performance metrics

app.py

@@ -3,13 +3,18 @@ import cv2
 import numpy as np
 from PIL import Image
 import os
+import time
 from logic.imgPreprocess import resize_img, color_quantize
 from logic.imgGrid import segment_image_grid
 from logic.tileMapping import load_tile_images, map_tiles_to_grid
-from logic.perfMetric import mse, ssim_metric, timed
+from logic.perfMetric import mse, ssim_metric, timed, create_performance_report, run_performance_benchmark
 
 def preprocess_and_mosaic(image: Image.Image, grid_size: int, n_colors: int):
-    """STEP 1: PREPROCESSING"""
+    """Enhanced mosaic generation with detailed performance metrics"""
+    start_total = time.time()
+    
+    # Step 1: Image preprocessing
+    start_preprocess = time.time()
     width, height = image.size
     if width != height:
         min_size = min(width, height)
@@ -18,8 +23,9 @@ def preprocess_and_mosaic(image: Image.Image, grid_size: int, n_colors: int):
         image = image.crop((left, top, left + min_size, top + min_size))
     resized_img = resize_img(image, 400)
     quantized_img, color_centers = color_quantize(resized_img, n_colors)
+    preprocess_time = time.time() - start_preprocess
 
-    """STEP 2: IMAGE GRID"""
+    # Step 2: Image grid processing
     resized_np = np.array(quantized_img)
     if resized_np.shape[-1] == 3:
         resized_np = cv2.cvtColor(resized_np, cv2.COLOR_RGB2BGR)
@@ -28,27 +34,60 @@ def preprocess_and_mosaic(image: Image.Image, grid_size: int, n_colors: int):
     actual_grid_size = 400 // cell_size
     actual_image_size = actual_grid_size * cell_size
     
+    # Crop the image to match the actual grid dimensions
     resized_np_cropped = resized_np[:actual_image_size, :actual_image_size]
+    
+    # Step 2: Grid segmentation (timed)
     grid_labels, seg_time = timed(segment_image_grid)(resized_np_cropped, actual_grid_size, color_centers)
     
-    """STEP 3: TILE MAPPING"""
+    # Step 3: Tile mapping
+    # Step 3a: Load tiles (timed)
+    start_tile_load = time.time()
     tiles, tile_colors = load_tile_images('data/tiles', n_colors, cell_size)
+    tile_load_time = time.time() - start_tile_load
+    
+    # Step 3b: Map tiles to grid (timed)
     mosaic_img, mosaic_time = timed(map_tiles_to_grid)(grid_labels, tiles, cell_size, color_centers, tile_colors)
     
-    """STEP 5: PERFORMANCE METRIC"""
+    total_time = time.time() - start_total
+    
+    # Step 4: Performance Metrics
+    start_metrics = time.time()
     mse_val = mse(resized_np_cropped, mosaic_img)
     ssim_val = ssim_metric(resized_np_cropped, mosaic_img)
+    metrics_time = time.time() - start_metrics
     
+    # Convert for display - all outputs as PIL Images
     orig_disp = Image.fromarray(cv2.cvtColor(resized_np_cropped, cv2.COLOR_BGR2RGB))
     mosaic_disp = Image.fromarray(cv2.cvtColor(mosaic_img, cv2.COLOR_BGR2RGB))
+    
+    # Segmented image: show each cell as its cluster color
     seg_img = np.zeros_like(resized_np_cropped)
     for i in range(actual_grid_size):
         for j in range(actual_grid_size):
             seg_img[i*cell_size:(i+1)*cell_size, j*cell_size:(j+1)*cell_size] = color_centers[grid_labels[i,j]]
     seg_disp = Image.fromarray(cv2.cvtColor(seg_img, cv2.COLOR_BGR2RGB))
     
-    info = f"MSE: {mse_val:.2f}\nSSIM: {ssim_val:.3f}\nSegmentation: {seg_time:.3f}s\nMosaic: {mosaic_time:.3f}s"
-    return orig_disp, seg_disp, mosaic_disp, info
+    # Enhanced performance info using perfMetric module
+    performance_info = create_performance_report(
+        actual_grid_size, cell_size, n_colors, actual_image_size,
+        preprocess_time, seg_time, tile_load_time, mosaic_time, metrics_time,
+        total_time, mse_val, ssim_val
+    )
+    
+    return orig_disp, seg_disp, mosaic_disp, performance_info
+
+def performance_benchmark(image: Image.Image, n_colors: int = 16):
+    """Run performance benchmark using perfMetric module"""
+    preprocess_funcs = {
+        'resize': resize_img,
+        'quantize': color_quantize
+    }
+    
+    return run_performance_benchmark(
+        preprocess_funcs, segment_image_grid, load_tile_images, map_tiles_to_grid,
+        image, n_colors
+    )
 
 example_urls = [
     "https://images.unsplash.com/photo-1686854016047-bcd783404deb?q=80&w=880&auto=format&fit=crop&ixlib=rb-4.1.0&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D", 
@@ -59,21 +98,61 @@ example_urls = [
 
 examples = [[url, 64, 16] for url in example_urls]
 
-with gr.Blocks() as demo:
-    gr.Markdown("# Flower Mosaic Generator by Adrien Mery")
-    with gr.Row():
-        image_input = gr.Image(type="pil", label="Upload Image or Select Example")
-        grid_slider = gr.Slider(8, 128, value=64, step=1, label="Mosaic Grid Resolution (NxN cells)")
-        color_slider = gr.Slider(2, 32, value=16, step=1, label="Color Palette Size (quantization)")
-    mosaic_btn = gr.Button("Generate Flower Mosaic")
-    with gr.Row():
-        orig_out = gr.Image(label="Resized & Color Quantized (400x400)")
-        seg_out = gr.Image(label="Grid Segmentation Preview")
-        mosaic_out = gr.Image(label="Mosaic Result")
-    info_out = gr.Textbox(label="Metrics & Timing", interactive=False)
+benchmark_examples = [[url, 16] for url in example_urls]
+
+with gr.Blocks(title="Mosaic Generator - Performance Analysis") as demo:
+    gr.Markdown("# 🌸 Mosaic Generator by Adrien Mery")
+    gr.Markdown("Transform your images into beautiful mosaics using colorful photo tiles. Includes comprehensive performance analysis!")
+    
+    with gr.Tabs():
+        with gr.Tab("🎨 Mosaic Generator"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    image_input = gr.Image(type="pil", label="Upload Image or Select Example", height=300)
+                with gr.Column(scale=1):
+                    grid_slider = gr.Slider(8, 128, value=64, step=1, label="Mosaic Grid Resolution (NxN cells)")
+                    color_slider = gr.Slider(2, 32, value=16, step=1, label="Color Palette Size (quantization)")
+                    mosaic_btn = gr.Button("🎨 Generate Mosaic", variant="primary")
+            
+            with gr.Row():
+                orig_out = gr.Image(label="Original (Resized & Quantized)")
+                seg_out = gr.Image(label="Grid Segmentation Preview")
+                mosaic_out = gr.Image(label="Final Mosaic Result")
+            
+            performance_out = gr.Textbox(label="📊 Detailed Performance Metrics", interactive=False, lines=15)
+            
+            gr.Examples(examples=examples, inputs=[image_input, grid_slider, color_slider], label="Example Images")
+        
+        with gr.Tab("📈 Performance Benchmark"):
+            gr.Markdown("""
+            ### Performance Analysis Tool
+            This tool runs your image through multiple grid sizes to analyze:
+            - **Processing time scaling** with grid complexity
+            - **Quality metrics** (MSE & SSIM) across different resolutions  
+            - **Performance bottlenecks** in the pipeline
+            - **Optimal settings** for speed vs quality trade-offs
+            """)
+            
+            with gr.Row():
+                benchmark_input = gr.Image(type="pil", label="Upload Image for Benchmarking", height=300)
+                benchmark_colors = gr.Slider(2, 32, value=16, step=1, label="Color Palette Size")
+                benchmark_btn = gr.Button("🔬 Run Performance Benchmark", variant="secondary")
+            
+            gr.Examples(examples=benchmark_examples, inputs=[benchmark_input, benchmark_colors], label="Example Images for Benchmarking")
+            
+            benchmark_plot = gr.Image(label="📊 Performance Analysis Charts")
+            benchmark_results = gr.Textbox(label="📋 Detailed Benchmark Results", interactive=False, lines=20)
     
-    gr.Examples(examples=examples, inputs=[image_input, grid_slider, color_slider], label="Example Images")
+    mosaic_btn.click(
+        preprocess_and_mosaic, 
+        inputs=[image_input, grid_slider, color_slider], 
+        outputs=[orig_out, seg_out, mosaic_out, performance_out]
+    )
     
-    mosaic_btn.click(preprocess_and_mosaic, inputs=[image_input, grid_slider, color_slider], outputs=[orig_out, seg_out, mosaic_out, info_out])
+    benchmark_btn.click(
+        performance_benchmark,
+        inputs=[benchmark_input, benchmark_colors],
+        outputs=[benchmark_plot, benchmark_results]
+    )
 
 demo.launch()

logic/perfMetric.py

@@ -6,6 +6,9 @@ import numpy as np
 import cv2
 from skimage.metrics import structural_similarity as ssim
 import time
+import matplotlib.pyplot as plt
+import pandas as pd
+from PIL import Image
 
 def mse(img1: np.ndarray, img2: np.ndarray) -> float:
     """Calculate Mean Squared Error between two images. Lower values = better similarity."""
@@ -28,3 +31,190 @@ def timed(func):
         elapsed = time.time() - start
         return result, elapsed
     return wrapper
+
+def create_performance_report(actual_grid_size: int, cell_size: int, n_colors: int, 
+                            actual_image_size: int, preprocess_time: float, seg_time: float,
+                            tile_load_time: float, mosaic_time: float, metrics_time: float,
+                            total_time: float, mse_val: float, ssim_val: float) -> str:
+    """Generate a comprehensive performance report."""
+    performance_info = f"""
+📊 PERFORMANCE METRICS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔧 CONFIGURATION
+   • Grid Size: {actual_grid_size}×{actual_grid_size} ({actual_grid_size**2:,} cells)
+   • Cell Size: {cell_size}×{cell_size} pixels
+   • Colors: {n_colors} quantized colors
+   • Image Size: {actual_image_size}×{actual_image_size} pixels
+
+⏱️  TIMING BREAKDOWN
+   • Preprocessing: {preprocess_time:.3f}s ({preprocess_time/total_time*100:.1f}%)
+   • Grid Segmentation: {seg_time:.3f}s ({seg_time/total_time*100:.1f}%)
+   • Tile Loading: {tile_load_time:.3f}s ({tile_load_time/total_time*100:.1f}%)
+   • Tile Mapping: {mosaic_time:.3f}s ({mosaic_time/total_time*100:.1f}%)
+   • Metrics Calculation: {metrics_time:.3f}s ({metrics_time/total_time*100:.1f}%)
+   • TOTAL TIME: {total_time:.3f}s
+
+📈 SIMILARITY METRICS
+   • MSE: {mse_val:.2f} (Lower = Better, 0 = Perfect)
+   • SSIM: {ssim_val:.3f} (Higher = Better, 1 = Perfect)
+   
+🎯 QUALITY ASSESSMENT
+   • MSE Quality: {'Excellent' if mse_val < 100 else 'Good' if mse_val < 500 else 'Fair' if mse_val < 1000 else 'Poor'}
+   • SSIM Quality: {'Excellent' if ssim_val > 0.9 else 'Good' if ssim_val > 0.8 else 'Fair' if ssim_val > 0.6 else 'Poor'}
+
+⚡ PERFORMANCE ANALYSIS
+   • Cells/second: {(actual_grid_size**2)/total_time:.0f}
+   • Efficiency: {'High' if total_time < 2 else 'Medium' if total_time < 5 else 'Low'}
+   • Memory Usage: ~{actual_image_size*actual_image_size*3/1024/1024:.1f}MB
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+"""
+    return performance_info
+
+def run_performance_benchmark(preprocess_func, segment_func, load_tiles_func, map_tiles_func,
+                            image: Image.Image, n_colors: int = 16):
+    """Run comprehensive performance benchmark across different grid sizes."""
+    if image is None:
+        return None, "Please upload an image first!"
+    
+    grid_sizes = [8, 16, 24, 32, 48, 64, 80, 96, 128]
+    results = []
+    
+    width, height = image.size
+    if width != height:
+        min_size = min(width, height)
+        left = (width - min_size) // 2
+        top = (height - min_size) // 2
+        image = image.crop((left, top, left + min_size, top + min_size))
+    
+    resized_img = preprocess_func['resize'](image, 400)
+    quantized_img, color_centers = preprocess_func['quantize'](resized_img, n_colors)
+    
+    resized_np = np.array(quantized_img)
+    if resized_np.shape[-1] == 3:
+        resized_np = cv2.cvtColor(resized_np, cv2.COLOR_RGB2BGR)
+    
+    for i, grid_size in enumerate(grid_sizes):
+        start_time = time.time()
+        
+        cell_size = 400 // grid_size
+        actual_grid_size = 400 // cell_size
+        actual_image_size = actual_grid_size * cell_size
+        resized_np_cropped = resized_np[:actual_image_size, :actual_image_size]
+        
+        # Time each step
+        grid_labels, seg_time = timed(segment_func)(resized_np_cropped, actual_grid_size, color_centers)
+        
+        start_tile = time.time()
+        tiles, tile_colors = load_tiles_func('data/tiles', n_colors, cell_size)
+        tile_time = time.time() - start_tile
+        
+        mosaic_img, mosaic_time = timed(map_tiles_func)(grid_labels, tiles, cell_size, color_centers, tile_colors)
+        
+        total_time = time.time() - start_time
+        
+        mse_val = mse(resized_np_cropped, mosaic_img)
+        ssim_val = ssim_metric(resized_np_cropped, mosaic_img)
+        
+        results.append({
+            'Grid Size': f"{actual_grid_size}x{actual_grid_size}",
+            'Cells': actual_grid_size**2,
+            'Cell Size': cell_size,
+            'Segmentation (s)': seg_time,
+            'Tile Loading (s)': tile_time,
+            'Tile Mapping (s)': mosaic_time,
+            'Total Time (s)': total_time,
+            'Cells/sec': actual_grid_size**2 / total_time,
+            'MSE': mse_val,
+            'SSIM': ssim_val
+        })
+    
+    return create_benchmark_plots(results)
+
+def create_benchmark_plots(results):
+    """Create performance benchmark visualization plots."""
+    fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 10))
+    
+    cells = [r['Cells'] for r in results]
+    total_times = [r['Total Time (s)'] for r in results]
+    seg_times = [r['Segmentation (s)'] for r in results]
+    mapping_times = [r['Tile Mapping (s)'] for r in results]
+    mse_vals = [r['MSE'] for r in results]
+    ssim_vals = [r['SSIM'] for r in results]
+    
+    # Plot 1: Total Time vs Grid Size
+    ax1.plot(cells, total_times, 'bo-', linewidth=2, markersize=6)
+    ax1.set_xlabel('Number of Cells')
+    ax1.set_ylabel('Total Time (seconds)')
+    ax1.set_title('Performance Scaling')
+    ax1.grid(True, alpha=0.3)
+    ax1.set_xscale('log')
+    
+    # Plot 2: Time Breakdown
+    width = 0.35
+    x = np.arange(len(results))
+    ax2.bar(x - width/2, seg_times, width, label='Segmentation', alpha=0.8)
+    ax2.bar(x + width/2, mapping_times, width, label='Tile Mapping', alpha=0.8)
+    ax2.set_xlabel('Grid Configuration')
+    ax2.set_ylabel('Time (seconds)')
+    ax2.set_title('Time Breakdown by Operation')
+    ax2.set_xticks(x)
+    ax2.set_xticklabels([r['Grid Size'] for r in results], rotation=45)
+    ax2.legend()
+    ax2.grid(True, alpha=0.3)
+    
+    # Plot 3: MSE vs Grid Size
+    ax3.plot(cells, mse_vals, 'ro-', linewidth=2, markersize=6)
+    ax3.set_xlabel('Number of Cells')
+    ax3.set_ylabel('MSE (Lower = Better)')
+    ax3.set_title('Image Quality (MSE)')
+    ax3.grid(True, alpha=0.3)
+    ax3.set_xscale('log')
+    
+    # Plot 4: SSIM vs Grid Size
+    ax4.plot(cells, ssim_vals, 'go-', linewidth=2, markersize=6)
+    ax4.set_xlabel('Number of Cells')
+    ax4.set_ylabel('SSIM (Higher = Better)')
+    ax4.set_title('Image Quality (SSIM)')
+    ax4.grid(True, alpha=0.3)
+    ax4.set_xscale('log')
+    
+    plt.tight_layout()
+    plt.savefig('performance_benchmark.png', dpi=150, bbox_inches='tight')
+    plt.close()
+    
+    # Create summary report
+    df = pd.DataFrame(results)
+    summary = create_benchmark_summary(results, mse_vals, ssim_vals, df)
+    
+    return 'performance_benchmark.png', summary
+
+def create_benchmark_summary(results, mse_vals, ssim_vals, df):
+    """Create a comprehensive benchmark summary report."""
+    summary = f"""
+🔬 PERFORMANCE BENCHMARK RESULTS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📊 PERFORMANCE SCALING ANALYSIS:
+   • Best Performance: {results[0]['Grid Size']} ({results[0]['Total Time (s)']:.3f}s)
+   • Highest Quality: {max(results, key=lambda x: x['SSIM'])['Grid Size']} (SSIM: {max(results, key=lambda x: x['SSIM'])['SSIM']:.3f})
+   • Best Balance: {sorted(results, key=lambda x: x['Total Time (s)'] * (1-x['SSIM']))[0]['Grid Size']}
+
+📈 COMPLEXITY ANALYSIS:
+   • 8x increase in cells: {results[-1]['Total Time (s)']/results[0]['Total Time (s)']:.1f}x slower
+   • Linear scaling: {'Yes' if results[-1]['Total Time (s)']/results[0]['Total Time (s)'] < 20 else 'No'}
+   • Processing efficiency: {np.mean([r['Cells/sec'] for r in results]):.0f} cells/sec average
+
+🎯 QUALITY TRENDS:
+   • MSE Range: {min(mse_vals):.1f} - {max(mse_vals):.1f}
+   • SSIM Range: {min(ssim_vals):.3f} - {max(ssim_vals):.3f}
+   • Quality improves with grid size: {'Yes' if ssim_vals[-1] > ssim_vals[0] else 'No'}
+
+💡 RECOMMENDATIONS:
+   • For speed: Use {results[0]['Grid Size']} or {results[1]['Grid Size']}
+   • For quality: Use {results[-2]['Grid Size']} or {results[-1]['Grid Size']}
+   • For balance: Use {results[len(results)//2]['Grid Size']}
+
+{df.to_string(index=False, float_format='%.3f')}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+"""
+    return summary

requirements.txt

@@ -1,7 +1,85 @@
-gradio
-opencv-python
-numpy
-Pillow
-scikit-image
-scikit-learn
-scipy
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+annotated-types==0.7.0
+anyio==4.10.0
+attrs==25.3.0
+audioop-lts==0.2.2
+Brotli==1.1.0
+certifi==2025.8.3
+charset-normalizer==3.4.3
+click==8.2.1
+contourpy==1.3.3
+cycler==0.12.1
+datasets==4.1.1
+dill==0.4.0
+fastapi==0.116.1
+ffmpy==0.6.1
+filelock==3.19.1
+fonttools==4.60.0
+frozenlist==1.7.0
+fsspec==2025.9.0
+gradio==5.45.0
+gradio_client==1.13.0
+groovy==0.1.2
+h11==0.16.0
+hf-xet==1.1.9
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.34.4
+idna==3.10
+imageio==2.37.0
+Jinja2==3.1.6
+joblib==1.5.2
+kiwisolver==1.4.9
+lazy_loader==0.4
+markdown-it-py==4.0.0
+MarkupSafe==3.0.2
+matplotlib==3.10.6
+mdurl==0.1.2
+multidict==6.6.4
+multiprocess==0.70.16
+networkx==3.5
+numpy==2.2.6
+opencv-python==4.12.0.88
+orjson==3.11.3
+packaging==25.0
+pandas==2.3.2
+pillow==11.3.0
+propcache==0.3.2
+pyarrow==21.0.0
+pydantic==2.11.7
+pydantic_core==2.33.2
+pydub==0.25.1
+Pygments==2.19.2
+pyparsing==3.2.5
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.2
+requests==2.32.5
+rich==14.1.0
+ruff==0.13.0
+safehttpx==0.1.6
+scikit-image==0.25.2
+scikit-learn==1.7.2
+scipy==1.16.1
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+starlette==0.47.3
+threadpoolctl==3.6.0
+tifffile==2025.9.9
+tomlkit==0.13.3
+tqdm==4.67.1
+typer==0.17.4
+typing-inspection==0.4.1
+typing_extensions==4.15.0
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.35.0
+websockets==15.0.1
+xxhash==3.5.0
+yarl==1.20.1