intermediary changes

app.py

@@ -3,35 +3,65 @@ import cv2
 import numpy as np
 from PIL import Image
 import os
-from logic.imgPreprocess import resize_img
+from logic.imgPreprocess import resize_img, color_quantize
+from logic.imgGrid import segment_image_grid
+from logic.tileMapping import load_tile_images, map_tiles_to_grid
+from logic.perfMetric import mse, ssim_metric, timed
 
-def preprocess_image(image: Image.Image, size: int):
-    # Resize using the resize_img function directly on the PIL Image
+def preprocess_and_mosaic(image: Image.Image, size: int, grid_size: int, n_colors: int):
+    # Apply color quantization
+    quantized_img, color_centers = color_quantize(image, n_colors)
+    image = Image.fromarray(cv2.cvtColor(quantized_img, cv2.COLOR_BGR2RGB))
+    # Resize image
     resized_np = resize_img(image, size=(size, size))
-    # Convert back to RGB for display (cv2 uses BGR)
-    resized_rgb = cv2.cvtColor(resized_np, cv2.COLOR_BGR2RGB)
-    return Image.fromarray(resized_rgb)
-
+    cell_size = size // grid_size
+    crop_size = cell_size * grid_size
+    # Crop resized image to match mosaic size
+    resized_np_cropped = resized_np[:crop_size, :crop_size]
+    # Segment grid and classify colors
+    grid_labels, seg_time = timed(segment_image_grid)(resized_np_cropped, grid_size, color_centers)
+    # Load/generate tiles
+    tiles = load_tile_images('data/tiles', n_colors, cell_size)
+    # Map tiles to grid
+    mosaic_img, mosaic_time = timed(map_tiles_to_grid)(grid_labels, tiles, cell_size)
+    # Metrics
+    mse_val = mse(resized_np_cropped, mosaic_img)
+    ssim_val = ssim_metric(resized_np_cropped, mosaic_img)
+    # Convert for display
+    orig_disp = Image.fromarray(cv2.cvtColor(resized_np_cropped, cv2.COLOR_BGR2RGB))
+    mosaic_disp = Image.fromarray(cv2.cvtColor(mosaic_img, cv2.COLOR_BGR2RGB))
+    # Segmented image: show each cell as its cluster color
+    seg_img = np.zeros_like(resized_np_cropped)
+    for i in range(grid_size):
+        for j in range(grid_size):
+            seg_img[i*cell_size:(i+1)*cell_size, j*cell_size:(j+1)*cell_size] = color_centers[grid_labels[i,j]]
+    seg_disp = Image.fromarray(cv2.cvtColor(seg_img, cv2.COLOR_BGR2RGB))
+    # Info
+    info = f"MSE: {mse_val:.2f}\nSSIM: {ssim_val:.3f}\nSegmentation: {seg_time:.3f}s\nMosaic: {mosaic_time:.3f}s"
+    return orig_disp, seg_disp, mosaic_disp, info
 
 # Only show example images for upload, no grid or extra info
 example_dir = "data/images"
 example_files = [os.path.join(example_dir, f) for f in [
     "bird.JPG", "cheetah.JPG", "lion.JPG", "oryx.JPG", "ostrich.JPG", "rhino.JPG", "zebra.JPG"
 ]]
+examples = [[f, 400, 32, 8] for f in example_files]
 
-inputs = [
-    gr.Image(type="pil", label="Upload or Select Example Image"),
-]
-
-outputs = gr.Image(type="pil", label="Resized Image")
-
-examples = [[f, 400] for f in example_files]
+with gr.Blocks() as demo:
+    gr.Markdown("# Image Mosaic Generator")
+    with gr.Row():
+        image_input = gr.Image(type="pil", label="Upload or Select Example Image")
+        size_slider = gr.Slider(100, 800, value=400, step=10, label="Resize (pixels)")
+        grid_slider = gr.Slider(8, 64, value=32, step=1, label="Grid Size (NxN)")
+        color_slider = gr.Slider(2, 16, value=8, step=1, label="Number of Colors (Quantization)")
+    mosaic_btn = gr.Button("Generate Mosaic")
+    with gr.Row():
+        orig_out = gr.Image(label="Original (Resized)")
+        seg_out = gr.Image(label="Segmented Grid")
+        mosaic_out = gr.Image(label="Mosaic Image")
+    info_out = gr.Textbox(label="Metrics & Timing", interactive=False)
+    gr.Examples(examples=examples, inputs=[image_input, size_slider, grid_slider, color_slider], label="Example Images")
+    
+    mosaic_btn.click(preprocess_and_mosaic, inputs=[image_input, size_slider, grid_slider, color_slider], outputs=[orig_out, seg_out, mosaic_out, info_out])
 
-demo = gr.Interface(
-    fn=preprocess_image,
-    inputs=inputs,
-    outputs=outputs,
-    examples=examples,
-    title="Image Resizer"
-)
 demo.launch()

logic/imgGrid.py

@@ -0,0 +1,17 @@
+import numpy as np
+from PIL import Image
+import cv2
+from sklearn.cluster import KMeans
+
+def segment_image_grid(image: np.ndarray, grid_size: int, color_centers: np.ndarray):
+    h, w, c = image.shape
+    cell_h, cell_w = h // grid_size, w // grid_size
+    image_cropped = image[:cell_h*grid_size, :cell_w*grid_size]
+    cells = image_cropped.reshape(grid_size, cell_h, grid_size, cell_w, c)
+    cells = cells.transpose(0,2,1,3,4).reshape(grid_size*grid_size, cell_h*cell_w, c)
+    cell_means = cells.mean(axis=1)
+    # Assign each cell to nearest color center
+    dists = np.linalg.norm(cell_means[:, None, :] - color_centers[None, :, :], axis=2)
+    labels = np.argmin(dists, axis=1)
+    grid_labels = labels.reshape(grid_size, grid_size)
+    return grid_labels

logic/imgPreprocess.py

@@ -21,25 +21,25 @@ def resize_img(image: Image.Image, size=(400, 400)) -> np.ndarray:
     resized_np = cv2.resize(image_np, size, interpolation=cv2.INTER_LANCZOS4)
     return resized_np
 
-
-# def color_quantize(image: Image.Image, n_colors: int = 8) -> Image.Image:
-#     """
-#     Apply color quantization to an image using KMeans clustering.
-#     Args:
-#         image (PIL.Image.Image): Input image.
-#         n_colors (int): Number of colors for quantization.
-#     Returns:
-#         PIL.Image.Image: Quantized image.
-#     """
-#     # Convert image to numpy array
-#     img_np = np.array(image)
-#     shape = img_np.shape
-#     # Flatten the image to (num_pixels, 3)
-#     img_flat = img_np.reshape(-1, 3)
-#     # Fit KMeans
-#     kmeans = KMeans(n_clusters=n_colors, random_state=42)
-#     labels = kmeans.fit_predict(img_flat)
-#     quantized_flat = kmeans.cluster_centers_[labels].astype(np.uint8)
-#     # Reshape back to original image shape
-#     quantized_img = quantized_flat.reshape(shape)
-#     return Image.fromarray(quantized_img)
+def color_quantize(image: Image.Image, n_colors: int = 8):
+    """
+    Apply color quantization to an image using KMeans clustering.
+    Args:
+        image (PIL.Image.Image): Input image.
+        n_colors (int): Number of colors for quantization.
+    Returns:
+        quantized_img (np.ndarray): Quantized image as np array (BGR format)
+        color_centers (np.ndarray): Array of color centers
+    """
+    img_np = np.array(image)
+    shape = img_np.shape
+    img_flat = img_np.reshape(-1, 3)
+    kmeans = KMeans(n_clusters=n_colors, random_state=42)
+    labels = kmeans.fit_predict(img_flat)
+    quantized_flat = kmeans.cluster_centers_[labels].astype(np.uint8)
+    quantized_img = quantized_flat.reshape(shape)
+    # Convert to BGR for consistency
+    if quantized_img.shape[-1] == 3:
+        quantized_img = cv2.cvtColor(quantized_img, cv2.COLOR_RGB2BGR)
+    color_centers = kmeans.cluster_centers_.astype(np.uint8)
+    return quantized_img, color_centers

logic/mosaic_logic.py

@@ -0,0 +1,56 @@
+import numpy as np
+from PIL import Image
+import cv2
+import time
+import os
+from skimage.metrics import structural_similarity as ssim
+
+def segment_image_grid(image: np.ndarray, grid_size: int, n_colors: int = 8):
+    h, w, c = image.shape
+    cell_h, cell_w = h // grid_size, w // grid_size
+    image_cropped = image[:cell_h*grid_size, :cell_w*grid_size]
+    cells = image_cropped.reshape(grid_size, cell_h, grid_size, cell_w, c)
+    cells = cells.transpose(0,2,1,3,4).reshape(grid_size*grid_size, cell_h*cell_w, c)
+    cell_means = cells.mean(axis=1)
+    from sklearn.cluster import KMeans
+    kmeans = KMeans(n_clusters=n_colors, random_state=42)
+    labels = kmeans.fit_predict(cell_means)
+    grid_labels = labels.reshape(grid_size, grid_size)
+    return grid_labels, kmeans.cluster_centers_.astype(np.uint8)
+
+def load_tile_images(tile_dir, n_colors, cell_size):
+    tiles = []
+    if os.path.isdir(tile_dir):
+        files = sorted([os.path.join(tile_dir, f) for f in os.listdir(tile_dir) if f.lower().endswith(('.png','.jpg','.jpeg'))])
+        for f in files[:n_colors]:
+            tile = np.array(Image.open(f).resize((cell_size, cell_size)))
+            tiles.append(tile)
+    while len(tiles) < n_colors:
+        color = np.random.randint(0,255,3)
+        tile = np.ones((cell_size, cell_size, 3), dtype=np.uint8) * color
+        tiles.append(tile)
+    return tiles
+
+def map_tiles_to_grid(grid_labels, tiles, cell_size):
+    grid_size = grid_labels.shape[0]
+    mosaic = np.zeros((grid_size*cell_size, grid_size*cell_size, 3), dtype=np.uint8)
+    for i in range(grid_size):
+        for j in range(grid_size):
+            mosaic[i*cell_size:(i+1)*cell_size, j*cell_size:(j+1)*cell_size] = tiles[grid_labels[i,j]]
+    return mosaic
+
+def mse(img1, img2):
+    return np.mean((img1.astype(np.float32) - img2.astype(np.float32))**2)
+
+def ssim_metric(img1, img2):
+    img1_gray = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
+    img2_gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
+    return ssim(img1_gray, img2_gray)
+
+def timed(func):
+    def wrapper(*args, **kwargs):
+        start = time.time()
+        result = func(*args, **kwargs)
+        elapsed = time.time() - start
+        return result, elapsed
+    return wrapper

logic/perfMetric.py

@@ -0,0 +1,20 @@
+import numpy as np
+import cv2
+from skimage.metrics import structural_similarity as ssim
+import time
+
+def mse(img1, img2):
+    return np.mean((img1.astype(np.float32) - img2.astype(np.float32))**2)
+
+def ssim_metric(img1, img2):
+    img1_gray = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
+    img2_gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
+    return ssim(img1_gray, img2_gray)
+
+def timed(func):
+    def wrapper(*args, **kwargs):
+        start = time.time()
+        result = func(*args, **kwargs)
+        elapsed = time.time() - start
+        return result, elapsed
+    return wrapper

logic/tileMapping.py

@@ -0,0 +1,24 @@
+import numpy as np
+import os
+from PIL import Image
+
+def load_tile_images(tile_dir, n_colors, cell_size):
+    tiles = []
+    if os.path.isdir(tile_dir):
+        files = sorted([os.path.join(tile_dir, f) for f in os.listdir(tile_dir) if f.lower().endswith(('.png','.jpg','.jpeg'))])
+        for f in files[:n_colors]:
+            tile = np.array(Image.open(f).resize((cell_size, cell_size)))
+            tiles.append(tile)
+    while len(tiles) < n_colors:
+        color = np.random.randint(0,255,3)
+        tile = np.ones((cell_size, cell_size, 3), dtype=np.uint8) * color
+        tiles.append(tile)
+    return tiles
+
+def map_tiles_to_grid(grid_labels, tiles, cell_size):
+    grid_size = grid_labels.shape[0]
+    mosaic = np.zeros((grid_size*cell_size, grid_size*cell_size, 3), dtype=np.uint8)
+    for i in range(grid_size):
+        for j in range(grid_size):
+            mosaic[i*cell_size:(i+1)*cell_size, j*cell_size:(j+1)*cell_size] = tiles[grid_labels[i,j]]
+    return mosaic

resize_image.py

@@ -1,12 +0,0 @@
-from PIL import Image
-
-def resize_image(image: Image.Image, size: tuple = (800, 800)) -> Image.Image:
-    """
-    Resize the input image to a fixed size (default 800x800 pixels).
-    Args:
-        image (PIL.Image.Image): Input image.
-        size (tuple): Target size as (width, height).
-    Returns:
-        PIL.Image.Image: Resized image.
-    """
-    return image.resize(size, Image.LANCZOS)