complete the project with additional analyze metric, create comparisons. Update requirements.txt

.gitignore

@@ -2,3 +2,5 @@
 .DS_Store
 cifar_data/
 __pycache__/
+
+output/

analyze_metrics.py

@@ -0,0 +1,577 @@
+#!/usr/bin/env python3
+"""
+Parameter behavior analysis for mosaic generator
+Focuses on: parameter degradation effects, CIFAR comparison, cross-image consistency
+Analyzes three images: akaza, IMG_5090, IMG_6914
+"""
+
+import json
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from pathlib import Path
+import re
+from collections import defaultdict
+import warnings
+warnings.filterwarnings('ignore')
+
+# Configuration
+METRICS_DIR = Path('./output/test_result/metrics')
+OUTPUT_DIR = Path('./output/analysis')
+TARGET_IMAGES = ['akaza', 'IMG_3378', 'IMG_5090', 'IMG_6914']
+
+# Visualization settings
+plt.style.use('default')
+sns.set_palette("husl")
+
+def setup_directories():
+    """Create analysis output directories"""
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    for image in TARGET_IMAGES:
+        (OUTPUT_DIR / image).mkdir(parents=True, exist_ok=True)
+    print(f"[INFO] Created analysis directories under {OUTPUT_DIR}")
+
+def parse_filename(filename):
+    """Parse filename to extract parameters"""
+    # Pattern: {image}-min{min}-max{max}-sub{sub}-quant{quant}-{tile}_metrics.json
+    pattern = r'(.+)-min(\d+)-max(\d+)-sub([0-9p]+)-quant(\d+)-(.+)_metrics\.json'
+    match = re.match(pattern, filename)
+
+    if not match:
+        return None
+
+    image, min_size, max_size, sub_threshold, quantization, tile_library = match.groups()
+
+    # Convert threshold back from string (0p1 -> 0.1)
+    sub_threshold = sub_threshold.replace('p', '.')
+
+    return {
+        'image': image,
+        'min_size': int(min_size),
+        'max_size': int(max_size),
+        'sub_threshold': float(sub_threshold),
+        'quantization': int(quantization),
+        'tile_library': tile_library
+    }
+
+def load_metrics_data():
+    """Load all metrics data and organize by image"""
+    data_by_image = defaultdict(list)
+
+    print("[INFO] Loading metrics data...")
+
+    for json_file in METRICS_DIR.glob('*.json'):
+        # Skip files not belonging to our target images
+        if not any(img in json_file.name for img in TARGET_IMAGES):
+            continue
+
+        parsed = parse_filename(json_file.name)
+        if parsed is None:
+            continue
+
+        # Load metrics
+        try:
+            with open(json_file, 'r') as f:
+                metrics = json.load(f)
+
+            # Combine parameters and metrics
+            record = {**parsed, **metrics}
+            data_by_image[parsed['image']].append(record)
+
+        except Exception as e:
+            print(f"[WARNING] Failed to load {json_file.name}: {e}")
+
+    # Convert to DataFrames
+    dfs = {}
+    for image, records in data_by_image.items():
+        df = pd.DataFrame(records)
+        dfs[image] = df
+        print(f"[INFO] Loaded {len(df)} records for {image}")
+
+    return dfs
+
+def create_heatmaps(df, image_name):
+    """Create heatmap visualizations for an image"""
+    print(f"[INFO] Creating heatmaps for {image_name}")
+
+    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+    fig.suptitle(f'Parameter Impact Heatmaps - {image_name}', fontsize=16, fontweight='bold')
+
+    # 1. Min_size vs Max_size colored by SSIM
+    pivot1 = df.pivot_table(values='SSIM', index='min_size', columns='max_size', aggfunc='mean')
+    sns.heatmap(pivot1, annot=True, fmt='.3f', ax=axes[0,0], cmap='RdYlGn')
+    axes[0,0].set_title('SSIM by Min/Max Size')
+    axes[0,0].set_xlabel('Max Size')
+    axes[0,0].set_ylabel('Min Size')
+
+    # 2. Quantization vs Tile_library colored by Overall_Quality
+    pivot2 = df.pivot_table(values='Overall_Quality', index='quantization', columns='tile_library', aggfunc='mean')
+    sns.heatmap(pivot2, annot=True, fmt='.3f', ax=axes[0,1], cmap='RdYlGn')
+    axes[0,1].set_title('Overall Quality by Quantization/Tile Library')
+    axes[0,1].set_xlabel('Tile Library')
+    axes[0,1].set_ylabel('Quantization')
+
+    # 3. Subdivision vs Quantization colored by MSE (inverted colormap since lower MSE is better)
+    pivot3 = df.pivot_table(values='MSE', index='sub_threshold', columns='quantization', aggfunc='mean')
+    sns.heatmap(pivot3, annot=True, fmt='.0f', ax=axes[1,0], cmap='RdYlGn_r')
+    axes[1,0].set_title('MSE by Subdivision/Quantization')
+    axes[1,0].set_xlabel('Quantization')
+    axes[1,0].set_ylabel('Subdivision Threshold')
+
+    # 4. Tile library vs Min_size colored by Edge_Similarity
+    pivot4 = df.pivot_table(values='Edge_Similarity', index='tile_library', columns='min_size', aggfunc='mean')
+    sns.heatmap(pivot4, annot=True, fmt='.3f', ax=axes[1,1], cmap='RdYlGn')
+    axes[1,1].set_title('Edge Similarity by Tile Library/Min Size')
+    axes[1,1].set_xlabel('Min Size')
+    axes[1,1].set_ylabel('Tile Library')
+
+    plt.tight_layout()
+    output_path = OUTPUT_DIR / image_name / 'heatmaps.png'
+    plt.savefig(output_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f"[INFO] Saved heatmaps to {output_path}")
+
+def create_metric_comparisons(df, image_name):
+    """Create metric comparison charts"""
+    print(f"[INFO] Creating metric comparisons for {image_name}")
+
+    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+    fig.suptitle(f'Metric Comparisons - {image_name}', fontsize=16, fontweight='bold')
+
+    # 1. Box plots by tile library
+    metrics_to_plot = ['SSIM', 'Histogram_Correlation', 'Edge_Similarity', 'Overall_Quality']
+
+    for i, metric in enumerate(metrics_to_plot):
+        ax = axes[i//2, i%2]
+        df.boxplot(column=metric, by='tile_library', ax=ax)
+        ax.set_title(f'{metric} by Tile Library')
+        ax.set_xlabel('Tile Library')
+        ax.set_ylabel(metric)
+        ax.grid(True, alpha=0.3)
+
+    plt.suptitle('')  # Remove automatic title
+    fig.suptitle(f'Metric Distribution by Tile Library - {image_name}', fontsize=16, fontweight='bold')
+    plt.tight_layout()
+
+    output_path = OUTPUT_DIR / image_name / 'metric_comparison.png'
+    plt.savefig(output_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f"[INFO] Saved metric comparison to {output_path}")
+
+def create_parameter_impact(df, image_name):
+    """Create parameter impact analysis"""
+    print(f"[INFO] Creating parameter impact analysis for {image_name}")
+
+    fig, axes = plt.subplots(2, 3, figsize=(18, 12))
+    fig.suptitle(f'Parameter Impact Analysis - {image_name}', fontsize=16, fontweight='bold')
+
+    # 1a. Quality metrics by quantization
+    quantization_impact = df.groupby('quantization')[['MSE', 'SSIM', 'Histogram_Correlation', 'Edge_Similarity']].mean()
+
+    quality_metrics = ['SSIM', 'Histogram_Correlation', 'Edge_Similarity']
+    quantization_impact[quality_metrics].plot(kind='bar', ax=axes[0,0])
+    axes[0,0].set_title('Quality Metrics by Quantization')
+    axes[0,0].set_xlabel('Quantization')
+    axes[0,0].set_ylabel('Metric Value')
+    axes[0,0].legend()
+    axes[0,0].tick_params(axis='x', rotation=0)
+    axes[0,0].grid(True, alpha=0.3)
+
+    # 1b. MSE by quantization (separate subplot)
+    quantization_impact['MSE'].plot(kind='bar', ax=axes[0,1], color='red')
+    axes[0,1].set_title('MSE by Quantization')
+    axes[0,1].set_xlabel('Quantization')
+    axes[0,1].set_ylabel('MSE')
+    axes[0,1].tick_params(axis='x', rotation=0)
+    axes[0,1].grid(True, alpha=0.3)
+
+    # 2. Size ratio impact (max/min)
+    df['size_ratio'] = df['max_size'] / df['min_size']
+    size_ratio_impact = df.groupby('size_ratio')['Overall_Quality'].mean()
+    size_ratio_impact.plot(kind='bar', ax=axes[0,2], color='skyblue')
+    axes[0,2].set_title('Overall Quality by Size Ratio (Max/Min)')
+    axes[0,2].set_xlabel('Size Ratio')
+    axes[0,2].set_ylabel('Overall Quality')
+    axes[0,2].tick_params(axis='x', rotation=45)
+    axes[0,2].grid(True, alpha=0.3)
+
+    # 3. Subdivision threshold impact
+    sub_impact = df.groupby('sub_threshold')['Overall_Quality'].mean()
+    sub_impact.plot(kind='bar', ax=axes[1,0], color='lightcoral')
+    axes[1,0].set_title('Overall Quality by Subdivision Threshold')
+    axes[1,0].set_xlabel('Subdivision Threshold')
+    axes[1,0].set_ylabel('Overall Quality')
+    axes[1,0].tick_params(axis='x', rotation=0)
+    axes[1,0].grid(True, alpha=0.3)
+
+    # 4a. Quality metrics by tile library
+    tile_performance = df.groupby('tile_library')[['MSE', 'SSIM', 'Histogram_Correlation', 'Edge_Similarity']].mean()
+    quality_metrics = ['SSIM', 'Histogram_Correlation', 'Edge_Similarity']
+    tile_performance[quality_metrics].plot(kind='bar', ax=axes[1,1])
+    axes[1,1].set_title('Quality Metrics by Tile Library')
+    axes[1,1].set_xlabel('Tile Library')
+    axes[1,1].set_ylabel('Metric Value')
+    axes[1,1].legend()
+    axes[1,1].tick_params(axis='x', rotation=45)
+    axes[1,1].grid(True, alpha=0.3)
+
+    # 4b. MSE by tile library
+    tile_performance['MSE'].plot(kind='bar', ax=axes[1,2], color='red')
+    axes[1,2].set_title('MSE by Tile Library')
+    axes[1,2].set_xlabel('Tile Library')
+    axes[1,2].set_ylabel('MSE')
+    axes[1,2].tick_params(axis='x', rotation=45)
+    axes[1,2].grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    output_path = OUTPUT_DIR / image_name / 'parameter_impact.png'
+    plt.savefig(output_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f"[INFO] Saved parameter impact to {output_path}")
+
+def analyze_parameter_degradation(df, image_name):
+    """Analyze which parameters cause quality degradation (for artistic/mosaic effects)"""
+    print(f"[INFO] Analyzing parameter degradation effects for {image_name}")
+
+    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+    fig.suptitle(f'Parameter Degradation Analysis (For Artistic Effects) - {image_name}', fontsize=16, fontweight='bold')
+
+    # 1. Which parameters INCREASE MSE (worse quality = more artistic)
+    mse_by_param = {}
+    mse_by_param['quantization'] = df.groupby('quantization')['MSE'].mean()
+    mse_by_param['min_size'] = df.groupby('min_size')['MSE'].mean()
+    mse_by_param['max_size'] = df.groupby('max_size')['MSE'].mean()
+    mse_by_param['sub_threshold'] = df.groupby('sub_threshold')['MSE'].mean()
+
+    # Plot MSE increase trends
+    ax = axes[0,0]
+    colors = ['red', 'orange', 'green', 'blue']
+    for i, (param, values) in enumerate(mse_by_param.items()):
+        ax.plot(values.index, values.values, marker='o', label=param, color=colors[i], linewidth=2)
+
+    ax.set_title('MSE by Parameters (Higher = More Artistic)')
+    ax.set_xlabel('Parameter Value')
+    ax.set_ylabel('Average MSE')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 2. Which parameters DECREASE SSIM (worse similarity = more artistic)
+    ssim_by_param = {}
+    ssim_by_param['quantization'] = df.groupby('quantization')['SSIM'].mean()
+    ssim_by_param['min_size'] = df.groupby('min_size')['SSIM'].mean()
+    ssim_by_param['max_size'] = df.groupby('max_size')['SSIM'].mean()
+    ssim_by_param['sub_threshold'] = df.groupby('sub_threshold')['SSIM'].mean()
+
+    ax = axes[0,1]
+    for i, (param, values) in enumerate(ssim_by_param.items()):
+        ax.plot(values.index, values.values, marker='s', label=param, color=colors[i], linewidth=2)
+
+    ax.set_title('SSIM by Parameters (Lower = More Artistic)')
+    ax.set_xlabel('Parameter Value')
+    ax.set_ylabel('Average SSIM')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 3. Parameter impact ranking for degradation
+    degradation_impact = {}
+
+    # Calculate impact as difference between max and min values (normalized)
+    for param in ['quantization', 'min_size', 'max_size', 'sub_threshold']:
+        mse_range = mse_by_param[param].max() - mse_by_param[param].min()
+        ssim_range = ssim_by_param[param].max() - ssim_by_param[param].min()
+
+        # Normalize by overall metric range
+        mse_impact = mse_range / df['MSE'].std()
+        ssim_impact = ssim_range / df['SSIM'].std()
+
+        degradation_impact[param] = (mse_impact + ssim_impact) / 2
+
+    # Plot simple impact ranking
+    ax = axes[1,0]
+    params = list(degradation_impact.keys())
+    impacts = list(degradation_impact.values())
+
+    ax.bar(params, impacts, color='lightcoral')
+    ax.set_title('Parameter Impact on Quality Degradation')
+    ax.set_xlabel('Parameters')
+    ax.set_ylabel('Impact Score')
+    ax.tick_params(axis='x', rotation=45)
+    ax.grid(True, alpha=0.3)
+
+    # Add score labels
+    for i, (param, impact) in enumerate(zip(params, impacts)):
+        ax.text(i, impact + 0.05, f'{impact:.2f}', ha='center', va='bottom')
+
+    # 4. Empty subplot (remove recommendations)
+    axes[1,1].axis('off')
+
+    plt.tight_layout()
+    output_path = OUTPUT_DIR / image_name / 'parameter_degradation.png'
+    plt.savefig(output_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f"[INFO] Saved parameter degradation analysis to {output_path}")
+
+def analyze_cifar_comparison(df, image_name):
+    """Direct comparison between CIFAR-10 and CIFAR-100"""
+    print(f"[INFO] Analyzing CIFAR-10 vs CIFAR-100 comparison for {image_name}")
+
+    # Filter data for CIFAR comparisons only
+    cifar_data = df[df['tile_library'].isin(['cifar-10', 'cifar-100'])].copy()
+
+    if len(cifar_data) == 0:
+        print(f"[WARNING] No CIFAR data found for {image_name}")
+        return
+
+    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+    fig.suptitle(f'CIFAR-10 vs CIFAR-100 Direct Comparison - {image_name}', fontsize=16, fontweight='bold')
+
+    # 1a. Quality metrics comparison
+    metrics = ['MSE', 'SSIM', 'Histogram_Correlation', 'Edge_Similarity']
+    cifar_comparison = cifar_data.groupby('tile_library')[metrics].mean()
+
+    quality_metrics = ['SSIM', 'Histogram_Correlation', 'Edge_Similarity']
+    cifar_comparison[quality_metrics].T.plot(kind='bar', ax=axes[0,0], color=['lightblue', 'lightcoral'])
+    axes[0,0].set_title('Quality Metrics Comparison')
+    axes[0,0].set_ylabel('Metric Value')
+    axes[0,0].legend(title='Tile Library')
+    axes[0,0].tick_params(axis='x', rotation=45)
+    axes[0,0].grid(True, alpha=0.3)
+
+    # 1b. MSE comparison (separate subplot)
+    cifar_comparison['MSE'].plot(kind='bar', ax=axes[0,1], color=['red', 'orange'])
+    axes[0,1].set_title('MSE Comparison')
+    axes[0,1].set_ylabel('MSE')
+    axes[0,1].legend(['CIFAR-10', 'CIFAR-100'])
+    axes[0,1].grid(True, alpha=0.3)
+
+    # 2. Paired comparison for same parameter settings
+    # Create parameter combination identifier
+    cifar_data['param_combo'] = (cifar_data['min_size'].astype(str) + '_' +
+                                 cifar_data['max_size'].astype(str) + '_' +
+                                 cifar_data['sub_threshold'].astype(str) + '_' +
+                                 cifar_data['quantization'].astype(str))
+
+    # Find configurations that exist for both CIFAR types
+    cifar10_combos = set(cifar_data[cifar_data['tile_library'] == 'cifar-10']['param_combo'])
+    cifar100_combos = set(cifar_data[cifar_data['tile_library'] == 'cifar-100']['param_combo'])
+    common_combos = cifar10_combos.intersection(cifar100_combos)
+
+    paired_data = []
+    for combo in common_combos:
+        combo_data = cifar_data[cifar_data['param_combo'] == combo]
+        if len(combo_data) == 2:  # Should have both CIFAR-10 and CIFAR-100
+            cifar10_row = combo_data[combo_data['tile_library'] == 'cifar-10'].iloc[0]
+            cifar100_row = combo_data[combo_data['tile_library'] == 'cifar-100'].iloc[0]
+
+            paired_data.append({
+                'combo': combo,
+                'cifar10_ssim': cifar10_row['SSIM'],
+                'cifar100_ssim': cifar100_row['SSIM'],
+                'cifar10_mse': cifar10_row['MSE'],
+                'cifar100_mse': cifar100_row['MSE'],
+                'ssim_diff': cifar10_row['SSIM'] - cifar100_row['SSIM'],
+                'mse_diff': cifar10_row['MSE'] - cifar100_row['MSE']
+            })
+
+    paired_df = pd.DataFrame(paired_data)
+
+    # 2. Win/Loss analysis
+    ax = axes[1,0]
+    if len(paired_df) > 0:
+        ssim_wins = (paired_df['ssim_diff'] > 0).sum()  # CIFAR-10 wins
+        ssim_losses = (paired_df['ssim_diff'] < 0).sum()  # CIFAR-100 wins
+
+        mse_wins = (paired_df['mse_diff'] < 0).sum()  # CIFAR-10 wins (lower MSE is better)
+        mse_losses = (paired_df['mse_diff'] > 0).sum()  # CIFAR-100 wins
+
+        categories = ['SSIM', 'MSE']
+        cifar10_scores = [ssim_wins, mse_wins]
+        cifar100_scores = [ssim_losses, mse_losses]
+
+        x = np.arange(len(categories))
+        width = 0.35
+
+        ax.bar(x - width/2, cifar10_scores, width, label='CIFAR-10 Wins', color='lightblue')
+        ax.bar(x + width/2, cifar100_scores, width, label='CIFAR-100 Wins', color='lightcoral')
+
+        ax.set_title(f'Win/Loss Analysis ({len(paired_df)} comparisons)')
+        ax.set_ylabel('Number of Wins')
+        ax.set_xticks(x)
+        ax.set_xticklabels(categories)
+        ax.legend()
+        ax.grid(True, alpha=0.3)
+
+        # Add value labels
+        for i, (c10, c100) in enumerate(zip(cifar10_scores, cifar100_scores)):
+            ax.text(i - width/2, c10 + 0.5, str(c10), ha='center', va='bottom')
+            ax.text(i + width/2, c100 + 0.5, str(c100), ha='center', va='bottom')
+
+    # 3. Performance difference distribution
+    ax = axes[1,1]
+    if len(paired_df) > 0:
+        ax.hist(paired_df['ssim_diff'], bins=20, alpha=0.7, color='skyblue', edgecolor='black')
+        ax.axvline(x=0, color='red', linestyle='--', linewidth=2)
+        ax.set_title('SSIM Difference Distribution (CIFAR-10 - CIFAR-100)')
+        ax.set_xlabel('SSIM Difference')
+        ax.set_ylabel('Frequency')
+        ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    output_path = OUTPUT_DIR / image_name / 'cifar_comparison.png'
+    plt.savefig(output_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f"[INFO] Saved CIFAR comparison to {output_path}")
+
+def analyze_size_consistency(all_dfs):
+    """Analyze if min/max size effects are consistent across images"""
+    print("[INFO] Analyzing min/max size consistency across images")
+
+    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+    fig.suptitle('Min/Max Size Effects Consistency Across Images', fontsize=16, fontweight='bold')
+
+    # Combine all data
+    combined_data = []
+    for image_name, df in all_dfs.items():
+        df_copy = df.copy()
+        df_copy['image'] = image_name
+        combined_data.append(df_copy)
+
+    combined_df = pd.concat(combined_data, ignore_index=True)
+
+    # 1. Min size effect on SSIM across images
+    ax = axes[0,0]
+    for image in TARGET_IMAGES:
+        image_data = combined_df[combined_df['image'] == image]
+        min_size_effect = image_data.groupby('min_size')['SSIM'].mean()
+        ax.plot(min_size_effect.index, min_size_effect.values, marker='o', label=image, linewidth=2)
+
+    ax.set_title('Min Size Effect on SSIM')
+    ax.set_xlabel('Min Size')
+    ax.set_ylabel('Average SSIM')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 2. Max size effect on SSIM across images
+    ax = axes[0,1]
+    for image in TARGET_IMAGES:
+        image_data = combined_df[combined_df['image'] == image]
+        max_size_effect = image_data.groupby('max_size')['SSIM'].mean()
+        ax.plot(max_size_effect.index, max_size_effect.values, marker='s', label=image, linewidth=2)
+
+    ax.set_title('Max Size Effect on SSIM')
+    ax.set_xlabel('Max Size')
+    ax.set_ylabel('Average SSIM')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 3. Size ratio consistency
+    combined_df['size_ratio'] = combined_df['max_size'] / combined_df['min_size']
+
+    ax = axes[1,0]
+    for image in TARGET_IMAGES:
+        image_data = combined_df[combined_df['image'] == image]
+        ratio_effect = image_data.groupby('size_ratio')['Overall_Quality'].mean()
+        ax.plot(ratio_effect.index, ratio_effect.values, marker='^', label=image, linewidth=2)
+
+    ax.set_title('Size Ratio Effect on Overall Quality')
+    ax.set_xlabel('Size Ratio (Max/Min)')
+    ax.set_ylabel('Average Overall Quality')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 4. Size ratio effect comparison
+    ax = axes[1,1]
+
+    # Show correlation values as a simple bar chart
+    consistency_analysis = {}
+
+    for size_param in ['min_size', 'max_size']:
+        param_effects = {}
+        for image in TARGET_IMAGES:
+            image_data = combined_df[combined_df['image'] == image]
+            effect = image_data.groupby(size_param)['SSIM'].mean()
+            param_effects[image] = effect
+
+        # Calculate correlation between images
+        correlations = []
+        images = list(param_effects.keys())
+        for i in range(len(images)):
+            for j in range(i+1, len(images)):
+                # Find common parameter values
+                common_params = set(param_effects[images[i]].index).intersection(
+                    set(param_effects[images[j]].index)
+                )
+                if len(common_params) > 1:
+                    vals_i = [param_effects[images[i]][p] for p in common_params]
+                    vals_j = [param_effects[images[j]][p] for p in common_params]
+                    corr = np.corrcoef(vals_i, vals_j)[0,1]
+                    correlations.append(corr)
+
+        consistency_analysis[size_param] = np.mean(correlations) if correlations else 0
+
+    # Plot consistency as bar chart
+    params = list(consistency_analysis.keys())
+    correlations = list(consistency_analysis.values())
+
+    ax.bar(params, correlations, color=['skyblue', 'lightgreen'])
+    ax.set_title('Parameter Consistency Across Images')
+    ax.set_xlabel('Size Parameters')
+    ax.set_ylabel('Average Correlation')
+    ax.set_ylim(0, 1)
+    ax.grid(True, alpha=0.3)
+
+    # Add correlation values
+    for i, (param, corr) in enumerate(zip(params, correlations)):
+        ax.text(i, corr + 0.02, f'{corr:.3f}', ha='center', va='bottom')
+
+    plt.tight_layout()
+    output_path = OUTPUT_DIR / 'size_consistency_analysis.png'
+    plt.savefig(output_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f"[INFO] Saved size consistency analysis to {output_path}")
+
+
+def main():
+    """Main analysis function"""
+    print("=" * 60)
+    print("MOSAIC PARAMETER BEHAVIOR ANALYSIS")
+    print("=" * 60)
+
+    setup_directories()
+
+    # Load data
+    all_dfs = load_metrics_data()
+
+    if not all_dfs:
+        print("[ERROR] No data loaded. Check metrics directory.")
+        return
+
+    # Analyze each image
+    for image_name, df in all_dfs.items():
+        print(f"\n[INFO] Analyzing {image_name}...")
+
+        # Keep original heatmaps and parameter impact
+        create_heatmaps(df, image_name)
+        create_parameter_impact(df, image_name)
+
+        # New analyses
+        analyze_parameter_degradation(df, image_name)
+        analyze_cifar_comparison(df, image_name)
+
+    # Cross-image consistency analysis
+    analyze_size_consistency(all_dfs)
+
+    print("\n" + "=" * 60)
+    print("ANALYSIS COMPLETE!")
+    print("=" * 60)
+    print(f"Results saved to: {OUTPUT_DIR}")
+    print("\nGenerated analyses:")
+    print("• heatmaps.png - Parameter impact heatmaps")
+    print("• parameter_impact.png - Parameter effect analysis")
+    print("• parameter_degradation.png - Settings for artistic effects")
+    print("• cifar_comparison.png - CIFAR-10 vs CIFAR-100 comparison")
+    print("• size_consistency_analysis.png - Cross-image size effect consistency")
+
+if __name__ == "__main__":
+    main()

create_comparison.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""
+Create horizontal comparison of IMG_3378 mosaic images with different min_size settings
+"""
+
+from PIL import Image, ImageDraw, ImageFont
+import os
+from pathlib import Path
+
+# Image paths for Figure 3 (2x2 grid)
+image_paths = [
+    "./samples/akaza.jpg",  # Original
+    "./output/test_result/mosaic_images/akaza-min16-max32-sub5-quant0-cifar-10.jpg",
+    "./output/test_result/mosaic_images/akaza-min16-max32-sub5-quant16-cifar-10.jpg",
+    "./output/test_result/mosaic_images/akaza-min16-max32-sub5-quant32-cifar-10.jpg"
+]
+
+# Labels for each image
+labels = ["Original", "quant = 0", "quant = 16", "quant = 32"]
+
+def create_comparison():
+    """Create 2x2 grid comparison image"""
+
+    # Load images
+    images = []
+    for path in image_paths:
+        if os.path.exists(path):
+            img = Image.open(path).convert('RGB')
+            images.append(img)
+            print(f"[INFO] Loaded: {path} | size = {img.size}")
+        else:
+            print(f"[ERROR] File not found: {path}")
+            return None
+
+    if len(images) != 4:
+        print(f"[ERROR] Expected 4 images, found {len(images)}")
+        return None
+
+    # Get dimensions and calculate scale
+    original_width, original_height = images[0].size
+
+    # Scale down to fit reasonable comparison size (e.g., each image 400px wide)
+    target_width = 400
+    scale = target_width / original_width
+    target_height = int(original_height * scale)
+
+    print(f"[INFO] Scaling from {original_width}x{original_height} to {target_width}x{target_height}")
+
+    # Resize all images to same scale
+    resized_images = []
+    for img in images:
+        resized = img.resize((target_width, target_height), Image.BICUBIC)
+        resized_images.append(resized)
+
+    # Create comparison canvas for 2x2 grid
+    margin = 20
+    label_height = 40
+    canvas_width = target_width * 2 + margin * 3
+    canvas_height = target_height * 2 + label_height + margin * 4
+
+    canvas = Image.new('RGB', (canvas_width, canvas_height), color='white')
+
+    # Paste images in 2x2 grid
+    draw = ImageDraw.Draw(canvas)
+
+    # Try to use a system font, fallback to default
+    try:
+        font = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", 20)
+    except:
+        try:
+            font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 20)
+        except:
+            font = ImageFont.load_default()
+
+    for i, (img, label) in enumerate(zip(resized_images, labels)):
+        # Calculate grid position (2x2)
+        row = i // 2
+        col = i % 2
+
+        x_pos = margin + col * (target_width + margin)
+        y_pos = margin + label_height + row * (target_height + margin)
+
+        canvas.paste(img, (x_pos, y_pos))
+
+        # Add label above each image
+        bbox = draw.textbbox((0, 0), label, font=font)
+        text_width = bbox[2] - bbox[0]
+        text_x = x_pos + (target_width - text_width) // 2
+        text_y = y_pos - label_height + 5
+
+        draw.text((text_x, text_y), label, fill='black', font=font)
+
+    # Add title
+    title = "Figure 3. Akaza Color Quantization Comparison (min16-max32-sub5-cifar-10)"
+    try:
+        title_font = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", 16)
+    except:
+        title_font = font
+
+    title_bbox = draw.textbbox((0, 0), title, font=title_font)
+    title_width = title_bbox[2] - title_bbox[0]
+    title_x = (canvas_width - title_width) // 2
+    title_y = canvas_height - margin + 5
+
+    draw.text((title_x, title_y), title, fill='gray', font=title_font)
+
+    return canvas
+
+def main():
+    print("=" * 60)
+    print("Creating Akaza Color Quantization Comparison")
+    print("=" * 60)
+
+    # Create comparison
+    comparison_img = create_comparison()
+
+    if comparison_img:
+        # Save result
+        output_path = "./output/akaza_quantization_comparison.png"
+        comparison_img.save(output_path, quality=95)
+        print(f"\n[SUCCESS] Comparison saved to: {output_path}")
+        print(f"[INFO] Canvas size: {comparison_img.size}")
+    else:
+        print("\n[ERROR] Failed to create comparison")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,19 @@
+# Core dependencies for Interactive Image Mosaic Generator
+torch>=2.0.0
+torchvision>=0.15.0
+pillow>=9.0.0
+numpy>=1.21.0
+
+# GUI framework
+gradio>=4.0.0
+
+# Image processing and computer vision
+opencv-python>=4.5.0
+scikit-image>=0.19.0
+
+# Data analysis and progress tracking
+pandas>=1.3.0
+tqdm>=4.60.0
+
+# Optional: for better performance
+scipy>=1.7.0

test.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""
+Comprehensive test script for Interactive Image Mosaic Generator
+Tests multiple parameter combinations and saves results with performance metrics
+"""
+
+import os
+import json
+import csv
+from pathlib import Path
+from itertools import product
+import tempfile
+from tqdm import tqdm
+import pandas as pd
+
+from simple_mosaic import SimpleMosaicImage
+from tile_library import build_cifar10_tile_library, build_cifar100_tile_library
+from performance import calculate_all_metrics
+from PIL import Image
+
+# Test parameters
+TEST_PARAMS = {
+    'min_size': [4, 16, 32],
+    'start_size': [32, 64, 128],  # max size
+    'threshold': [0.1, 5.0],      # subdivision threshold
+    'color_quantization': [0, 16, 32],
+    'tile_library': ['none', 'cifar-10', 'cifar-100']
+}
+
+# Input and output directories
+SAMPLES_DIR = Path('./samples')
+OUTPUT_DIR = Path('./output/test_result')
+MOSAIC_DIR = OUTPUT_DIR / 'mosaic_images'
+METRICS_DIR = OUTPUT_DIR / 'metrics'
+
+# Tile cache to avoid reloading
+tile_cache = {}
+
+def setup_directories():
+    """Create necessary output directories"""
+    for dir_path in [OUTPUT_DIR, MOSAIC_DIR, METRICS_DIR]:
+        dir_path.mkdir(parents=True, exist_ok=True)
+    print(f"[INFO] Created output directories under {OUTPUT_DIR}")
+
+def get_tile_library(tile_type, max_per_class=500):
+    """Get cached tile library or create new one"""
+    if tile_type == 'none':
+        return None, None, None
+
+    cache_key = f"{tile_type}_{max_per_class}"
+
+    if cache_key not in tile_cache:
+        print(f"[INFO] Loading {tile_type} tile library...")
+        if tile_type == "cifar-10":
+            tiles, means, labels = build_cifar10_tile_library(max_per_class=max_per_class)
+        elif tile_type == "cifar-100":
+            tiles, means, labels = build_cifar100_tile_library(max_per_class=max_per_class)
+        else:
+            return None, None, None
+
+        tile_cache[cache_key] = (tiles, means, labels)
+        print(f"[INFO] Cached {len(tiles)} tiles for {tile_type}")
+
+    return tile_cache[cache_key]
+
+def generate_filename(image_name, min_size, start_size, threshold, color_quantization, tile_library):
+    """Generate standardized filename for results"""
+    # Clean image name (remove extension)
+    base_name = Path(image_name).stem
+
+    # Format threshold to avoid decimal issues
+    threshold_str = f"{threshold:g}".replace('.', 'p')
+
+    # Create filename
+    filename = f"{base_name}-min{min_size}-max{start_size}-sub{threshold_str}-quant{color_quantization}-{tile_library}"
+
+    return filename
+
+def process_single_combination(image_path, params, progress_bar=None):
+    """Process a single parameter combination and return results"""
+    image_name = image_path.name
+    min_size, start_size, threshold, color_quantization, tile_library = params
+
+    try:
+        # Load original image
+        original_image = Image.open(image_path).convert("RGB")
+
+        # Create temporary file for processing
+        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp_file:
+            original_image.save(tmp_file.name)
+
+            # Load and process image
+            loader = SimpleMosaicImage(tmp_file.name)
+
+            # Apply resize if needed (use existing MAX_IMAGE_SIZE logic)
+            MAX_IMAGE_SIZE = 4500
+            if max(loader.width, loader.height) > MAX_IMAGE_SIZE:
+                loader.resize(MAX_IMAGE_SIZE)
+
+            # Apply color quantization if requested
+            if color_quantization > 0:
+                loader.quantize_colors(color_quantization)
+
+            # Smart boundary handling
+            loader.crop_to_grid(2)
+
+            # Build adaptive cells
+            cells = loader.build_adaptive_cells(
+                start_size=start_size,
+                min_size=min_size,
+                threshold=threshold
+            )
+
+            # Generate mosaic based on tile type
+            if tile_library == "none":
+                result_img = loader.mosaic_average_color_adaptive(cells)
+                processing_info = f"Average colors with {len(cells)} adaptive cells"
+            else:
+                tiles, tile_means, _ = get_tile_library(tile_library, max_per_class=500)
+                if tiles is None:
+                    raise ValueError(f"Failed to load {tile_library} tile library")
+
+                result_img = loader.mosaic_with_tiles_adaptive(cells, tiles, tile_means)
+                processing_info = f"{tile_library} with {len(cells)} cells using {len(tiles)} tiles"
+
+            # Calculate metrics
+            metrics = calculate_all_metrics(original_image, result_img)
+
+            # Generate filenames
+            base_filename = generate_filename(
+                image_name, min_size, start_size, threshold, color_quantization, tile_library
+            )
+
+            # Save mosaic image
+            mosaic_path = MOSAIC_DIR / f"{base_filename}.jpg"
+            result_img.save(mosaic_path, quality=95)
+
+            # Save metrics
+            metrics_path = METRICS_DIR / f"{base_filename}_metrics.json"
+            with open(metrics_path, 'w') as f:
+                json.dump(metrics, f, indent=2)
+
+            # Clean up temporary file
+            os.unlink(tmp_file.name)
+
+            # Update progress bar
+            if progress_bar:
+                progress_bar.set_postfix({
+                    'image': image_name[:15],
+                    'params': f"min{min_size}_max{start_size}_sub{threshold:g}_q{color_quantization}_{tile_library[:6]}"
+                })
+                progress_bar.update(1)
+
+            return {
+                'image_name': image_name,
+                'min_size': min_size,
+                'start_size': start_size,
+                'threshold': threshold,
+                'color_quantization': color_quantization,
+                'tile_library': tile_library,
+                'num_cells': len(cells),
+                'processing_info': processing_info,
+                'mosaic_path': str(mosaic_path),
+                'metrics_path': str(metrics_path),
+                'success': True,
+                **metrics
+            }
+
+    except Exception as e:
+        error_msg = f"Error processing {image_name} with params {params}: {str(e)}"
+        print(f"[ERROR] {error_msg}")
+
+        if progress_bar:
+            progress_bar.update(1)
+
+        return {
+            'image_name': image_name,
+            'min_size': min_size,
+            'start_size': start_size,
+            'threshold': threshold,
+            'color_quantization': color_quantization,
+            'tile_library': tile_library,
+            'success': False,
+            'error': str(e),
+            'MSE': float('nan'),
+            'SSIM': float('nan'),
+            'Histogram_Correlation': float('nan'),
+            'Edge_Similarity': float('nan'),
+            'Overall_Quality': float('nan')
+        }
+
+def run_comprehensive_test():
+    """Run comprehensive test across all parameter combinations"""
+    setup_directories()
+
+    # Find all image files in samples directory
+    image_files = []
+    for ext in ['*.jpg', '*.jpeg', '*.JPG', '*.JPEG', '*.png', '*.PNG']:
+        image_files.extend(list(SAMPLES_DIR.glob(ext)))
+
+    if not image_files:
+        print(f"[ERROR] No image files found in {SAMPLES_DIR}")
+        return
+
+    print(f"[INFO] Found {len(image_files)} images to process")
+    print(f"[INFO] Images: {[f.name for f in image_files]}")
+
+    # Generate all parameter combinations
+    param_combinations = list(product(
+        TEST_PARAMS['min_size'],
+        TEST_PARAMS['start_size'],
+        TEST_PARAMS['threshold'],
+        TEST_PARAMS['color_quantization'],
+        TEST_PARAMS['tile_library']
+    ))
+
+    # Filter out invalid combinations (min_size >= start_size)
+    valid_combinations = [
+        combo for combo in param_combinations
+        if combo[0] < combo[1]  # min_size < start_size
+    ]
+
+    total_tests = len(image_files) * len(valid_combinations)
+    print(f"[INFO] Total test combinations: {total_tests}")
+    print(f"[INFO] Parameter combinations per image: {len(valid_combinations)}")
+
+    # Results storage
+    all_results = []
+
+    # Create progress bar
+    with tqdm(total=total_tests, desc="Processing mosaics", unit="test") as pbar:
+        for image_path in image_files:
+            print(f"\n[INFO] Processing image: {image_path.name}")
+
+            for params in valid_combinations:
+                result = process_single_combination(image_path, params, pbar)
+                all_results.append(result)
+
+    # Save comprehensive results to CSV
+    summary_path = OUTPUT_DIR / 'summary.csv'
+    df = pd.DataFrame(all_results)
+    df.to_csv(summary_path, index=False)
+
+    # Print summary statistics
+    successful_tests = df[df['success'] == True]
+    failed_tests = df[df['success'] == False]
+
+    print(f"\n[SUMMARY]")
+    print(f"Total tests run: {len(all_results)}")
+    print(f"Successful: {len(successful_tests)}")
+    print(f"Failed: {len(failed_tests)}")
+
+    if len(successful_tests) > 0:
+        print(f"\nPerformance Statistics (successful tests):")
+        print(f"Average MSE: {successful_tests['MSE'].mean():.2f}")
+        print(f"Average SSIM: {successful_tests['SSIM'].mean():.4f}")
+        print(f"Average Histogram Correlation: {successful_tests['Histogram_Correlation'].mean():.4f}")
+        print(f"Average Edge Similarity: {successful_tests['Edge_Similarity'].mean():.4f}")
+        print(f"Average Overall Quality: {successful_tests['Overall_Quality'].mean():.4f}")
+
+    print(f"\nResults saved to:")
+    print(f"- Summary CSV: {summary_path}")
+    print(f"- Mosaic images: {MOSAIC_DIR}")
+    print(f"- Individual metrics: {METRICS_DIR}")
+
+    return all_results
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("Interactive Image Mosaic Generator - Comprehensive Test")
+    print("=" * 60)
+
+    results = run_comprehensive_test()
+
+    print("\n" + "=" * 60)
+    print("Test completed successfully!")
+    print("=" * 60)