Adding all files

Cache_Builder.py

@@ -0,0 +1,234 @@
+"""
+cache_builder.py
+Builds optimized tile caches for fast mosaic generation.
+Run this once to create cache files, then use for instant tile loading.
+"""
+
+import numpy as np
+import cv2
+from pathlib import Path
+from typing import Tuple
+from sklearn.cluster import MiniBatchKMeans
+from sklearn.neighbors import NearestNeighbors
+from sklearn.metrics.pairwise import euclidean_distances
+from tqdm import tqdm
+import pickle
+import time
+import warnings
+from collections import defaultdict
+
+class TileCacheBuilder:
+    """Builds optimized tile caches with rotation variants and color subgrouping."""
+    
+    def __init__(self, tile_folder: str, 
+                 tile_size: Tuple[int, int] = (32, 32),
+                 colour_bins: int = 8,
+                 enable_rotation: bool = True):
+        """
+        Initialize cache builder.
+        
+        Args:
+            tile_folder: Path to folder containing tile images
+            tile_size: Target tile size (width, height)
+            colour_bins: Number of colour categories for subgrouping
+            enable_rotation: Whether to create rotated variants
+        """
+        self.tile_folder = Path(tile_folder)
+        self.tile_size = tile_size
+        self.colour_bins = colour_bins
+        self.enable_rotation = enable_rotation
+        self.rotation_angles = [0, 90, 180, 270] if enable_rotation else [0]
+        
+        # Data containers
+        self.tile_images = []
+        self.tile_colours = []
+        self.tile_names = []
+        self.colour_palette = None
+        self.colour_groups = defaultdict(list)
+        self.colour_indices = {}
+        
+        print(f"Tile Cache Builder")
+        print(f"Folder: {tile_folder}")
+        print(f"Tile size: {tile_size[0]}x{tile_size[1]}")
+        print(f"Colour bins: {colour_bins}")
+        print(f"Rotation: {enable_rotation}")
+    
+    def build_cache(self, output_file: str, force_rebuild: bool = False) -> bool:
+        """Build complete optimized tile cache."""
+        if Path(output_file).exists() and not force_rebuild:
+            print(f"Cache exists: {output_file} (use force_rebuild=True to rebuild)")
+            return False
+        
+        print("Building comprehensive tile cache...")
+        total_start = time.time()
+        
+        try:
+            self._load_base_tiles()
+            if self.enable_rotation:
+                self._create_rotated_variants()
+            self._analyze_tile_colors()
+            self._create_color_subgroups()
+            self._save_cache(output_file)
+            
+            total_time = time.time() - total_start
+            print(f"Cache built in {total_time:.2f} seconds: {output_file}")
+            return True
+            
+        except Exception as e:
+            print(f"Cache building failed: {e}")
+            return False
+    
+    def _load_base_tiles(self):
+        """Load base tiles from folder."""
+        if not self.tile_folder.exists():
+            raise ValueError(f"Tile folder not found: {self.tile_folder}")
+        
+        # Find all image files
+        extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff']
+        image_files = []
+        for ext in extensions:
+            image_files.extend(self.tile_folder.glob(f'*{ext}'))
+            image_files.extend(self.tile_folder.glob(f'*{ext.upper()}'))
+        
+        if not image_files:
+            raise ValueError(f"No images found in {self.tile_folder}")
+        
+        print(f"Loading {len(image_files)} base tiles...")
+        
+        for img_path in tqdm(image_files, desc="Loading tiles"):
+            try:
+                img = cv2.imread(str(img_path))
+                if img is not None:
+                    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+                    
+                    # Resize to target size
+                    if img_rgb.shape[:2] != (self.tile_size[1], self.tile_size[0]):
+                        img_rgb = cv2.resize(img_rgb, self.tile_size, interpolation=cv2.INTER_AREA)
+                    
+                    self.tile_images.append(img_rgb)
+                    self.tile_names.append(img_path.name)
+                    
+            except Exception as e:
+                print(f"Error loading {img_path}: {e}")
+        
+        print(f"Loaded {len(self.tile_images)} base tiles")
+    
+    def _create_rotated_variants(self):
+        """Create 90, 180, 270 degree rotated variants."""
+        print("Creating rotated variants...")
+        
+        base_count = len(self.tile_images)
+        rotated_images = []
+        rotated_names = []
+        
+        for i in range(base_count):
+            base_image = self.tile_images[i]
+            base_name = self.tile_names[i]
+            
+            # Create 3 rotated versions
+            for angle in [90, 180, 270]:
+                if angle == 90:
+                    rotated = cv2.rotate(base_image, cv2.ROTATE_90_CLOCKWISE)
+                elif angle == 180:
+                    rotated = cv2.rotate(base_image, cv2.ROTATE_180)
+                elif angle == 270:
+                    rotated = cv2.rotate(base_image, cv2.ROTATE_90_COUNTERCLOCKWISE)
+                
+                rotated_images.append(rotated)
+                rotated_names.append(f"{base_name}_rot{angle}")
+        
+        # Add to main collections
+        self.tile_images.extend(rotated_images)
+        self.tile_names.extend(rotated_names)
+        
+        print(f"Expanded to {len(self.tile_images)} tiles with rotation")
+    
+    def _analyze_tile_colors(self):
+        """Calculate average colors for all tiles."""
+        print("Analyzing tile colors...")
+        
+        for tile_image in tqdm(self.tile_images, desc="Color analysis"):
+            avg_colour = np.mean(tile_image, axis=(0, 1))
+            self.tile_colours.append(avg_colour)
+        
+        self.tile_colours = np.array(self.tile_colours)
+        print(f"Color analysis complete: {len(self.tile_colours)} tiles")
+    
+    def _create_color_subgroups(self):
+        """Create color palette and subgroup tiles for fast searching."""
+        print(f"Creating {self.colour_bins}-color palette...")
+        
+        # Create color palette using Mini-Batch K-means
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=UserWarning)
+            
+            batch_size = min(max(len(self.tile_colours) // 10, 100), 1000)
+            kmeans = MiniBatchKMeans(
+                n_clusters=self.colour_bins, 
+                batch_size=batch_size,
+                random_state=42, 
+                n_init=3
+            )
+            kmeans.fit(self.tile_colours)
+            self.colour_palette = kmeans.cluster_centers_
+        
+        # Assign tiles to color bins
+        for i, tile_colour in enumerate(self.tile_colours):
+            distances = euclidean_distances(
+                tile_colour.reshape(1, -1), 
+                self.colour_palette
+            )[0]
+            closest_bin = np.argmin(distances)
+            self.colour_groups[closest_bin].append(i)
+        
+        # Create search indices for each group
+        for bin_id, tile_indices in self.colour_groups.items():
+            if len(tile_indices) > 0:
+                group_colours = self.tile_colours[tile_indices]
+                
+                index = NearestNeighbors(
+                    n_neighbors=min(10, len(tile_indices)),
+                    metric='euclidean',
+                    algorithm='kd_tree'
+                )
+                index.fit(group_colours)
+                self.colour_indices[bin_id] = (index, tile_indices)
+        
+        print(f"Created {len(self.colour_groups)} color subgroups")
+    
+    def _save_cache(self, output_file: str):
+        """Save processed data to cache file."""
+        cache_data = {
+            'tile_images': np.array(self.tile_images),
+            'tile_colours': self.tile_colours,
+            'tile_names': self.tile_names,
+            'colour_palette': self.colour_palette,
+            'colour_groups': dict(self.colour_groups),
+            'colour_indices': self.colour_indices,
+            'tile_size': self.tile_size,
+            'colour_bins': self.colour_bins,
+            'enable_rotation': self.enable_rotation,
+            'build_timestamp': time.time()
+        }
+        
+        with open(output_file, 'wb') as f:
+            pickle.dump(cache_data, f)
+        
+        cache_size_mb = Path(output_file).stat().st_size / 1024 / 1024
+        print(f"Cache saved: {cache_size_mb:.1f}MB")
+
+if __name__ == "__main__":
+    # Build cache with your settings
+    builder = TileCacheBuilder(
+        tile_folder="extracted_images",
+        tile_size=(32, 32),
+        colour_bins=8,
+        enable_rotation=True
+    )
+    
+    success = builder.build_cache("tiles_cache.pkl", force_rebuild=True)
+    
+    if success:
+        print("Cache building completed! You can now run main.py")
+    else:
+        print("Cache building failed!")

ColourClassification.py

@@ -0,0 +1,511 @@
+import numpy as np
+import cv2
+from sklearn.cluster import KMeans
+from sklearn.preprocessing import LabelEncoder
+import matplotlib.pyplot as plt
+from typing import Tuple, List, Dict, Optional
+from dataclasses import dataclass
+from enum import Enum
+import seaborn as sns
+
+class ColorClassificationMethod(Enum):
+    """Different methods for classifying cell colors."""
+    DOMINANT_COLOR = "dominant_color"
+    AVERAGE_COLOR = "average_color"
+    HISTOGRAM_BINS = "histogram_bins"
+    HSV_QUANTIZATION = "hsv_quantization"
+
+@dataclass
+class GridCell:
+    """Represents a single grid cell with its properties."""
+    row: int
+    col: int
+    average_color: np.ndarray
+    dominant_color: np.ndarray
+    brightness: float
+    saturation: float
+    hue: float
+    color_category: int
+    pixel_data: np.ndarray
+
+class ImageGridAnalyzer:
+    """
+    Analyzes images by dividing them into grids and classifying each cell's color properties.
+    Uses vectorized NumPy operations for high performance.
+    """
+    
+    def __init__(self, grid_size: Tuple[int, int] = (32, 32),
+                 classification_method: ColorClassificationMethod = ColorClassificationMethod.DOMINANT_COLOR,
+                 n_color_categories: int = 16):
+        """
+        Initialize the grid analyzer.
+        
+        Args:
+            grid_size: (rows, cols) for the grid division
+            classification_method: Method to classify cell colors
+            n_color_categories: Number of color categories for classification
+        """
+        self.grid_size = grid_size
+        self.classification_method = classification_method
+        self.n_color_categories = n_color_categories
+        self.color_classifier = None
+        self.category_colors = None
+        
+    def divide_image_into_grid(self, image: np.ndarray) -> Tuple[np.ndarray, Tuple[int, int]]:
+        """
+        Divide image into a grid using vectorized operations.
+        
+        Args:
+            image: Input image (H, W, C)
+            
+        Returns:
+            Grid of cells (grid_rows, grid_cols, tile_height, tile_width, channels)
+            Tuple of (tile_height, tile_width)
+        """
+        h, w, c = image.shape
+        grid_rows, grid_cols = self.grid_size
+        
+        # Calculate tile dimensions
+        tile_h = h // grid_rows
+        tile_w = w // grid_cols
+        
+        # Adjust image size to fit grid perfectly (crop if necessary)
+        adjusted_h = tile_h * grid_rows
+        adjusted_w = tile_w * grid_cols
+        image = image[:adjusted_h, :adjusted_w]
+        
+        # Vectorized grid division using reshape and transpose
+        # This is much faster than nested loops
+        grid = image.reshape(grid_rows, tile_h, grid_cols, tile_w, c)
+        grid = grid.transpose(0, 2, 1, 3, 4)  # (grid_rows, grid_cols, tile_h, tile_w, c)
+        
+        return grid, (tile_h, tile_w)
+    
+    def analyze_grid_colors_vectorized(self, grid: np.ndarray) -> Dict[str, np.ndarray]:
+        """
+        Analyze color properties of all grid cells using vectorized operations.
+        
+        Args:
+            grid: Grid of cells (grid_rows, grid_cols, tile_h, tile_w, c)
+            
+        Returns:
+            Dictionary containing vectorized analysis results
+        """
+        grid_rows, grid_cols, tile_h, tile_w, c = grid.shape
+        
+        # Reshape for vectorized operations: (total_cells, pixels_per_cell, channels)
+        cells_flat = grid.reshape(grid_rows * grid_cols, tile_h * tile_w, c)
+        
+        # Calculate average colors for all cells at once
+        average_colors = np.mean(cells_flat, axis=1)  # (total_cells, c)
+        
+        # Calculate dominant colors using vectorized approach
+        dominant_colors = self._calculate_dominant_colors_vectorized(cells_flat)
+        
+        # Convert to HSV for additional analysis
+        hsv_averages = self._rgb_to_hsv_vectorized(average_colors)
+        
+        # Calculate brightness (V in HSV)
+        brightness = hsv_averages[:, 2]
+        
+        # Calculate saturation
+        saturation = hsv_averages[:, 1]
+        
+        # Calculate hue
+        hue = hsv_averages[:, 0]
+        
+        # Reshape results back to grid format
+        results = {
+            'average_colors': average_colors.reshape(grid_rows, grid_cols, c),
+            'dominant_colors': dominant_colors.reshape(grid_rows, grid_cols, c),
+            'brightness': brightness.reshape(grid_rows, grid_cols),
+            'saturation': saturation.reshape(grid_rows, grid_cols),
+            'hue': hue.reshape(grid_rows, grid_cols),
+            'cells_data': grid  # Keep original cell data
+        }
+        
+        return results
+    
+    def _calculate_dominant_colors_vectorized(self, cells_flat: np.ndarray) -> np.ndarray:
+        """
+        Calculate dominant color for each cell using vectorized operations.
+        
+        Args:
+            cells_flat: Flattened cells (total_cells, pixels_per_cell, channels)
+            
+        Returns:
+            Dominant colors for all cells (total_cells, channels)
+        """
+        import warnings
+        
+        total_cells, pixels_per_cell, c = cells_flat.shape
+        dominant_colors = np.zeros((total_cells, c))
+        
+        # Process cells in batches for memory efficiency
+        batch_size = 100
+        for i in range(0, total_cells, batch_size):
+            end_idx = min(i + batch_size, total_cells)
+            batch = cells_flat[i:end_idx]
+            
+            for j, cell_pixels in enumerate(batch):
+                # Check for color diversity first
+                unique_pixels = np.unique(cell_pixels, axis=0)
+                
+                if len(unique_pixels) >= 3 and pixels_per_cell > 100:
+                    # Use k-means for larger cells with sufficient color diversity
+                    with warnings.catch_warnings():
+                        warnings.filterwarnings("ignore", category=UserWarning)
+                        warnings.filterwarnings("ignore", message=".*ConvergenceWarning.*")
+                        
+                        kmeans = KMeans(n_clusters=min(3, len(unique_pixels)), 
+                                      random_state=42, n_init=5)
+                        labels = kmeans.fit_predict(cell_pixels)
+                        # Get the most frequent cluster center
+                        unique_labels, counts = np.unique(labels, return_counts=True)
+                        dominant_idx = unique_labels[np.argmax(counts)]
+                        dominant_colors[i + j] = kmeans.cluster_centers_[dominant_idx]
+                elif len(unique_pixels) >= 2:
+                    # Use most frequent color for limited diversity
+                    unique_colors, counts = np.unique(cell_pixels, axis=0, return_counts=True)
+                    dominant_colors[i + j] = unique_colors[np.argmax(counts)]
+                else:
+                    # Use simple average for uniform cells
+                    dominant_colors[i + j] = np.mean(cell_pixels, axis=0)
+        
+        return dominant_colors
+    
+    def _rgb_to_hsv_vectorized(self, rgb_colors: np.ndarray) -> np.ndarray:
+        """
+        Convert RGB colors to HSV using vectorized operations.
+        
+        Args:
+            rgb_colors: RGB colors (N, 3)
+            
+        Returns:
+            HSV colors (N, 3)
+        """
+        # Normalize to 0-1 range
+        rgb_normalized = rgb_colors / 255.0
+        
+        # Create a dummy image for cv2 conversion
+        dummy_img = rgb_normalized.reshape(-1, 1, 3).astype(np.float32)
+        hsv_img = cv2.cvtColor(dummy_img, cv2.COLOR_RGB2HSV)
+        hsv_colors = hsv_img.reshape(-1, 3)
+        
+        return hsv_colors
+    
+    def classify_colors(self, color_data: Dict[str, np.ndarray]) -> np.ndarray:
+        """
+        Classify each grid cell into color categories.
+        
+        Args:
+            color_data: Dictionary containing color analysis results
+            
+        Returns:
+            Color categories for each grid cell (grid_rows, grid_cols)
+        """
+        import warnings
+        
+        if self.classification_method == ColorClassificationMethod.AVERAGE_COLOR:
+            features = color_data['average_colors']
+        elif self.classification_method == ColorClassificationMethod.DOMINANT_COLOR:
+            features = color_data['dominant_colors']
+        elif self.classification_method == ColorClassificationMethod.HSV_QUANTIZATION:
+            # Combine HSV features
+            h = color_data['hue']
+            s = color_data['saturation']
+            v = color_data['brightness']
+            features = np.stack([h, s, v], axis=-1)
+        else:
+            features = color_data['average_colors']
+        
+        # Flatten for clustering
+        grid_rows, grid_cols = features.shape[:2]
+        features_flat = features.reshape(-1, features.shape[-1])
+        
+        # Check for sufficient diversity before clustering
+        unique_features = np.unique(features_flat, axis=0)
+        effective_clusters = min(self.n_color_categories, len(unique_features))
+        
+        if effective_clusters < 2:
+            # Handle case with very limited color diversity
+            print(f"Warning: Only {len(unique_features)} unique colors found. Using simple classification.")
+            categories = np.zeros(len(features_flat), dtype=int)
+            categories_grid = categories.reshape(grid_rows, grid_cols)
+            self.category_colors = unique_features[:1] if len(unique_features) > 0 else np.array([[128, 128, 128]])
+            return categories_grid
+        
+        # Fit color classifier with warning suppression
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=UserWarning)
+            warnings.filterwarnings("ignore", message=".*ConvergenceWarning.*")
+            
+            self.color_classifier = KMeans(n_clusters=effective_clusters, 
+                                         random_state=42, n_init=10)
+            categories = self.color_classifier.fit_predict(features_flat)
+        
+        # Store category representative colors
+        self.category_colors = self.color_classifier.cluster_centers_
+        
+        # Reshape back to grid
+        categories_grid = categories.reshape(grid_rows, grid_cols)
+        
+        return categories_grid
+    
+    def apply_thresholding(self, color_data: Dict[str, np.ndarray], 
+                          brightness_threshold: float = 0.5,
+                          saturation_threshold: float = 0.3) -> Dict[str, np.ndarray]:
+        """
+        Apply thresholding to create binary masks for different criteria.
+        
+        Args:
+            color_data: Color analysis results
+            brightness_threshold: Threshold for bright/dark classification
+            saturation_threshold: Threshold for saturated/desaturated classification
+            
+        Returns:
+            Dictionary containing various threshold masks
+        """
+        brightness = color_data['brightness']
+        saturation = color_data['saturation']
+        
+        # Normalize brightness and saturation to 0-1 range
+        brightness_norm = brightness / 255.0 if brightness.max() > 1.0 else brightness
+        saturation_norm = saturation / 255.0 if saturation.max() > 1.0 else saturation
+        
+        thresholds = {
+            'bright_mask': brightness_norm > brightness_threshold,
+            'dark_mask': brightness_norm <= brightness_threshold,
+            'saturated_mask': saturation_norm > saturation_threshold,
+            'desaturated_mask': saturation_norm <= saturation_threshold,
+            'bright_saturated': (brightness_norm > brightness_threshold) & 
+                              (saturation_norm > saturation_threshold),
+            'dark_saturated': (brightness_norm <= brightness_threshold) & 
+                            (saturation_norm > saturation_threshold)
+        }
+        
+        return thresholds
+    
+    def analyze_image_complete(self, image: np.ndarray) -> Dict:
+        """
+        Complete analysis pipeline for an image.
+        
+        Args:
+            image: Input image (H, W, C)
+            
+        Returns:
+            Complete analysis results
+        """
+        print(f"Analyzing image with {self.grid_size[0]}x{self.grid_size[1]} grid...")
+        
+        # Step 1: Divide into grid
+        grid, tile_size = self.divide_image_into_grid(image)
+        print(f"Created grid with tile size: {tile_size}")
+        
+        # Step 2: Analyze colors (vectorized)
+        color_data = self.analyze_grid_colors_vectorized(grid)
+        print("Completed color analysis")
+        
+        # Step 3: Classify colors
+        color_categories = self.classify_colors(color_data)
+        print(f"Classified into {self.n_color_categories} color categories")
+        
+        # Step 4: Apply thresholding
+        thresholds = self.apply_thresholding(color_data)
+        print("Applied thresholding")
+        
+        # Combine all results
+        results = {
+            'grid': grid,
+            'tile_size': tile_size,
+            'color_data': color_data,
+            'color_categories': color_categories,
+            'thresholds': thresholds,
+            'category_colors': self.category_colors
+        }
+        
+        return results
+    
+    def visualize_analysis(self, results: Dict, original_image: np.ndarray):
+        """
+        Create comprehensive visualizations of the analysis results.
+        
+        Args:
+            results: Analysis results from analyze_image_complete
+            original_image: Original input image
+        """
+        fig, axes = plt.subplots(2, 4, figsize=(20, 10))
+        
+        # Original image
+        axes[0, 0].imshow(original_image)
+        axes[0, 0].set_title('Original Image')
+        axes[0, 0].axis('off')
+        
+        # Average colors
+        avg_colors = results['color_data']['average_colors'].astype(np.uint8)
+        axes[0, 1].imshow(avg_colors)
+        axes[0, 1].set_title('Average Colors per Cell')
+        axes[0, 1].axis('off')
+        
+        # Dominant colors
+        dom_colors = results['color_data']['dominant_colors'].astype(np.uint8)
+        axes[0, 2].imshow(dom_colors)
+        axes[0, 2].set_title('Dominant Colors per Cell')
+        axes[0, 2].axis('off')
+        
+        # Color categories
+        categories = results['color_categories']
+        im_cat = axes[0, 3].imshow(categories, cmap='tab20')
+        axes[0, 3].set_title(f'Color Categories ({self.n_color_categories} classes)')
+        axes[0, 3].axis('off')
+        plt.colorbar(im_cat, ax=axes[0, 3])
+        
+        # Brightness
+        brightness = results['color_data']['brightness']
+        im_bright = axes[1, 0].imshow(brightness, cmap='gray')
+        axes[1, 0].set_title('Brightness Values')
+        axes[1, 0].axis('off')
+        plt.colorbar(im_bright, ax=axes[1, 0])
+        
+        # Saturation
+        saturation = results['color_data']['saturation']
+        im_sat = axes[1, 1].imshow(saturation, cmap='viridis')
+        axes[1, 1].set_title('Saturation Values')
+        axes[1, 1].axis('off')
+        plt.colorbar(im_sat, ax=axes[1, 1])
+        
+        # Threshold: Bright areas
+        axes[1, 2].imshow(results['thresholds']['bright_mask'], cmap='gray')
+        axes[1, 2].set_title('Bright Areas (Threshold)')
+        axes[1, 2].axis('off')
+        
+        # Threshold: Saturated areas
+        axes[1, 3].imshow(results['thresholds']['saturated_mask'], cmap='gray')
+        axes[1, 3].set_title('Saturated Areas (Threshold)')
+        axes[1, 3].axis('off')
+        
+        plt.tight_layout()
+        plt.show()
+        
+        # Show color category palette
+        self._visualize_color_palette(results['category_colors'])
+    
+    def _visualize_color_palette(self, category_colors: np.ndarray):
+        """
+        Visualize the color category palette.
+        
+        Args:
+            category_colors: Color palette (n_categories, channels)
+        """
+        if category_colors is None:
+            return
+            
+        fig, ax = plt.subplots(1, 1, figsize=(12, 2))
+        
+        # Normalize colors if needed
+        colors = category_colors.copy()
+        if colors.max() > 1.0:
+            colors = colors / 255.0
+        
+        # Create color swatches
+        palette = colors.reshape(1, -1, 3)
+        ax.imshow(palette, aspect='auto')
+        ax.set_xlim(0, len(colors))
+        ax.set_ylim(0, 1)
+        ax.set_xticks(range(len(colors)))
+        ax.set_xticklabels([f'Cat {i}' for i in range(len(colors))])
+        ax.set_title(f'Color Category Palette ({len(colors)} categories)')
+        ax.set_ylabel('Color Categories')
+        
+        plt.tight_layout()
+        plt.show()
+    
+    def get_performance_stats(self, results: Dict) -> Dict:
+        """
+        Calculate performance and analysis statistics.
+        
+        Args:
+            results: Analysis results
+            
+        Returns:
+            Dictionary containing statistics
+        """
+        grid_shape = results['color_categories'].shape
+        total_cells = np.prod(grid_shape)
+        
+        # Color diversity
+        unique_categories = len(np.unique(results['color_categories']))
+        
+        # Brightness statistics
+        brightness = results['color_data']['brightness']
+        
+        # Saturation statistics
+        saturation = results['color_data']['saturation']
+        
+        stats = {
+            'grid_size': f"{grid_shape[0]}x{grid_shape[1]}",
+            'total_cells': total_cells,
+            'unique_color_categories': unique_categories,
+            'category_utilization': unique_categories / self.n_color_categories,
+            'avg_brightness': np.mean(brightness),
+            'brightness_std': np.std(brightness),
+            'avg_saturation': np.mean(saturation),
+            'saturation_std': np.std(saturation),
+            'bright_cells_percent': np.mean(results['thresholds']['bright_mask']) * 100,
+            'saturated_cells_percent': np.mean(results['thresholds']['saturated_mask']) * 100
+        }
+        
+        return stats
+
+# Example usage and testing
+def main():
+    """
+    Example usage of the ImageGridAnalyzer.
+    """
+    # Create sample test image (or load your own)
+    def create_test_image():
+        # Create a colorful test image with gradients and patterns
+        img = np.zeros((256, 256, 3), dtype=np.uint8)
+        
+        # Add gradients
+        for i in range(256):
+            for j in range(256):
+                img[i, j, 0] = i  # Red gradient
+                img[i, j, 1] = j  # Green gradient
+                img[i, j, 2] = (i + j) % 255  # Blue pattern
+        
+        return img
+    
+    # Initialize analyzer
+    analyzer = ImageGridAnalyzer(
+        grid_size=(32, 32),  # 32x32 grid = 1024 cells
+        classification_method=ColorClassificationMethod.DOMINANT_COLOR,
+        n_color_categories=16
+    )
+    
+    # Create or load test image
+    # test_image = create_test_image()
+    
+    # Or load real image (uncomment and modify path):
+    test_image = cv2.imread('processed_quantized.jpg')
+    test_image = cv2.cvtColor(test_image, cv2.COLOR_BGR2RGB)
+    
+    print("Starting analysis...")
+    
+    # Analyze the image
+    results = analyzer.analyze_image_complete(test_image)
+    
+    # Get performance statistics
+    stats = analyzer.get_performance_stats(results)
+    
+    print("\n=== Analysis Statistics ===")
+    for key, value in stats.items():
+        print(f"{key}: {value}")
+    
+    # Visualize results
+    # analyzer.visualize_analysis(results, test_image)
+    
+    return results, analyzer
+
+if __name__ == "__main__":
+    results, analyzer = main()

ImagePreprocessor.py

@@ -0,0 +1,199 @@
+"""
+ImagePreprocessor.py
+Step 1: Image preprocessing for mosaic generation.
+Handles image loading, resizing, cropping, and color quantization.
+"""
+
+import cv2
+import numpy as np
+from PIL import Image
+import os
+from typing import Tuple, Optional
+from sklearn.cluster import MiniBatchKMeans
+import warnings
+
+class ImagePreprocessor:
+    """
+    Handles image preprocessing for mosaic generation.
+    Features: Smart resizing, grid-perfect cropping, fast color quantization.
+    """
+    
+    def __init__(self, target_resolution: Tuple[int, int] = (800, 600), 
+                 grid_size: Tuple[int, int] = (20, 15)):
+        """
+        Initialize the preprocessor.
+        
+        Args:
+            target_resolution: Target (width, height) for processed images
+            grid_size: Grid dimensions (cols, rows) for mosaic
+        """
+        self.target_resolution = target_resolution
+        self.grid_size = grid_size
+        
+        # Calculate tile size for perfect grid alignment
+        self.tile_width = target_resolution[0] // grid_size[0]
+        self.tile_height = target_resolution[1] // grid_size[1]
+        
+        # Adjust target resolution to fit grid perfectly
+        self.adjusted_width = self.tile_width * grid_size[0]
+        self.adjusted_height = self.tile_height * grid_size[1]
+        
+        print(f"Target resolution: {self.adjusted_width}x{self.adjusted_height}")
+        print(f"Grid size: {grid_size[0]}x{grid_size[1]}")
+        print(f"Tile size: {self.tile_width}x{self.tile_height}")
+    
+    def load_and_preprocess_image(self, image_path: str, 
+                                 apply_quantization: bool = False,
+                                 n_colors: int = 16) -> Optional[np.ndarray]:
+        """
+        Load and preprocess image from file path.
+        
+        Args:
+            image_path: Path to the image file
+            apply_quantization: Whether to apply color quantization
+            n_colors: Number of colors for quantization
+            
+        Returns:
+            Preprocessed image as numpy array (RGB) or None if failed
+        """
+        try:
+            # Load and convert image
+            image = cv2.imread(image_path)
+            if image is None:
+                raise ValueError(f"Could not load image: {image_path}")
+            
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            
+            # Resize and crop to fit grid
+            processed_image = self._resize_and_crop(image)
+            
+            # Apply color quantization if requested
+            if apply_quantization:
+                processed_image = self._apply_color_quantization(processed_image, n_colors)
+            
+            return processed_image
+            
+        except Exception as e:
+            print(f"Error processing {image_path}: {str(e)}")
+            return None
+    
+    def preprocess_numpy_image(self, image: np.ndarray,
+                              apply_quantization: bool = False,
+                              n_colors: int = 16) -> Optional[np.ndarray]:
+        """
+        Preprocess numpy image array (for Gradio integration).
+        
+        Args:
+            image: Input image as numpy array
+            apply_quantization: Whether to apply color quantization
+            n_colors: Number of colors for quantization
+            
+        Returns:
+            Preprocessed image as numpy array (RGB) or None if failed
+        """
+        try:
+            if len(image.shape) != 3 or image.shape[2] != 3:
+                raise ValueError("Image must be RGB format with shape (H, W, 3)")
+            
+            processed_image = image.copy()
+            processed_image = self._resize_and_crop(processed_image)
+            
+            if apply_quantization:
+                processed_image = self._apply_color_quantization(processed_image, n_colors)
+            
+            return processed_image
+            
+        except Exception as e:
+            print(f"Error processing numpy image: {str(e)}")
+            return None
+    
+    def _resize_and_crop(self, image: np.ndarray) -> np.ndarray:
+        """
+        Resize and crop image to fit target resolution while maintaining aspect ratio.
+        """
+        h, w = image.shape[:2]
+        target_w, target_h = self.adjusted_width, self.adjusted_height
+        
+        # Scale to fill target size
+        scale_w = target_w / w
+        scale_h = target_h / h
+        scale = max(scale_w, scale_h)
+        
+        # Resize image
+        new_w = int(w * scale)
+        new_h = int(h * scale)
+        resized = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_AREA)
+        
+        # Center crop to exact target size
+        start_x = (new_w - target_w) // 2
+        start_y = (new_h - target_h) // 2
+        cropped = resized[start_y:start_y + target_h, start_x:start_x + target_w]
+        
+        return cropped
+    
+    def _apply_color_quantization(self, image: np.ndarray, n_colors: int) -> np.ndarray:
+        """
+        Apply color quantization using Mini-Batch K-means for speed.
+        3-4x faster than regular K-means with similar quality.
+        """
+        h, w, c = image.shape
+        pixels = image.reshape(-1, c)
+        
+        # Adaptive batch size based on image size
+        total_pixels = len(pixels)
+        batch_size = min(max(total_pixels // 100, 1000), 10000)
+        
+        print(f"Applying Mini-Batch K-means quantization:")
+        print(f"  Total pixels: {total_pixels:,}")
+        print(f"  Batch size: {batch_size:,}")
+        print(f"  Target colors: {n_colors}")
+        
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=UserWarning)
+            warnings.filterwarnings("ignore", message=".*ConvergenceWarning.*")
+            
+            kmeans = MiniBatchKMeans(
+                n_clusters=n_colors, 
+                batch_size=batch_size,
+                random_state=42, 
+                n_init=3,
+                max_iter=100
+            )
+            labels = kmeans.fit_predict(pixels)
+        
+        # Replace pixels with cluster centers
+        quantized_pixels = kmeans.cluster_centers_[labels]
+        quantized_image = quantized_pixels.reshape(h, w, c).astype(np.uint8)
+        
+        return quantized_image
+    
+    def save_preprocessed_image(self, image: np.ndarray, output_path: str):
+        """Save preprocessed image to disk."""
+        try:
+            pil_image = Image.fromarray(image)
+            pil_image.save(output_path, quality=95)
+            print(f"Saved preprocessed image to: {output_path}")
+        except Exception as e:
+            print(f"Error saving image: {str(e)}")
+
+if __name__ == "__main__":
+    # Test preprocessing
+    preprocessor = ImagePreprocessor(
+        target_resolution=(1280, 1280),
+        grid_size=(32, 32)
+    )
+    
+    test_image = "EmmaPotrait.jpg"
+    
+    if os.path.exists(test_image):
+        processed = preprocessor.load_and_preprocess_image(
+            test_image, 
+            apply_quantization=True,
+            n_colors=8
+        )
+        
+        if processed is not None:
+            preprocessor.save_preprocessed_image(processed, "processed_quantized.jpg")
+            print("Image preprocessing completed!")
+    else:
+        print(f"Test image not found: {test_image}")

Performance_metrics.py

@@ -0,0 +1,168 @@
+"""
+performance_metrics.py
+Performance evaluation for mosaic quality assessment.
+"""
+
+import numpy as np
+import cv2
+from typing import Dict
+from skimage.metrics import structural_similarity as ssim
+import matplotlib.pyplot as plt
+
+class PerformanceEvaluator:
+    """Comprehensive mosaic quality evaluation."""
+    
+    def __init__(self):
+        self.metrics = {}
+        
+    def calculate_mse(self, original: np.ndarray, mosaic: np.ndarray) -> float:
+        """Calculate Mean Squared Error."""
+        if original.shape != mosaic.shape:
+            original_resized = cv2.resize(original, (mosaic.shape[1], mosaic.shape[0]))
+        else:
+            original_resized = original
+        
+        orig_float = original_resized.astype(np.float64)
+        mosaic_float = mosaic.astype(np.float64)
+        mse = np.mean((orig_float - mosaic_float) ** 2)
+        return float(mse)
+    
+    def calculate_psnr(self, original: np.ndarray, mosaic: np.ndarray) -> float:
+        """Calculate Peak Signal-to-Noise Ratio."""
+        mse = self.calculate_mse(original, mosaic)
+        if mse == 0:
+            return float('inf')
+        psnr = 20 * np.log10(255.0 / np.sqrt(mse))
+        return float(psnr)
+    
+    def calculate_ssim(self, original: np.ndarray, mosaic: np.ndarray) -> float:
+        """Calculate Structural Similarity Index."""
+        if original.shape != mosaic.shape:
+            original_resized = cv2.resize(original, (mosaic.shape[1], mosaic.shape[0]))
+        else:
+            original_resized = original
+        
+        if len(original_resized.shape) == 3:
+            ssim_values = []
+            for channel in range(original_resized.shape[2]):
+                channel_ssim = ssim(original_resized[:, :, channel], mosaic[:, :, channel], data_range=255)
+                ssim_values.append(channel_ssim)
+            return float(np.mean(ssim_values))
+        else:
+            return float(ssim(original_resized, mosaic, data_range=255))
+    
+    def calculate_color_histogram_similarity(self, original: np.ndarray, mosaic: np.ndarray) -> float:
+        """Calculate color histogram similarity."""
+        if original.shape != mosaic.shape:
+            original_resized = cv2.resize(original, (mosaic.shape[1], mosaic.shape[0]))
+        else:
+            original_resized = original
+        
+        correlations = []
+        for channel in range(3):
+            hist_orig = cv2.calcHist([original_resized], [channel], None, [256], [0, 256])
+            hist_mosaic = cv2.calcHist([mosaic], [channel], None, [256], [0, 256])
+            corr = cv2.compareHist(hist_orig, hist_mosaic, cv2.HISTCMP_CORREL)
+            correlations.append(corr)
+        
+        return float(np.mean(correlations))
+    
+    def evaluate_mosaic_quality(self, original: np.ndarray, mosaic: np.ndarray, 
+                               original_path: str = None) -> Dict[str, float]:
+        """Comprehensive quality evaluation."""
+        print("Calculating quality metrics...")
+        
+        metrics = {
+            'mse': self.calculate_mse(original, mosaic),
+            'psnr': self.calculate_psnr(original, mosaic),
+            'ssim': self.calculate_ssim(original, mosaic),
+            'histogram_similarity': self.calculate_color_histogram_similarity(original, mosaic)
+        }
+        
+        # Overall score
+        ssim_norm = (metrics['ssim'] + 1) / 2
+        psnr_norm = min(metrics['psnr'] / 50.0, 1.0)
+        hist_norm = metrics['histogram_similarity']
+        overall = (0.5 * ssim_norm + 0.3 * hist_norm + 0.2 * psnr_norm) * 100
+        metrics['overall_quality'] = float(overall)
+        
+        self.metrics = metrics
+        self._print_report(metrics, original_path)
+        return metrics
+    
+    def _print_report(self, metrics: Dict[str, float], original_path: str = None):
+        """Print quality assessment report."""
+        print(f"\n{'='*50}")
+        print("QUALITY ASSESSMENT")
+        print(f"{'='*50}")
+        
+        if original_path:
+            print(f"Image: {original_path}")
+        
+        print(f"MSE: {metrics['mse']:.2f} (lower = better)")
+        print(f"PSNR: {metrics['psnr']:.2f} dB (>30 = good)")
+        print(f"SSIM: {metrics['ssim']:.4f} (>0.8 = very good)")
+        print(f"Histogram: {metrics['histogram_similarity']:.4f}")
+        print(f"Overall Score: {metrics['overall_quality']:.1f}/100")
+        
+        score = metrics['overall_quality']
+        if score >= 85:
+            quality = "Excellent"
+        elif score >= 75:
+            quality = "Very Good"
+        elif score >= 65:
+            quality = "Good"
+        else:
+            quality = "Fair"
+        
+        print(f"Assessment: {quality}")
+        print(f"{'='*50}")
+    
+    def visualize_quality_comparison(self, original: np.ndarray, mosaic: np.ndarray, 
+                                   metrics: Dict[str, float] = None):
+        """Create visual comparison with metrics."""
+        if metrics is None:
+            metrics = self.metrics
+        
+        print("Showing quality comparison...")
+        
+        fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+        
+        # Original
+        axes[0, 0].imshow(original)
+        axes[0, 0].set_title(f'Original\n{original.shape[1]}×{original.shape[0]}')
+        axes[0, 0].axis('off')
+        
+        # Mosaic
+        axes[0, 1].imshow(mosaic)
+        axes[0, 1].set_title(f'Mosaic\n{mosaic.shape[1]}×{mosaic.shape[0]}')
+        axes[0, 1].axis('off')
+        
+        # Metrics
+        if metrics:
+            metrics_text = (f"Quality Metrics:\n\n"
+                          f"MSE: {metrics['mse']:.1f}\n"
+                          f"PSNR: {metrics['psnr']:.1f} dB\n"
+                          f"SSIM: {metrics['ssim']:.4f}\n"
+                          f"Histogram: {metrics['histogram_similarity']:.4f}\n\n"
+                          f"Score: {metrics['overall_quality']:.1f}/100")
+            
+            axes[1, 0].text(0.1, 0.5, metrics_text, fontsize=12, fontfamily='monospace', va='center')
+            axes[1, 0].set_title('Quality Assessment')
+            axes[1, 0].axis('off')
+        
+        # Difference map
+        if original.shape == mosaic.shape:
+            diff_img = np.abs(original.astype(np.int16) - mosaic.astype(np.int16))
+        else:
+            original_resized = cv2.resize(original, (mosaic.shape[1], mosaic.shape[0]))
+            diff_img = np.abs(original_resized.astype(np.int16) - mosaic.astype(np.int16))
+        
+        diff_enhanced = np.clip(diff_img * 3, 0, 255).astype(np.uint8)
+        axes[1, 1].imshow(diff_enhanced)
+        axes[1, 1].set_title('Difference Map')
+        axes[1, 1].axis('off')
+        
+        plt.suptitle('Mosaic Quality Evaluation', fontsize=16)
+        plt.tight_layout()
+        plt.show()

app.py

@@ -0,0 +1,480 @@
+"""
+app.py
+Deployment-only Gradio interface that NEVER builds caches during startup.
+Uses only pre-built cache files for fast cloud deployment.
+"""
+
+import gradio as gr
+import numpy as np
+import cv2
+from pathlib import Path
+import time
+import pickle
+import warnings
+from typing import Tuple, Dict, Optional, List
+from dataclasses import dataclass
+from sklearn.cluster import MiniBatchKMeans
+from sklearn.metrics.pairwise import euclidean_distances
+from skimage.metrics import structural_similarity as ssim
+
+# Deployment configuration
+TILE_FOLDER = "extracted_images"
+
+# Pre-built cache files that should be uploaded with the app
+AVAILABLE_CACHES = {
+    16: "cache_16x16_bins8_rot.pkl",
+    32: "cache_32x32_bins8_rot.pkl", 
+    64: "cache_64x64_bins8_rot.pkl"
+}
+
+@dataclass
+class ImageContext:
+    """Contextual analysis results."""
+    has_faces: bool
+    face_regions: List[Tuple[int, int, int, int]]
+    is_portrait: bool
+    is_landscape: bool
+    content_complexity: float
+
+class DeploymentMosaicGenerator:
+    """Deployment-optimized mosaic generator that NEVER builds caches."""
+    
+    def __init__(self, cache_file: str):
+        """Initialize with existing cache file only."""
+        self.cache_file = cache_file
+        
+        # Load cache data
+        try:
+            with open(cache_file, 'rb') as f:
+                data = pickle.load(f)
+            
+            self.tile_images = data['tile_images']
+            self.tile_colours = data['tile_colours']
+            self.tile_names = data['tile_names']
+            self.colour_palette = data['colour_palette']
+            self.colour_groups = data['colour_groups']
+            self.colour_indices = data['colour_indices']
+            self.tile_size = data['tile_size']
+            
+            print(f"Loaded cache: {len(self.tile_images)} tiles, size {self.tile_size}")
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to load cache {cache_file}: {e}")
+        
+        # Face detection
+        try:
+            self.face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        except:
+            self.face_cascade = None
+    
+    def analyze_context(self, image: np.ndarray) -> ImageContext:
+        """Basic context analysis for deployment."""
+        faces = []
+        has_faces = False
+        
+        if self.face_cascade is not None:
+            try:
+                gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+                detected_faces = self.face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(20, 20))
+                faces = [(x, y, w, h) for (x, y, w, h) in detected_faces]
+                has_faces = len(faces) > 0
+            except:
+                pass
+        
+        # Basic scene classification
+        aspect_ratio = image.shape[1] / image.shape[0]
+        is_portrait = aspect_ratio < 1.2 and has_faces
+        is_landscape = aspect_ratio > 1.5
+        
+        # Simple complexity measure
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        edges = cv2.Canny(gray, 50, 150)
+        content_complexity = np.mean(edges) / 255.0
+        
+        return ImageContext(
+            has_faces=has_faces,
+            face_regions=faces,
+            is_portrait=is_portrait,
+            is_landscape=is_landscape,
+            content_complexity=content_complexity
+        )
+    
+    def find_best_tile(self, target_colour: np.ndarray) -> int:
+        """Find best matching tile using color subgroups."""
+        distances = euclidean_distances(target_colour.reshape(1, -1), self.colour_palette)[0]
+        target_bin = np.argmin(distances)
+        
+        if target_bin in self.colour_indices:
+            index, tile_indices = self.colour_indices[target_bin]
+            _, indices = index.kneighbors(target_colour.reshape(1, -1), n_neighbors=1)
+            return tile_indices[indices[0][0]]
+        
+        return 0
+    
+    def create_mosaic(self, image: np.ndarray, grid_size: int, diversity_factor: float = 0.1) -> Tuple[np.ndarray, ImageContext]:
+        """Create mosaic with deployment-optimized processing."""
+        print(f"Creating {grid_size}x{grid_size} mosaic...")
+        
+        # Analyze context
+        context = self.analyze_context(image)
+        
+        # Preprocess image to fit grid
+        target_size = grid_size * self.tile_size[0]
+        h, w = image.shape[:2]
+        scale = max(target_size / w, target_size / h)
+        new_w, new_h = int(w * scale), int(h * scale)
+        resized = cv2.resize(image, (new_w, new_h))
+        
+        # Center crop
+        start_x = (new_w - target_size) // 2
+        start_y = (new_h - target_size) // 2
+        processed_image = resized[start_y:start_y + target_size, start_x:start_x + target_size]
+        
+        # Create mosaic
+        cell_size = target_size // grid_size
+        mosaic = np.zeros((grid_size * self.tile_size[1], grid_size * self.tile_size[0], 3), dtype=np.uint8)
+        
+        usage_count = {} if diversity_factor > 0 else None
+        
+        for i in range(grid_size):
+            for j in range(grid_size):
+                # Get cell color
+                start_y = i * cell_size
+                end_y = start_y + cell_size
+                start_x = j * cell_size
+                end_x = start_x + cell_size
+                
+                cell = processed_image[start_y:end_y, start_x:end_x]
+                target_colour = np.mean(cell, axis=(0, 1))
+                
+                # Find best tile
+                best_tile_idx = self.find_best_tile(target_colour)
+                
+                # Apply diversity if enabled
+                if usage_count is not None:
+                    tile_name = self.tile_names[best_tile_idx]
+                    usage_penalty = usage_count.get(tile_name, 0) * diversity_factor
+                    
+                    # Try alternative tiles if this one is overused
+                    if usage_penalty > 2.0:  # Simple diversity check
+                        distances = euclidean_distances(target_colour.reshape(1, -1), self.tile_colours)[0]
+                        sorted_indices = np.argsort(distances)
+                        for idx in sorted_indices[1:6]:  # Try next 5 best matches
+                            alt_tile_name = self.tile_names[idx]
+                            if usage_count.get(alt_tile_name, 0) < usage_count[tile_name]:
+                                best_tile_idx = idx
+                                break
+                    
+                    usage_count[self.tile_names[best_tile_idx]] = usage_count.get(self.tile_names[best_tile_idx], 0) + 1
+                
+                # Place tile
+                tile_start_y = i * self.tile_size[1]
+                tile_end_y = tile_start_y + self.tile_size[1]
+                tile_start_x = j * self.tile_size[0]
+                tile_end_x = tile_start_x + self.tile_size[0]
+                
+                mosaic[tile_start_y:tile_end_y, tile_start_x:tile_end_x] = self.tile_images[best_tile_idx]
+        
+        return mosaic, context
+
+def calculate_metrics(original: np.ndarray, mosaic: np.ndarray) -> Dict[str, float]:
+    """Calculate the 4 core quality metrics."""
+    # Resize for comparison
+    if original.shape != mosaic.shape:
+        original_resized = cv2.resize(original, (mosaic.shape[1], mosaic.shape[0]))
+    else:
+        original_resized = original
+    
+    # MSE
+    orig_float = original_resized.astype(np.float64)
+    mosaic_float = mosaic.astype(np.float64)
+    mse = float(np.mean((orig_float - mosaic_float) ** 2))
+    
+    # PSNR
+    psnr = float(20 * np.log10(255.0 / np.sqrt(mse))) if mse > 0 else float('inf')
+    
+    # SSIM
+    ssim_values = []
+    for channel in range(3):
+        channel_ssim = ssim(original_resized[:, :, channel], mosaic[:, :, channel], data_range=255)
+        ssim_values.append(channel_ssim)
+    ssim_score = float(np.mean(ssim_values))
+    
+    # Histogram similarity
+    correlations = []
+    for channel in range(3):
+        hist_orig = cv2.calcHist([original_resized], [channel], None, [256], [0, 256])
+        hist_mosaic = cv2.calcHist([mosaic], [channel], None, [256], [0, 256])
+        corr = cv2.compareHist(hist_orig, hist_mosaic, cv2.HISTCMP_CORREL)
+        correlations.append(corr)
+    histogram_similarity = float(np.mean(correlations))
+    
+    # Overall score
+    ssim_norm = (ssim_score + 1) / 2
+    psnr_norm = min(psnr / 50.0, 1.0)
+    overall = (0.5 * ssim_norm + 0.3 * histogram_similarity + 0.2 * psnr_norm) * 100
+    
+    return {
+        'mse': mse,
+        'psnr': psnr,
+        'ssim': ssim_score,
+        'histogram_similarity': histogram_similarity,
+        'overall_quality': float(overall)
+    }
+
+def get_best_available_cache(requested_tile_size: int) -> Optional[str]:
+    """Get the best available cache for requested tile size."""
+    # Check exact match first
+    if requested_tile_size in AVAILABLE_CACHES:
+        cache_file = AVAILABLE_CACHES[requested_tile_size]
+        if Path(cache_file).exists():
+            return cache_file
+    
+    # Find closest available cache
+    available_sizes = []
+    for size, cache_file in AVAILABLE_CACHES.items():
+        if Path(cache_file).exists():
+            available_sizes.append(size)
+    
+    if not available_sizes:
+        return None
+    
+    # Return closest match
+    closest_size = min(available_sizes, key=lambda x: abs(x - requested_tile_size))
+    return AVAILABLE_CACHES[closest_size]
+
+def create_mosaic_interface(image, grid_size, tile_size, diversity_factor, enable_rotation, apply_quantization, n_colors):
+    """Main interface function - deployment optimized."""
+    if image is None:
+        return None, None, "Please upload an image first.", "Please upload an image first."
+    
+    try:
+        start_time = time.time()
+        
+        # Get appropriate cache file
+        cache_file = get_best_available_cache(tile_size)
+        if cache_file is None:
+            error_msg = f"No cache available for tile size {tile_size}x{tile_size}"
+            return None, None, error_msg, error_msg
+        
+        # Initialize generator with existing cache
+        generator = DeploymentMosaicGenerator(cache_file)
+        
+        # Basic color quantization if requested
+        if apply_quantization:
+            pixels = image.reshape(-1, 3)
+            sample_size = min(5000, len(pixels))
+            sampled_pixels = pixels[np.random.choice(len(pixels), sample_size, replace=False)]
+            
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore")
+                kmeans = MiniBatchKMeans(n_clusters=n_colors, batch_size=500, random_state=42)
+                kmeans.fit(sampled_pixels)
+                labels = kmeans.predict(pixels)
+            
+            quantized_pixels = kmeans.cluster_centers_[labels]
+            image = quantized_pixels.reshape(image.shape).astype(np.uint8)
+        
+        # Create mosaic
+        mosaic, context = generator.create_mosaic(image, grid_size, diversity_factor)
+        
+        # Calculate metrics
+        metrics = calculate_metrics(image, mosaic)
+        
+        total_time = time.time() - start_time
+        
+        # Create comparison
+        comparison = np.hstack([
+            cv2.resize(image, (mosaic.shape[1]//2, mosaic.shape[0])),
+            cv2.resize(mosaic, (mosaic.shape[1]//2, mosaic.shape[0]))
+        ])
+        
+        # Metrics display - only 4 core metrics
+        metrics_text = f"""PERFORMANCE METRICS
+
+Mean Squared Error (MSE): {metrics['mse']:.2f}
+
+Peak Signal-to-Noise Ratio (PSNR): {metrics['psnr']:.2f} dB
+
+Structural Similarity Index (SSIM): {metrics['ssim']:.4f}
+
+Color Histogram Similarity: {metrics['histogram_similarity']:.4f}
+
+Overall Quality Score: {metrics['overall_quality']:.1f}/100"""
+        
+        # Status
+        status = f"""Generation Successful!
+
+Grid: {grid_size}x{grid_size} = {grid_size**2} tiles
+Tile Size: {tile_size}x{tile_size} pixels
+Processing Time: {total_time:.2f} seconds
+Cache Used: {cache_file}
+
+Contextual Analysis:
+• Faces Detected: {len(context.face_regions)}
+• Scene Type: {'Portrait' if context.is_portrait else 'Landscape' if context.is_landscape else 'General'}
+• Content Complexity: {context.content_complexity:.3f}"""
+        
+        return mosaic, comparison, metrics_text, status
+        
+    except Exception as e:
+        error_msg = f"Error: {str(e)}"
+        return None, None, error_msg, error_msg
+
+def verify_deployment_setup():
+    """Check deployment setup without building anything."""
+    available_caches = {}
+    total_size_mb = 0
+    
+    for size, cache_file in AVAILABLE_CACHES.items():
+        if Path(cache_file).exists():
+            size_mb = Path(cache_file).stat().st_size / 1024 / 1024
+            available_caches[size] = size_mb
+            total_size_mb += size_mb
+    
+    setup_msg = f"Found {len(available_caches)} cache files ({total_size_mb:.1f}MB total)"
+    
+    return len(available_caches) > 0, setup_msg, available_caches
+
+def get_system_status():
+    """System status for deployment."""
+    setup_ok, setup_msg, available_caches = verify_deployment_setup()
+    
+    cache_list = ""
+    for size, size_mb in available_caches.items():
+        cache_list += f"  {size}x{size}: {size_mb:.1f}MB\n"
+    
+    status = f"""DEPLOYMENT STATUS
+{'='*30}
+
+Cache System: {'✅' if setup_ok else '❌'}
+{setup_msg}
+
+Available Caches:
+{cache_list if cache_list else "  None found"}
+
+Smart Selection: System automatically uses the best 
+available cache for your chosen tile size.
+
+INNOVATIONS INCLUDED
+{'='*30}
+
+🧠 Contextual Awareness: Face detection, scene classification
+🔄 Multi-Orientation: Rotation variants in cache files  
+⚡ Performance: Color subgrouping, Mini-Batch K-means
+📊 Quality Metrics: MSE, PSNR, SSIM, Histogram similarity
+
+DEPLOYMENT OPTIMIZED
+{'='*30}
+
+• No cache building during startup
+• Fast initialization with pre-built caches
+• Lightweight processing for cloud deployment
+• Maintains all core innovations"""
+    
+    return status
+
+def create_interface():
+    """Create deployment-optimized Gradio interface."""
+    
+    css = """
+    .gradio-container { max-width: 100% !important; padding: 0 20px; }
+    .left-panel { 
+        flex: 0 0 350px; background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+        padding: 25px; border-radius: 15px; box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+    }
+    .right-panel { 
+        flex: 1; background: white; padding: 25px; border-radius: 15px;
+        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+    }
+    .metrics-display {
+        background: linear-gradient(145deg, #667eea 0%, #764ba2 100%);
+        color: white; padding: 20px; border-radius: 10px;
+        font-family: 'Courier New', monospace; font-size: 14px; line-height: 1.6;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="Advanced Mosaic Generator") as demo:
+        
+        gr.Markdown("# Advanced Contextual Mosaic Generator")
+        gr.Markdown("AI-powered mosaic creation with contextual awareness and performance metrics.")
+        
+        with gr.Accordion("System Status", open=False):
+            status_display = gr.Textbox(value=get_system_status(), lines=20, show_label=False)
+            gr.Button("Refresh Status").click(fn=get_system_status, outputs=status_display)
+        
+        with gr.Row():
+            # Left Panel: Controls
+            with gr.Column(scale=0, min_width=350, elem_classes=["left-panel"]):
+                gr.Markdown("## Configuration")
+                
+                # Generate button at top
+                generate_btn = gr.Button("Generate Advanced Mosaic", variant="primary", size="lg")
+                
+                gr.Markdown("---")
+                
+                # Image upload
+                input_image = gr.Image(type="numpy", label="Upload Image", height=200)
+                
+                # Controls
+                grid_size = gr.Slider(16, 96, 32, step=8, label="Grid Size", info="Number of tiles per side")
+                tile_size = gr.Slider(16, 64, 32, step=16, label="Tile Size", info="Must match available cache")
+                diversity_factor = gr.Slider(0.0, 0.5, 0.15, step=0.05, label="Diversity", info="Tile variety")
+                enable_rotation = gr.Checkbox(label="Enable Rotation", value=False, info="Uses rotation variants if available")
+                apply_quantization = gr.Checkbox(label="Color Quantization", value=True)
+                n_colors = gr.Slider(4, 24, 12, step=2, label="Colors")
+                
+                # Presets
+                gr.Markdown("### Quick Presets")
+                with gr.Row():
+                    preset_fast = gr.Button("Fast", size="sm")
+                    preset_quality = gr.Button("Quality", size="sm")
+            
+            # Right Panel: Results
+            with gr.Column(scale=2, elem_classes=["right-panel"]):
+                gr.Markdown("## Results & Analysis")
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Generated Mosaic")
+                        mosaic_output = gr.Image(height=300, show_label=False)
+                    
+                    with gr.Column():
+                        gr.Markdown("### Comparison")
+                        comparison_output = gr.Image(height=300, show_label=False)
+                
+                gr.Markdown("### Performance Metrics")
+                metrics_output = gr.Textbox(lines=8, elem_classes=["metrics-display"], show_label=False)
+                
+                status_output = gr.Textbox(label="Status", lines=6)
+        
+        # Connect functions
+        def fast_preset():
+            return 24, 32, 0.1, False, True, 8
+        
+        def quality_preset():
+            return 48, 32, 0.15, False, True, 12
+        
+        generate_btn.click(
+            fn=create_mosaic_interface,
+            inputs=[input_image, grid_size, tile_size, diversity_factor, enable_rotation, apply_quantization, n_colors],
+            outputs=[mosaic_output, comparison_output, metrics_output, status_output]
+        )
+        
+        preset_fast.click(fn=fast_preset, outputs=[grid_size, tile_size, diversity_factor, enable_rotation, apply_quantization, n_colors])
+        preset_quality.click(fn=quality_preset, outputs=[grid_size, tile_size, diversity_factor, enable_rotation, apply_quantization, n_colors])
+    
+    return demo
+
+if __name__ == "__main__":
+    print("Advanced Mosaic Generator - Deployment Version")
+    print("Checking deployment setup...")
+    
+    setup_ok, setup_msg, caches = verify_deployment_setup()
+    if setup_ok:
+        print(f"Deployment ready: {setup_msg}")
+        demo = create_interface()
+        demo.launch(server_name="0.0.0.0", server_port=7860, share=True)
+    else:
+        print(f"Deployment not ready: {setup_msg}")
+        print("Please upload the required cache files")

cache_16x16_bins8_rot.pkl

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

cache_32x32_bins8_rot.pkl

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

contextual_Mosaic_Builder.py

@@ -0,0 +1,369 @@
+"""
+contextual_mosaic.py
+Advanced contextual mosaic generator with face detection and rotation.
+"""
+
+import numpy as np
+import cv2
+from pathlib import Path
+from typing import Dict, Tuple, List, Optional
+from dataclasses import dataclass
+from sklearn.metrics.pairwise import euclidean_distances
+from sklearn.cluster import MiniBatchKMeans
+from tqdm import tqdm
+import pickle
+import warnings
+import matplotlib.pyplot as plt
+
+@dataclass
+class ImageContext:
+    """Stores contextual analysis results."""
+    has_faces: bool
+    face_regions: List[Tuple[int, int, int, int]]
+    is_portrait: bool
+    is_landscape: bool
+    dominant_colors: np.ndarray
+    brightness_map: np.ndarray
+    edge_density_map: np.ndarray
+    content_complexity: float
+
+class ContextualMosaicGenerator:
+    """Advanced mosaic generator with contextual awareness."""
+    
+    def __init__(self, cache_file: str, tile_folder: str = "extracted_images", 
+                 tile_size: Tuple[int, int] = (32, 32),
+                 colour_bins: int = 8,
+                 enable_rotation: bool = True):
+        self.cache_file = cache_file
+        self.tile_folder = tile_folder
+        self.target_tile_size = tile_size
+        self.target_colour_bins = colour_bins
+        self.target_enable_rotation = enable_rotation
+        
+        # Data containers
+        self.tile_images = None
+        self.tile_colours = None
+        self.tile_names = None
+        self.colour_palette = None
+        self.colour_groups = None
+        self.colour_indices = None
+        self.tile_size = None
+        self.enable_rotation = False
+        
+        # Setup face detection
+        try:
+            self.face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        except:
+            print("Warning: Face detection not available")
+            self.face_cascade = None
+        
+        self._load_or_build_cache()
+    
+    def _load_or_build_cache(self):
+        """Load existing cache or build new one."""
+        if Path(self.cache_file).exists():
+            try:
+                if self._load_and_validate_cache():
+                    print("Cache loaded successfully")
+                    return
+            except Exception as e:
+                print(f"Cache error: {e}")
+        
+        print("Building new cache...")
+        self._build_cache_automatically()
+    
+    def _load_and_validate_cache(self) -> bool:
+        """Load and validate cache parameters."""
+        with open(self.cache_file, 'rb') as f:
+            data = pickle.load(f)
+        
+        required_keys = ['tile_images', 'tile_colours', 'tile_names', 'colour_palette', 'colour_groups', 'colour_indices']
+        if not all(key in data for key in required_keys):
+            return False
+        
+        # Validate parameters
+        if (data.get('tile_size') != self.target_tile_size or
+            data.get('colour_bins') != self.target_colour_bins or
+            data.get('enable_rotation') != self.target_enable_rotation):
+            print("Cache parameters don't match")
+            return False
+        
+        # Load data
+        self.tile_images = data['tile_images']
+        self.tile_colours = data['tile_colours']
+        self.tile_names = data['tile_names']
+        self.colour_palette = data['colour_palette']
+        self.colour_groups = data['colour_groups']
+        self.colour_indices = data['colour_indices']
+        self.tile_size = data['tile_size']
+        self.enable_rotation = data.get('enable_rotation', False)
+        
+        print(f"Loaded: {len(self.tile_images)} tiles")
+        return True
+    
+    def _build_cache_automatically(self):
+        """Build cache using cache builder."""
+        try:
+            from Cache_Builder import TileCacheBuilder
+            
+            print("Auto-building cache...")
+            builder = TileCacheBuilder(
+                tile_folder=self.tile_folder,
+                tile_size=self.target_tile_size,
+                colour_bins=self.target_colour_bins,
+                enable_rotation=self.target_enable_rotation
+            )
+            
+            success = builder.build_cache(self.cache_file, force_rebuild=True)
+            if not success:
+                raise RuntimeError("Cache builder failed")
+            
+            if not self._load_and_validate_cache():
+                raise RuntimeError("Failed to load new cache")
+            
+            print("Cache built successfully!")
+            
+        except Exception as e:
+            raise RuntimeError(f"Auto-cache failed: {e}")
+    
+    def analyze_image_context(self, image: np.ndarray) -> ImageContext:
+        """Analyze image content for contextual tile selection."""
+        print("Analyzing context...")
+        
+        # Face detection
+        faces = []
+        has_faces = False
+        if self.face_cascade is not None:
+            gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+            detected_faces = self.face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+            faces = [(x, y, w, h) for (x, y, w, h) in detected_faces]
+            has_faces = len(faces) > 0
+        
+        # Scene classification
+        aspect_ratio = image.shape[1] / image.shape[0]
+        is_portrait = aspect_ratio < 1.2 and has_faces
+        is_landscape = aspect_ratio > 1.5
+        
+        # Dominant colors
+        pixels = image.reshape(-1, 3)
+        sample_size = min(10000, len(pixels))
+        sampled_pixels = pixels[np.random.choice(len(pixels), sample_size, replace=False)]
+        
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore")
+            kmeans = MiniBatchKMeans(n_clusters=5, random_state=42, batch_size=1000)
+            kmeans.fit(sampled_pixels)
+            dominant_colors = kmeans.cluster_centers_
+        
+        # Analysis maps
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        brightness_map = cv2.resize(gray, (32, 32)) / 255.0
+        edges = cv2.Canny(gray, 50, 150)
+        edge_density_map = cv2.resize(edges, (32, 32)) / 255.0
+        content_complexity = np.mean(edge_density_map)
+        
+        context = ImageContext(
+            has_faces=has_faces,
+            face_regions=faces,
+            is_portrait=is_portrait,
+            is_landscape=is_landscape,
+            dominant_colors=dominant_colors,
+            brightness_map=brightness_map,
+            edge_density_map=edge_density_map,
+            content_complexity=content_complexity
+        )
+        
+        print(f"Context: {len(faces)} faces, {'Portrait' if is_portrait else 'Landscape' if is_landscape else 'General'}")
+        return context
+    
+    def get_adaptive_tile_strategy(self, context: ImageContext, grid_pos: Tuple[int, int], grid_size: Tuple[int, int]) -> Dict:
+        """Get adaptive strategy based on content and position."""
+        row, col = grid_pos
+        grid_rows, grid_cols = grid_size
+        
+        strategy = {
+            'precision_factor': 1.0,
+            'diversity_factor': 0.1,
+            'allow_rotation': self.enable_rotation,
+            'search_candidates': 5
+        }
+        
+        # Face area adjustments
+        if context.has_faces:
+            for face_x, face_y, face_w, face_h in context.face_regions:
+                face_grid_x = int((face_x / 1024) * grid_cols)
+                face_grid_y = int((face_y / 1024) * grid_rows)
+                face_grid_w = max(1, int((face_w / 1024) * grid_cols))
+                face_grid_h = max(1, int((face_h / 1024) * grid_rows))
+                
+                if (face_grid_x <= col <= face_grid_x + face_grid_w and
+                    face_grid_y <= row <= face_grid_y + face_grid_h):
+                    strategy['precision_factor'] = 2.0
+                    strategy['diversity_factor'] = 0.05
+                    strategy['allow_rotation'] = False
+                    strategy['search_candidates'] = 10
+                    break
+        
+        # Edge adjustments
+        edge_row = min(int((row / grid_rows) * 32), 31)
+        edge_col = min(int((col / grid_cols) * 32), 31)
+        edge_density = context.edge_density_map[edge_row, edge_col]
+        
+        if edge_density > 0.3:
+            strategy['precision_factor'] *= 1.5
+            strategy['search_candidates'] = min(strategy['search_candidates'] * 2, 15)
+        
+        return strategy
+    
+    def find_contextual_best_tile(self, target_colour: np.ndarray, context: ImageContext,
+                                 grid_pos: Tuple[int, int], grid_size: Tuple[int, int],
+                                 usage_count: Dict = None) -> int:
+        """Find best tile using contextual analysis."""
+        strategy = self.get_adaptive_tile_strategy(context, grid_pos, grid_size)
+        
+        # Find color bin
+        distances = euclidean_distances(target_colour.reshape(1, -1), self.colour_palette)[0]
+        target_bin = np.argmin(distances)
+        
+        if target_bin in self.colour_indices:
+            index, tile_indices = self.colour_indices[target_bin]
+            
+            n_candidates = min(strategy['search_candidates'], len(tile_indices))
+            _, indices = index.kneighbors(target_colour.reshape(1, -1), n_neighbors=n_candidates)
+            
+            best_score = float('inf')
+            best_tile_idx = tile_indices[indices[0][0]]
+            
+            for local_idx in indices[0]:
+                global_tile_idx = tile_indices[local_idx]
+                tile_name = self.tile_names[global_tile_idx]
+                
+                # Skip rotation in face areas
+                if not strategy['allow_rotation'] and '_rot' in tile_name:
+                    continue
+                
+                # Calculate score
+                tile_colour = self.tile_colours[global_tile_idx]
+                color_distance = np.linalg.norm(target_colour - tile_colour) * strategy['precision_factor']
+                
+                usage_penalty = 0
+                if usage_count is not None:
+                    usage_penalty = usage_count.get(tile_name, 0) * strategy['diversity_factor']
+                
+                total_score = color_distance + usage_penalty
+                
+                if total_score < best_score:
+                    best_score = total_score
+                    best_tile_idx = global_tile_idx
+            
+            return best_tile_idx
+        
+        return 0
+    
+    def create_contextual_mosaic(self, image: np.ndarray, grid_size: Tuple[int, int],
+                               diversity_factor: float = 0.1) -> Tuple[np.ndarray, ImageContext]:
+        """Create mosaic with contextual awareness."""
+        print("Creating contextual mosaic...")
+        
+        # Analyze context
+        context = self.analyze_image_context(image)
+        
+        # Setup grid
+        h, w = image.shape[:2]
+        grid_rows, grid_cols = grid_size
+        cell_h = h // grid_rows
+        cell_w = w // grid_cols
+        
+        # Initialize mosaic
+        tile_h, tile_w = self.tile_size[1], self.tile_size[0]
+        mosaic = np.zeros((grid_rows * tile_h, grid_cols * tile_w, 3), dtype=np.uint8)
+        
+        usage_count = {} if diversity_factor > 0 else None
+        
+        print(f"Building {grid_rows}x{grid_cols} mosaic...")
+        
+        for i in tqdm(range(grid_rows), desc="Creating mosaic"):
+            for j in range(grid_cols):
+                # Get cell color
+                start_y = i * cell_h
+                end_y = min(start_y + cell_h, h)
+                start_x = j * cell_w
+                end_x = min(start_x + cell_w, w)
+                
+                cell = image[start_y:end_y, start_x:end_x]
+                target_colour = np.mean(cell, axis=(0, 1))
+                
+                # Find best tile
+                best_tile_idx = self.find_contextual_best_tile(
+                    target_colour, context, (i, j), (grid_rows, grid_cols), usage_count
+                )
+                
+                # Place tile
+                tile_start_row = i * tile_h
+                tile_end_row = tile_start_row + tile_h
+                tile_start_col = j * tile_w
+                tile_end_col = tile_start_col + tile_w
+                
+                mosaic[tile_start_row:tile_end_row, tile_start_col:tile_end_col] = self.tile_images[best_tile_idx]
+                
+                # Update usage
+                if usage_count is not None:
+                    tile_name = self.tile_names[best_tile_idx]
+                    usage_count[tile_name] = usage_count.get(tile_name, 0) + 1
+        
+        print("Contextual mosaic completed")
+        return mosaic, context
+    
+    def visualize_context_analysis(self, image: np.ndarray, context: ImageContext):
+        """Display contextual analysis visualization."""
+        print("Showing context analysis...")
+        
+        fig, axes = plt.subplots(2, 3, figsize=(18, 12))
+        
+        # Original with face overlay
+        img_with_faces = image.copy()
+        for (x, y, w, h) in context.face_regions:
+            cv2.rectangle(img_with_faces, (x, y), (x+w, y+h), (255, 0, 0), 3)
+        
+        axes[0, 0].imshow(img_with_faces)
+        axes[0, 0].set_title(f'Face Detection\n{len(context.face_regions)} faces')
+        axes[0, 0].axis('off')
+        
+        # Brightness map
+        axes[0, 1].imshow(context.brightness_map, cmap='gray')
+        axes[0, 1].set_title('Brightness Map')
+        axes[0, 1].axis('off')
+        
+        # Edge density
+        axes[0, 2].imshow(context.edge_density_map, cmap='hot')
+        axes[0, 2].set_title(f'Edge Density\nComplexity: {context.content_complexity:.3f}')
+        axes[0, 2].axis('off')
+        
+        # Dominant colors
+        colors_display = context.dominant_colors.reshape(1, -1, 3).astype(np.uint8)
+        axes[1, 0].imshow(colors_display)
+        axes[1, 0].set_title('Dominant Colors')
+        axes[1, 0].axis('off')
+        
+        # Scene info
+        scene_text = (f"Scene Analysis:\n\n"
+                     f"Portrait: {context.is_portrait}\n"
+                     f"Landscape: {context.is_landscape}\n"
+                     f"Has Faces: {context.has_faces}\n"
+                     f"Complexity: {context.content_complexity:.3f}")
+        
+        axes[1, 1].text(0.5, 0.5, scene_text, ha='center', va='center', 
+                        fontsize=14, transform=axes[1, 1].transAxes)
+        axes[1, 1].set_title('Scene Classification')
+        axes[1, 1].axis('off')
+        
+        # Color palette
+        if self.colour_palette is not None:
+            palette_display = self.colour_palette.reshape(1, -1, 3).astype(np.uint8)
+            axes[1, 2].imshow(palette_display)
+            axes[1, 2].set_title('Color Palette')
+            axes[1, 2].axis('off')
+        
+        plt.suptitle('Contextual Analysis for Intelligent Tile Selection', fontsize=16)
+        plt.tight_layout()
+        plt.show()