Initial commit with current state

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+"images_dataset/" 

README.md

@@ -0,0 +1,13 @@
+---
+title: ComputerVision
+emoji: 📊
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: 5.15.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,477 @@
+from huggingface_hub import hf_hub_download, login
+import cv2
+import numpy as np
+import pickle  # for loading tile features and raw images
+from skimage.feature import local_binary_pattern, graycomatrix, graycoprops, hog
+from skimage.metrics import structural_similarity as ssim, peak_signal_noise_ratio as psnr
+from PIL import Image
+import gradio as gr
+import time
+import os
+
+# ---------------------------------------------------------------------
+# Feature Extraction Functions
+# ---------------------------------------------------------------------
+def get_average_color(image):
+    """Compute the average color (per channel) of the image (BGR format)."""
+    return np.mean(image, axis=(0, 1))
+
+def get_color_histogram(image, bins=(8, 8, 8)):
+    """Compute a normalized color histogram in HSV color space."""
+    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+    hist = cv2.calcHist([hsv], [0, 1, 2], None, bins, [0, 180, 0, 256, 0, 256])
+    cv2.normalize(hist, hist)
+    return hist.flatten()
+
+def get_lbp_histogram(image, numPoints=24, radius=8, bins=59):
+    """Compute a histogram of Local Binary Patterns (LBP) from the grayscale image."""
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    lbp = local_binary_pattern(gray, numPoints, radius, method="uniform")
+    hist, _ = np.histogram(lbp.ravel(), bins=bins, range=(0, bins))
+    hist = hist.astype("float")
+    hist /= (hist.sum() + 1e-7)
+    return hist
+
+def get_glcm_features(image, distances=[1, 2, 4], angles=[0, np.pi/4, np.pi/2, 3*np.pi/4],
+                      properties=('contrast', 'dissimilarity', 'homogeneity', 'energy', 'correlation', 'ASM')):
+    """
+    Compute GLCM (Gray Level Co-occurrence Matrix) features (Haralick features).
+    Returns a concatenated feature vector of all requested properties, for each distance & angle.
+    """
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    glcm = graycomatrix(gray, distances=distances, angles=angles, levels=256,
+                        symmetric=True, normed=True)
+    feats = []
+    for prop in properties:
+        vals = graycoprops(glcm, prop)
+        feats.append(vals.ravel())
+    return np.hstack(feats)
+
+def get_hog_features(image, orientations=9, pixels_per_cell=(8, 8),
+                     cells_per_block=(2, 2), block_norm='L2-Hys'):
+    """
+    Compute Histogram of Oriented Gradients (HOG) from the grayscale image.
+    The image is forcibly resized to 16×16 to avoid errors.
+    """
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    return hog(gray, orientations=orientations, pixels_per_cell=pixels_per_cell,
+               cells_per_block=(2, 2), block_norm=block_norm)
+
+def get_combined_features(image):
+    """
+    Compute and combine all features in the following order:
+      - Average Color (3)
+      - HSV Color Histogram (512)
+      - LBP Histogram (59)
+      - GLCM Features (72)
+      - HOG Features (36)
+    Total length = 682.
+    """
+    avg_color = get_average_color(image)
+    color_hist = get_color_histogram(image)
+    lbp_hist = get_lbp_histogram(image)
+    glcm_feats = get_glcm_features(image)
+    hog_feats = get_hog_features(cv2.resize(image, (16, 16), interpolation=cv2.INTER_LINEAR))
+    return np.concatenate([avg_color, color_hist, lbp_hist, glcm_feats, hog_feats])
+
+# ---------------------------------------------------------------------
+# Feature Dictionary and Order
+# ---------------------------------------------------------------------
+FEATURES = {
+    "Average Color (Color, Fast)": {
+        "func": get_average_color,
+        "range": (0, 3)
+    },
+    "HSV Histogram (Color Dist., Slow)": {
+        "func": get_color_histogram,
+        "range": (3, 515)
+    },
+    "LBP Histogram (Texture, Normal)": {
+        "func": get_lbp_histogram,
+        "range": (515, 574)
+    },
+    "GLCM Features (Texture Stats, Very Slow)": {
+        "func": get_glcm_features,
+        "range": (574, 646)
+    },
+    "HOG Features (Edges/Shapes, Normal)": {
+        "func": lambda image: get_hog_features(cv2.resize(image, (16, 16), interpolation=cv2.INTER_LINEAR)),
+        "range": (646, 682)
+    }
+}
+FEATURE_ORDER = list(FEATURES.keys())
+
+def get_selected_features(image, selected_features):
+    """
+    Compute and combine only the selected features from the image.
+    Uses the canonical order defined in FEATURE_ORDER.
+    """
+    feats = []
+    for feat in FEATURE_ORDER:
+        if feat in selected_features:
+            feats.append(FEATURES[feat]["func"](image))
+    if not feats:
+        return np.array([], dtype=np.float32)
+    return np.concatenate(feats).astype(np.float32)
+
+# ---------------------------------------------------------------------
+# Load Precomputed Tile Features & Raw Images
+# ---------------------------------------------------------------------
+try:
+    with open("tile_features.pkl", "rb") as f:
+        data = pickle.load(f)
+    tile_features = data["features"]   # shape: (num_tiles, 682)
+    tile_paths = data["paths"]         # e.g. "image_dataset/21837.jpg"
+    print(f"Loaded {len(tile_paths)} tile features from tile_features.pkl")
+except Exception as e:
+    print("Error loading tile features from local file:", e)
+    tile_features = None
+    tile_paths = None
+
+try:
+    with open("tile_images_raw.pkl", "rb") as f:
+        raw_images_dict = pickle.load(f)
+    print(f"Loaded raw images dictionary with {len(raw_images_dict)} entries.")
+except Exception as e:
+    print("Error loading raw images dictionary:", e)
+    raw_images_dict = {}
+
+def get_tile_image(tile_path):
+    """
+    Given a tile image path from the features pickle (e.g. "image_dataset\\21837.jpg"),
+    decode it from the raw_images_dict. Expects tile to be ~150×150.
+    """
+    fixed_path = tile_path.replace("\\", "/").strip()
+    if fixed_path in raw_images_dict:
+        raw_bytes = raw_images_dict[fixed_path]
+        np_arr = np.frombuffer(raw_bytes, np.uint8)
+        img = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
+        if img is None:
+            print(f"cv2.imdecode failed for: {fixed_path}")
+        return img
+    else:
+        print(f"Tile image '{fixed_path}' not found.")
+        return None
+
+# ---------------------------------------------------------------------
+# Mosaic Generation Function (No tile scaling, with Output Scale)
+# ---------------------------------------------------------------------
+def mosaic_generator(user_img, block_size, output_scale=1.0,
+                     weight_avg_color=1.0, weight_hsv_hist=1.0,
+                     weight_lbp=1.0, weight_glcm=1.0, weight_hog=1.0):
+    """
+    Create a photomosaic using 150×150 tiles with no tile scaling.
+    For each block (block_size x block_size) in the cropped user image, compute the selected features
+    and perform a weighted linear search over the tile_features subset.
+    
+    Each block is replaced by one 150×150 tile, so the final mosaic dimensions are:
+      (grid_rows * 150) x (grid_cols * 150).
+      
+    The final mosaic is optionally rescaled by output_scale (range: 0.1 to 1.0; default 1.0).
+    
+    Performance metrics (MSE, SSIM, PSNR) compare the original cropped image with a downsized version
+    of the mosaic.
+    """
+    start_time = time.time()
+
+    # Build a dictionary of feature weights.
+    feature_weights = {
+        "Average Color (Color, Fast)": weight_avg_color,
+        "HSV Histogram (Color Dist., Slow)": weight_hsv_hist,
+        "LBP Histogram (Texture, Normal)": weight_lbp,
+        "GLCM Features (Texture Stats, Very Slow)": weight_glcm,
+        "HOG Features (Edges/Shapes, Normal)": weight_hog
+    }
+    effective_features = [f for f in FEATURE_ORDER if feature_weights.get(f, 0) > 0]
+    if not effective_features:
+        return "Error: All features have weight = 0. Please enable at least one feature.", ""
+
+    # Build the tile_feature subset for only the selected features.
+    selected_indices = []
+    weights_list = []
+    for feat in FEATURE_ORDER:
+        if feat in effective_features:
+            start_idx, end_idx = FEATURES[feat]["range"]
+            selected_indices.extend(range(start_idx, end_idx))
+            w = feature_weights[feat]
+            weights_list.extend([w] * (end_idx - start_idx))
+    weights_vector = np.array(weights_list, dtype=np.float32)
+
+    if tile_features is None or tile_paths is None:
+        return "Error: Tile features are not loaded or incompatible.", ""
+    tile_subset = tile_features[:, selected_indices].astype(np.float32)
+
+    # Crop the user image to multiples of block_size.
+    user_img_bgr = cv2.cvtColor(np.array(user_img), cv2.COLOR_RGB2BGR)
+    h, w, _ = user_img_bgr.shape
+    new_h = (h // block_size) * block_size
+    new_w = (w // block_size) * block_size
+    user_img_bgr = user_img_bgr[:new_h, :new_w]
+    grid_rows = new_h // block_size
+    grid_cols = new_w // block_size
+
+    # Save a copy in RGB for final metrics.
+    original_cropped_rgb = cv2.cvtColor(user_img_bgr, cv2.COLOR_BGR2RGB)
+
+    mosaic_grid = []
+    progress = gr.Progress()  # Row-by-row progress bar
+
+    for row in range(grid_rows):
+        row_tiles = []
+        for col in range(grid_cols):
+            y = row * block_size
+            x = col * block_size
+            block = user_img_bgr[y:y+block_size, x:x+block_size]
+            
+            # Compute only the selected features from this block.
+            query_feats = get_selected_features(block, effective_features)
+            if query_feats.size == 0:
+                best_tile = np.zeros((150, 150, 3), dtype=np.uint8)
+                row_tiles.append(best_tile)
+                continue
+            query_feats = query_feats.reshape(1, -1)
+            query_weighted = query_feats * weights_vector
+            tile_subset_weighted = tile_subset * weights_vector
+
+            dists = np.linalg.norm(tile_subset_weighted - query_weighted, axis=1)
+            best_idx = np.argmin(dists)
+
+            best_tile_path = tile_paths[best_idx]
+            best_tile = get_tile_image(best_tile_path)
+            if best_tile is None:
+                best_tile = np.zeros((150, 150, 3), dtype=np.uint8)
+            else:
+                if best_tile.shape[:2] != (150, 150):
+                    best_tile = cv2.resize(best_tile, (150, 150), interpolation=cv2.INTER_AREA)
+            row_tiles.append(best_tile)
+
+        row_image = np.hstack(row_tiles)
+        mosaic_grid.append(row_image)
+        progress((row + 1) / grid_rows, desc=f"Processed row {row+1}/{grid_rows}")
+
+    mosaic_bgr = np.vstack(mosaic_grid)
+    mosaic_rgb = cv2.cvtColor(mosaic_bgr, cv2.COLOR_BGR2RGB)
+
+    # Rescale mosaic output if output_scale is not 1.0.
+    if output_scale != 1.0:
+        out_w = int(mosaic_rgb.shape[1] * output_scale)
+        out_h = int(mosaic_rgb.shape[0] * output_scale)
+        mosaic_rgb = cv2.resize(mosaic_rgb, (out_w, out_h), interpolation=cv2.INTER_LINEAR)
+
+    end_time = time.time()
+    processing_time = end_time - start_time
+    total_blocks = grid_rows * grid_cols
+
+    # For performance metrics, downsize the mosaic to match original cropped dimensions.
+    orig_h, orig_w, _ = original_cropped_rgb.shape
+    mosaic_resized_for_metrics = cv2.resize(mosaic_rgb, (orig_w, orig_h), interpolation=cv2.INTER_AREA)
+
+    mse_val = np.mean((original_cropped_rgb.astype(np.float32) - mosaic_resized_for_metrics.astype(np.float32)) ** 2)
+    ssim_val = ssim(original_cropped_rgb, mosaic_resized_for_metrics, channel_axis=-1, win_size=3)
+    psnr_val = psnr(original_cropped_rgb, mosaic_resized_for_metrics)
+
+    metrics = (
+        f"Processing Time: {processing_time:.2f} seconds\n"
+        f"Grid Dimensions: {grid_rows} rows x {grid_cols} columns\n"
+        f"Total Blocks Processed: {total_blocks}\n"
+        f"MSE: {mse_val:.2f}\n"
+        f"SSIM: {ssim_val:.4f}\n"
+        f"PSNR: {psnr_val:.2f} dB\n"
+    )
+
+    return mosaic_rgb, metrics
+
+# ---------------------------------------------------------------------
+# Gradio Interface
+# ---------------------------------------------------------------------
+iface = gr.Interface(
+    fn=mosaic_generator,
+    cache_examples=False,
+    inputs=[
+        gr.Image(type="pil", label="Upload Your Image"),
+        gr.Slider(minimum=1, maximum=32, step=1, value=10,
+                  label="Block Size (px) for Feature Extraction"),
+        gr.Slider(minimum=0.1, maximum=1.0, step=0.1, value=1.0,
+                  label="Output Scale (0.1 to 1.0)"),
+        # Feature priority sliders:
+        gr.Slider(minimum=0.0, maximum=5.0, step=0.1, value=3.5,
+                  label="Priority for Average Color (Fast)"),
+        gr.Slider(minimum=0.0, maximum=5.0, step=0.1, value=5.0,
+                  label="Priority for HSV Histogram (Slow)"),
+        gr.Slider(minimum=0.0, maximum=5.0, step=0.1, value=0.2,
+                  label="Priority for LBP Histogram (Normal)"),
+        gr.Slider(minimum=0.0, maximum=5.0, step=0.1, value=0.2,
+                  label="Priority for GLCM Features (Very Slow)"),
+        gr.Slider(minimum=0.0, maximum=5.0, step=0.1, value=0.2,
+                  label="Priority for HOG Features (Normal)")
+    ],
+    outputs=[
+        gr.Image(type="numpy", label="Mosaic Image", format="png"),
+        gr.Textbox(label="Performance Metrics")
+    ],
+    title="Photomosaic Generator",
+    description=(
+       "Turn your image into a mesmerizing photomosaic, crafted from carefully selected 150×150 tiles. Each block is replaced with the best-matching tile, preserving the essence of your original picture. Customize the look by adjusting feature priorities and output scale. The final mosaic captures intricate details while maintaining artistic harmony, creating a unique visual story."
+    ),
+    examples=[
+        # For each sample image, all examples use an output scale of 0.1.
+        # -- SAMPLE (1).png --
+        [
+            "samples/sample (1).png",
+            10,
+            0.1,   # Output Scale set to 0.1
+            5.0,   # Priority for Average Color only
+            0.0,   # HSV
+            0.0,   # LBP
+            0.0,   # GLCM
+            0.0    # HOG
+        ],
+        [
+            "samples/sample (1).png",
+            10,
+            0.1,   # Output Scale set to 0.1
+            0.0,   # Priority for Average Color
+            5.0,   # Priority for HSV only
+            0.0,   # LBP
+            0.0,   # GLCM
+            0.0    # HOG
+        ],
+        [
+            "samples/sample (1).png",
+            10,
+            0.1,   # Output Scale set to 0.1
+            3.5,   # Combination: avg=3.5, hsv=5, rest=0.2
+            5.0,
+            0.2,
+            0.2,
+            0.2
+        ],
+        # -- SAMPLE (2).jpg --
+        [
+            "samples/sample (2).jpg",
+            10,
+            0.1,
+            5.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0
+        ],
+        [
+            "samples/sample (2).jpg",
+            10,
+            0.1,
+            0.0,
+            5.0,
+            0.0,
+            0.0,
+            0.0
+        ],
+        [
+            "samples/sample (2).jpg",
+            10,
+            0.1,
+            3.5,
+            5.0,
+            0.2,
+            0.2,
+            0.2
+        ],
+        # -- SAMPLE (3).jpg --
+        [
+            "samples/sample (3).jpg",
+            10,
+            0.1,
+            5.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0
+        ],
+        [
+            "samples/sample (3).jpg",
+            10,
+            0.1,
+            0.0,
+            5.0,
+            0.0,
+            0.0,
+            0.0
+        ],
+        [
+            "samples/sample (3).jpg",
+            10,
+            0.1,
+            3.5,
+            5.0,
+            0.2,
+            0.2,
+            0.2
+        ],
+        # -- SAMPLE (4).webp --
+        [
+            "samples/sample (4).webp",
+            10,
+            0.1,
+            5.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0
+        ],
+        [
+            "samples/sample (4).webp",
+            10,
+            0.1,
+            0.0,
+            5.0,
+            0.0,
+            0.0,
+            0.0
+        ],
+        [
+            "samples/sample (4).webp",
+            10,
+            0.1,
+            3.5,
+            5.0,
+            0.2,
+            0.2,
+            0.2
+        ],
+        # -- SAMPLE (5).jpg --
+        [
+            "samples/sample (5).jpg",
+            10,
+            0.1,
+            5.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0
+        ],
+        [
+            "samples/sample (5).jpg",
+            10,
+            0.1,
+            0.0,
+            5.0,
+            0.0,
+            0.0,
+            0.0
+        ],
+        [
+            "samples/sample (5).jpg",
+            10,
+            0.1,
+            3.5,
+            5.0,
+            0.2,
+            0.2,
+            0.2
+        ]
+    ]
+)
+
+if __name__ == "__main__":
+    iface.launch()

imageUpload.py

@@ -0,0 +1,20 @@
+from huggingface_hub import HfApi
+
+# Create an API instance
+api = HfApi()
+
+# Start uploading the folder in the background (non-blocking)
+future = api.upload_large_folder(
+    repo_id="kalhar/images_dataset",          # Your repo ID
+    folder_path="C:/Users/kalha/Documents/NEU 5330/Lab 1/computer-vision-dataset/image_dataset",  # Local folder to upload
+    repo_type="dataset",                                 # Specify it's a dataset repo (if needed)
+)
+
+print("Upload started. Waiting for completion...")
+
+# Optionally, you can check if the future is done
+print("Upload done?", future.done())
+
+# Block until the upload completes and get the result
+result = future.result()
+print("Folder uploaded successfully!")

imagesPickleCreater.py

@@ -0,0 +1,23 @@
+import os
+import pickle
+
+# Path to your local image dataset folder
+image_folder = "C:/Users/kalha/Documents/NEU 5330/Lab 1/images_dataset"  # Adjust if needed
+
+tile_images = {}
+
+# Iterate over all JPEG files in the folder
+for filename in os.listdir(image_folder):
+    if filename.lower().endswith(".jpg"):
+        key = f"images_dataset/{filename}"  # key with folder prefix
+        filepath = os.path.join(image_folder, filename)
+        with open(filepath, "rb") as f:
+            data = f.read()  # read raw bytes without decoding
+        tile_images[key] = data
+        print(f"Stored {key}")
+
+# Save the dictionary of raw image bytes to a pickle file
+with open("tile_images_raw.pkl", "wb") as f:
+    pickle.dump(tile_images, f)
+
+print("Saved tile images to tile_images_raw.pkl")

prepare_data.py

@@ -0,0 +1,162 @@
+import os
+import cv2
+import numpy as np
+import pickle
+from skimage.feature import local_binary_pattern, graycomatrix, graycoprops, hog
+
+# ---------------------------------------------------------------------
+# Feature Extraction Functions
+# ---------------------------------------------------------------------
+def get_average_color(image):
+    """Compute the average color of the image in BGR space."""
+    return np.mean(image, axis=(0, 1))
+
+def get_color_histogram(image, bins=(8, 8, 8)):
+    """
+    Compute a normalized color histogram in HSV space.
+    """
+    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+    hist = cv2.calcHist([hsv], [0, 1, 2], None, bins, [0, 180, 0, 256, 0, 256])
+    cv2.normalize(hist, hist)
+    return hist.flatten()
+
+def get_lbp_histogram(image, numPoints=24, radius=8, bins=59):
+    """
+    Compute a histogram of Local Binary Patterns (LBP) from the grayscale image.
+    """
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    lbp = local_binary_pattern(gray, numPoints, radius, method="uniform")
+    hist, _ = np.histogram(lbp.ravel(), bins=bins, range=(0, bins))
+    hist = hist.astype("float")
+    hist /= (hist.sum() + 1e-7)
+    return hist
+
+def get_glcm_features(image,
+                      distances=[1, 2, 4],
+                      angles=[0, np.pi/4, np.pi/2, 3*np.pi/4],
+                      properties=('contrast', 'dissimilarity', 'homogeneity', 'energy', 'correlation', 'ASM')):
+    """
+    Compute GLCM (Gray Level Co-occurrence Matrix) based features (a.k.a. Haralick features).
+    distances: List of pixel distances.
+    angles: List of angles in radians.
+    properties: GLCM properties to compute for each distance and angle.
+    Returns a concatenated feature vector of all properties.
+    """
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    glcm = graycomatrix(gray,
+                        distances=distances,
+                        angles=angles,
+                        levels=256,
+                        symmetric=True,
+                        normed=True)
+    feats = []
+    for prop in properties:
+        vals = graycoprops(glcm, prop)
+        feats.append(vals.ravel())  # flatten the NxM result for this property
+    glcm_features = np.hstack(feats)
+    return glcm_features
+
+def get_hog_features(image,
+                     orientations=9,
+                     pixels_per_cell=(8, 8),
+                     cells_per_block=(2, 2),
+                     block_norm='L2-Hys'):
+    """
+    Compute Histogram of Oriented Gradients (HOG) from the grayscale image.
+    By default, requires at least 16×16.
+    """
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    fd = hog(gray,
+             orientations=orientations,
+             pixels_per_cell=pixels_per_cell,
+             cells_per_block=cells_per_block,
+             block_norm=block_norm)
+    return fd
+
+def get_combined_features(image):
+    """
+    Combine the average color, color histogram, LBP histogram,
+    GLCM-based features, and HOG features into one feature vector.
+    
+    IMPORTANT: We force-resize the tile to 16×16 (for HOG) 
+               if we want to match the mosaic script that 
+               also forces 16×16 before HOG.
+    """
+    # -- Compute features from original image size --
+    avg_color  = get_average_color(image)
+    color_hist = get_color_histogram(image)
+    lbp_hist   = get_lbp_histogram(image)
+    glcm_feats = get_glcm_features(image)
+
+    # -- Force-resize to 16×16 for HOG to match mosaic script --
+    hog_input  = cv2.resize(image, (16, 16), interpolation=cv2.INTER_LINEAR)
+    hog_feats  = get_hog_features(hog_input)
+
+    # -- Concatenate everything --
+    combined = np.concatenate([
+        avg_color,
+        color_hist,
+        lbp_hist,
+        glcm_feats,
+        hog_feats
+    ])
+    return combined
+
+# ---------------------------------------------------------------------
+# Main Data Preparation Function
+# ---------------------------------------------------------------------
+def prepare_tile_data(tiles_folder, output_file):
+    """
+    Process all images in 'tiles_folder' to compute their feature vectors.
+    Force-resize each tile to 16×16 for HOG (same as mosaic script).
+    Save features + file paths to a pickle file.
+    """
+    tile_features = []
+    tile_paths = []
+    valid_extensions = ('.jpg', '.jpeg', '.png', '.bmp', '.tiff')
+
+    # Gather all valid image files
+    all_files = [f for f in os.listdir(tiles_folder) if f.lower().endswith(valid_extensions)]
+    total_files = len(all_files)
+
+    if total_files == 0:
+        print("No valid image files found in", tiles_folder)
+        return
+
+    print(f"Found {total_files} image(s) in '{tiles_folder}'. Starting feature extraction...")
+
+    for idx, filename in enumerate(all_files, start=1):
+        filepath = os.path.join(tiles_folder, filename)
+        image = cv2.imread(filepath)
+        if image is None:
+            print(f"[{idx}/{total_files}] Warning: Failed to read {filepath}")
+            continue
+
+        # Extract combined features (with forced 16×16 for HOG)
+        features = get_combined_features(image)
+
+        tile_features.append(features)
+        tile_paths.append(filepath)
+
+        # Log progress
+        print(f"[{idx}/{total_files}] Processed: {filename}")
+
+    # Convert to NumPy array (float32 for KDTree)
+    tile_features = np.array(tile_features, dtype=np.float32)
+
+    # Save features and paths
+    data = {'features': tile_features, 'paths': tile_paths}
+    with open(output_file, 'wb') as f:
+        pickle.dump(data, f)
+
+    print(f"Saved features for {len(tile_paths)} tiles to {output_file}")
+
+# ---------------------------------------------------------------------
+# Script Entry Point
+# ---------------------------------------------------------------------
+if __name__ == "__main__":
+    # Adjust as needed:
+    tiles_folder = "images_dataset"    # Folder with tile images
+    output_file  = "tile_features.pkl" # Pickle file for precomputed features
+
+    prepare_tile_data(tiles_folder, output_file)

requirements.txt

@@ -0,0 +1,6 @@
+opencv-python
+numpy
+scikit-learn
+scikit-image
+Pillow
+gradio

tile_features.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61d9726b1a9097178fbe234728babb0053ac76fb9e43e8dd0ba1765e6fd046d2
+size 67032135

tile_images_raw.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5135bfa6bf37af29b61509deaf06e224926a15a5177f80f8acdcb2655a21c51b
+size 369696804