Upload 11 files

app.py

@@ -0,0 +1,409 @@
+"""
+Main application file for the Image Evaluator tool.
+This module integrates all components and provides a Gradio interface.
+"""
+
+import os
+import gradio as gr
+import numpy as np
+import pandas as pd
+import torch
+import glob
+from PIL import Image
+import json
+import tempfile
+import shutil
+from datetime import datetime
+
+# Import custom modules
+from modules.metadata_extractor import MetadataExtractor
+from modules.technical_metrics import TechnicalMetrics
+from modules.aesthetic_metrics import AestheticMetrics
+from modules.aggregator import ResultsAggregator
+from modules.visualizer import Visualizer
+
+
+class ImageEvaluator:
+    """Main class for the Image Evaluator application."""
+    
+    def __init__(self):
+        """Initialize the Image Evaluator."""
+        self.results_dir = os.path.join(os.getcwd(), "results")
+        os.makedirs(self.results_dir, exist_ok=True)
+        
+        # Initialize components
+        self.metadata_extractor = MetadataExtractor()
+        self.technical_metrics = TechnicalMetrics()
+        self.aesthetic_metrics = AestheticMetrics()
+        self.aggregator = ResultsAggregator()
+        self.visualizer = Visualizer(self.results_dir)
+        
+        # Storage for results
+        self.evaluation_results = {}
+        self.metadata_cache = {}
+        self.current_comparison = None
+        
+    def process_images(self, image_files, progress=None):
+        """
+        Process a list of image files and extract metadata.
+        
+        Args:
+            image_files: list of image file paths
+            progress: optional gradio Progress object
+            
+        Returns:
+            tuple: (metadata_by_model, metadata_by_prompt)
+        """
+        metadata_list = []
+        
+        total_files = len(image_files)
+        for i, img_path in enumerate(image_files):
+            if progress:
+                progress(i / total_files, f"Processing image {i+1}/{total_files}")
+            
+            # Extract metadata
+            metadata = self.metadata_extractor.extract_metadata(img_path)
+            metadata_list.append((img_path, metadata))
+            
+            # Cache metadata
+            self.metadata_cache[img_path] = metadata
+        
+        # Group by model and prompt
+        metadata_by_model = self.metadata_extractor.group_images_by_model(metadata_list)
+        metadata_by_prompt = self.metadata_extractor.group_images_by_prompt(metadata_list)
+        
+        return metadata_by_model, metadata_by_prompt
+    
+    def evaluate_images(self, image_files, progress=None):
+        """
+        Evaluate a list of image files using all metrics.
+        
+        Args:
+            image_files: list of image file paths
+            progress: optional gradio Progress object
+            
+        Returns:
+            dict: evaluation results by image path
+        """
+        results = {}
+        
+        total_files = len(image_files)
+        for i, img_path in enumerate(image_files):
+            if progress:
+                progress(i / total_files, f"Evaluating image {i+1}/{total_files}")
+            
+            # Get metadata if available
+            metadata = self.metadata_cache.get(img_path, {})
+            prompt = metadata.get('prompt', '')
+            
+            # Calculate technical metrics
+            tech_metrics = self.technical_metrics.calculate_all_metrics(img_path)
+            
+            # Calculate aesthetic metrics
+            aesthetic_metrics = self.aesthetic_metrics.calculate_all_metrics(img_path, prompt)
+            
+            # Combine results
+            combined_metrics = {**tech_metrics, **aesthetic_metrics}
+            
+            # Store results
+            results[img_path] = combined_metrics
+        
+        return results
+    
+    def compare_models(self, evaluation_results, metadata_by_model):
+        """
+        Compare different models based on evaluation results.
+        
+        Args:
+            evaluation_results: dictionary with image paths as keys and metrics as values
+            metadata_by_model: dictionary with model names as keys and lists of image paths as values
+            
+        Returns:
+            tuple: (comparison_df, visualizations)
+        """
+        # Group results by model
+        results_by_model = {}
+        for model, image_paths in metadata_by_model.items():
+            model_results = [evaluation_results[img] for img in image_paths if img in evaluation_results]
+            results_by_model[model] = model_results
+        
+        # Compare models
+        comparison = self.aggregator.compare_models(results_by_model)
+        
+        # Create comparison dataframe
+        comparison_df = self.aggregator.create_comparison_dataframe(comparison)
+        
+        # Store current comparison
+        self.current_comparison = comparison_df
+        
+        # Create visualizations
+        visualizations = {}
+        
+        # Create heatmap
+        heatmap_path = self.visualizer.plot_heatmap(comparison_df)
+        visualizations['Model Comparison Heatmap'] = heatmap_path
+        
+        # Create radar chart for key metrics
+        key_metrics = ['aesthetic_score', 'sharpness', 'noise', 'contrast', 'color_harmony', 'prompt_similarity']
+        available_metrics = [m for m in key_metrics if m in comparison_df.columns]
+        if available_metrics:
+            radar_path = self.visualizer.plot_radar_chart(comparison_df, available_metrics)
+            visualizations['Model Comparison Radar Chart'] = radar_path
+        
+        # Create bar charts for important metrics
+        for metric in ['overall_score', 'aesthetic_score', 'prompt_similarity']:
+            if metric in comparison_df.columns:
+                bar_path = self.visualizer.plot_metric_comparison(comparison_df, metric)
+                visualizations[f'{metric} Comparison'] = bar_path
+        
+        return comparison_df, visualizations
+    
+    def export_results(self, format='csv'):
+        """
+        Export current comparison results.
+        
+        Args:
+            format: export format ('csv', 'excel', or 'html')
+            
+        Returns:
+            str: path to exported file
+        """
+        if self.current_comparison is not None:
+            return self.visualizer.export_comparison_table(self.current_comparison, format)
+        return None
+    
+    def generate_report(self, comparison_df, visualizations):
+        """
+        Generate a comprehensive HTML report.
+        
+        Args:
+            comparison_df: pandas DataFrame with comparison data
+            visualizations: dictionary of visualization paths
+            
+        Returns:
+            str: path to HTML report
+        """
+        metrics_list = comparison_df.columns.tolist()
+        return self.visualizer.generate_html_report(comparison_df, visualizations, metrics_list)
+
+
+# Create Gradio interface
+def create_interface():
+    """Create and configure the Gradio interface."""
+    
+    # Initialize evaluator
+    evaluator = ImageEvaluator()
+    
+    # Track state
+    state = {
+        'uploaded_images': [],
+        'metadata_by_model': {},
+        'metadata_by_prompt': {},
+        'evaluation_results': {},
+        'comparison_df': None,
+        'visualizations': {},
+        'report_path': None
+    }
+    
+    def upload_images(files, progress=gr.Progress()):
+        """Handle image upload and processing."""
+        # Reset state
+        state['uploaded_images'] = []
+        state['metadata_by_model'] = {}
+        state['metadata_by_prompt'] = {}
+        state['evaluation_results'] = {}
+        state['comparison_df'] = None
+        state['visualizations'] = {}
+        state['report_path'] = None
+        
+        # Process uploaded files
+        image_paths = [f.name for f in files]
+        state['uploaded_images'] = image_paths
+        
+        # Extract metadata and group images
+        progress(0, "Extracting metadata...")
+        metadata_by_model, metadata_by_prompt = evaluator.process_images(image_paths, progress)
+        state['metadata_by_model'] = metadata_by_model
+        state['metadata_by_prompt'] = metadata_by_prompt
+        
+        # Create model summary
+        model_summary = []
+        for model, images in metadata_by_model.items():
+            model_summary.append(f"- {model}: {len(images)} images")
+        
+        # Create prompt summary
+        prompt_summary = []
+        for prompt, images in metadata_by_prompt.items():
+            prompt_summary.append(f"- {prompt}: {len(images)} images")
+        
+        return (
+            f"Processed {len(image_paths)} images.\n\n"
+            f"Found {len(metadata_by_model)} models:\n" + "\n".join(model_summary) + "\n\n"
+            f"Found {len(metadata_by_prompt)} unique prompts."
+        )
+    
+    def evaluate_images(progress=gr.Progress()):
+        """Evaluate all uploaded images."""
+        if not state['uploaded_images']:
+            return "No images uploaded. Please upload images first."
+        
+        # Evaluate images
+        progress(0, "Evaluating images...")
+        evaluation_results = evaluator.evaluate_images(state['uploaded_images'], progress)
+        state['evaluation_results'] = evaluation_results
+        
+        return f"Evaluated {len(evaluation_results)} images with all metrics."
+    
+    def compare_models():
+        """Compare models based on evaluation results."""
+        if not state['evaluation_results'] or not state['metadata_by_model']:
+            return "No evaluation results available. Please evaluate images first.", None, None
+        
+        # Compare models
+        comparison_df, visualizations = evaluator.compare_models(
+            state['evaluation_results'], state['metadata_by_model']
+        )
+        state['comparison_df'] = comparison_df
+        state['visualizations'] = visualizations
+        
+        # Generate report
+        report_path = evaluator.generate_report(comparison_df, visualizations)
+        state['report_path'] = report_path
+        
+        # Get visualization paths
+        heatmap_path = visualizations.get('Model Comparison Heatmap')
+        radar_path = visualizations.get('Model Comparison Radar Chart')
+        overall_score_path = visualizations.get('overall_score Comparison')
+        
+        # Convert DataFrame to markdown for display
+        df_markdown = comparison_df.to_markdown()
+        
+        return df_markdown, heatmap_path, radar_path
+    
+    def export_results(format):
+        """Export results in the specified format."""
+        if state['comparison_df'] is None:
+            return "No comparison results available. Please compare models first."
+        
+        export_path = evaluator.export_results(format)
+        if export_path:
+            return f"Results exported to {export_path}"
+        else:
+            return "Failed to export results."
+    
+    def view_report():
+        """View the generated HTML report."""
+        if state['report_path'] and os.path.exists(state['report_path']):
+            return state['report_path']
+        else:
+            return "No report available. Please compare models first."
+    
+    # Create interface
+    with gr.Blocks(title="Image Model Evaluator") as interface:
+        gr.Markdown("# Image Model Evaluator")
+        gr.Markdown("Upload images generated by different AI models to compare their quality and performance.")
+        
+        with gr.Tab("Upload & Process"):
+            with gr.Row():
+                with gr.Column():
+                    upload_input = gr.File(
+                        label="Upload Images (PNG format)",
+                        file_count="multiple",
+                        type="file"
+                    )
+                    upload_button = gr.Button("Process Uploaded Images")
+                
+                with gr.Column():
+                    upload_output = gr.Textbox(
+                        label="Processing Results",
+                        lines=10,
+                        interactive=False
+                    )
+            
+            evaluate_button = gr.Button("Evaluate Images")
+            evaluate_output = gr.Textbox(
+                label="Evaluation Status",
+                lines=2,
+                interactive=False
+            )
+        
+        with gr.Tab("Compare Models"):
+            compare_button = gr.Button("Compare Models")
+            
+            with gr.Row():
+                comparison_output = gr.Markdown(
+                    label="Comparison Results"
+                )
+            
+            with gr.Row():
+                with gr.Column():
+                    heatmap_output = gr.Image(
+                        label="Model Comparison Heatmap",
+                        interactive=False
+                    )
+                
+                with gr.Column():
+                    radar_output = gr.Image(
+                        label="Model Comparison Radar Chart",
+                        interactive=False
+                    )
+        
+        with gr.Tab("Export & Report"):
+            with gr.Row():
+                with gr.Column():
+                    export_format = gr.Radio(
+                        label="Export Format",
+                        choices=["csv", "excel", "html"],
+                        value="csv"
+                    )
+                    export_button = gr.Button("Export Results")
+                    export_output = gr.Textbox(
+                        label="Export Status",
+                        lines=2,
+                        interactive=False
+                    )
+                
+                with gr.Column():
+                    report_button = gr.Button("View Full Report")
+                    report_output = gr.HTML(
+                        label="Full Report"
+                    )
+        
+        # Set up event handlers
+        upload_button.click(
+            upload_images,
+            inputs=[upload_input],
+            outputs=[upload_output]
+        )
+        
+        evaluate_button.click(
+            evaluate_images,
+            inputs=[],
+            outputs=[evaluate_output]
+        )
+        
+        compare_button.click(
+            compare_models,
+            inputs=[],
+            outputs=[comparison_output, heatmap_output, radar_output]
+        )
+        
+        export_button.click(
+            export_results,
+            inputs=[export_format],
+            outputs=[export_output]
+        )
+        
+        report_button.click(
+            view_report,
+            inputs=[],
+            outputs=[report_output]
+        )
+    
+    return interface
+
+
+# Launch the application
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch(share=True)

modules/__init__.py

@@ -0,0 +1,3 @@
+"""
+Module initialization file for the Image Evaluator tool.
+"""

modules/aesthetic_metrics.py

@@ -0,0 +1,252 @@
+"""
+Aesthetic metrics for image quality assessment using AI models.
+These metrics evaluate subjective aspects of images like aesthetic appeal, composition, etc.
+"""
+
+import torch
+import numpy as np
+from PIL import Image
+from transformers import AutoFeatureExtractor, AutoModelForImageClassification
+import clip
+from torchvision import transforms
+
+
+class AestheticMetrics:
+    """Class for computing aesthetic image quality metrics using AI models."""
+    
+    def __init__(self):
+        """Initialize models for aesthetic evaluation."""
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self._initialize_models()
+        
+    def _initialize_models(self):
+        """Initialize all required models."""
+        # Initialize CLIP model for text-image similarity
+        try:
+            self.clip_model, self.clip_preprocess = clip.load("ViT-B/32", device=self.device)
+            self.clip_loaded = True
+        except Exception as e:
+            print(f"Warning: Could not load CLIP model: {e}")
+            self.clip_loaded = False
+            
+        # Initialize aesthetic predictor model (LAION Aesthetic Predictor v2)
+        try:
+            self.aesthetic_model_name = "cafeai/cafe_aesthetic"
+            self.aesthetic_extractor = AutoFeatureExtractor.from_pretrained(self.aesthetic_model_name)
+            self.aesthetic_model = AutoModelForImageClassification.from_pretrained(self.aesthetic_model_name)
+            self.aesthetic_model.to(self.device)
+            self.aesthetic_loaded = True
+        except Exception as e:
+            print(f"Warning: Could not load aesthetic model: {e}")
+            self.aesthetic_loaded = False
+            
+        # Initialize transforms for preprocessing
+        self.transform = transforms.Compose([
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ])
+    
+    def calculate_aesthetic_score(self, image_path):
+        """
+        Calculate aesthetic score using a pre-trained model.
+        
+        Args:
+            image_path: path to the image file
+            
+        Returns:
+            float: aesthetic score between 0 and 10
+        """
+        if not self.aesthetic_loaded:
+            return 5.0  # Default middle score if model not loaded
+            
+        try:
+            image = Image.open(image_path).convert('RGB')
+            inputs = self.aesthetic_extractor(images=image, return_tensors="pt").to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.aesthetic_model(**inputs)
+                
+            # Get predicted class probabilities
+            probs = torch.nn.functional.softmax(outputs.logits, dim=1)
+            
+            # Calculate weighted score (0-10 scale)
+            score_weights = torch.tensor([i for i in range(10)]).to(self.device).float()
+            aesthetic_score = torch.sum(probs * score_weights).item()
+            
+            return aesthetic_score
+        except Exception as e:
+            print(f"Error calculating aesthetic score: {e}")
+            return 5.0
+    
+    def calculate_composition_score(self, image_path):
+        """
+        Estimate composition quality using rule of thirds and symmetry analysis.
+        
+        Args:
+            image_path: path to the image file
+            
+        Returns:
+            float: composition score between 0 and 10
+        """
+        try:
+            # Load image
+            image = Image.open(image_path).convert('RGB')
+            img_array = np.array(image)
+            
+            # Calculate rule of thirds score
+            h, w = img_array.shape[:2]
+            third_h, third_w = h // 3, w // 3
+            
+            # Define rule of thirds points
+            thirds_points = [
+                (third_w, third_h), (2*third_w, third_h),
+                (third_w, 2*third_h), (2*third_w, 2*third_h)
+            ]
+            
+            # Calculate edge detection to find important elements
+            gray = np.mean(img_array, axis=2).astype(np.uint8)
+            edges = np.abs(np.diff(gray, axis=0, append=0)) + np.abs(np.diff(gray, axis=1, append=0))
+            
+            # Calculate score based on edge concentration near thirds points
+            thirds_score = 0
+            for px, py in thirds_points:
+                # Get region around thirds point
+                region = edges[max(0, py-50):min(h, py+50), max(0, px-50):min(w, px+50)]
+                thirds_score += np.mean(region)
+            
+            # Normalize score
+            thirds_score = min(10, thirds_score / 100)
+            
+            # Calculate symmetry score
+            flipped = np.fliplr(img_array)
+            symmetry_diff = np.mean(np.abs(img_array.astype(float) - flipped.astype(float)))
+            symmetry_score = 10 * (1 - symmetry_diff / 255)
+            
+            # Combine scores (weighted average)
+            composition_score = 0.7 * thirds_score + 0.3 * symmetry_score
+            
+            return min(10, max(0, composition_score))
+        except Exception as e:
+            print(f"Error calculating composition score: {e}")
+            return 5.0
+    
+    def calculate_color_harmony(self, image_path):
+        """
+        Calculate color harmony score based on color theory.
+        
+        Args:
+            image_path: path to the image file
+            
+        Returns:
+            float: color harmony score between 0 and 10
+        """
+        try:
+            # Load image
+            image = Image.open(image_path).convert('RGB')
+            img_array = np.array(image)
+            
+            # Convert to HSV for better color analysis
+            hsv = np.array(image.convert('HSV'))
+            
+            # Extract hue channel and create histogram
+            hue = hsv[:,:,0].flatten()
+            hist, _ = np.histogram(hue, bins=36, range=(0, 255))
+            hist = hist / np.sum(hist)
+            
+            # Calculate entropy of hue distribution
+            entropy = -np.sum(hist * np.log2(hist + 1e-10))
+            
+            # Calculate complementary color usage
+            complementary_score = 0
+            for i in range(18):
+                complementary_i = (i + 18) % 36
+                complementary_score += min(hist[i], hist[complementary_i])
+            
+            # Calculate analogous color usage
+            analogous_score = 0
+            for i in range(36):
+                analogous_i1 = (i + 1) % 36
+                analogous_i2 = (i + 35) % 36
+                analogous_score += min(hist[i], max(hist[analogous_i1], hist[analogous_i2]))
+            
+            # Calculate saturation variance as a measure of color interest
+            saturation = hsv[:,:,1].flatten()
+            saturation_variance = np.var(saturation)
+            
+            # Combine metrics into final score
+            harmony_score = (
+                3 * (1 - min(1, entropy/5)) +  # Lower entropy is better for harmony
+                3 * complementary_score +       # Complementary colors
+                2 * analogous_score +           # Analogous colors
+                2 * min(1, saturation_variance/2000)  # Saturation variance
+            )
+            
+            return min(10, max(0, harmony_score))
+        except Exception as e:
+            print(f"Error calculating color harmony: {e}")
+            return 5.0
+    
+    def calculate_prompt_similarity(self, image_path, prompt):
+        """
+        Calculate similarity between image and text prompt using CLIP.
+        
+        Args:
+            image_path: path to the image file
+            prompt: text prompt used to generate the image
+            
+        Returns:
+            float: similarity score between 0 and 10
+        """
+        if not self.clip_loaded or not prompt:
+            return 5.0  # Default middle score if model not loaded or no prompt
+            
+        try:
+            # Load and preprocess image
+            image = Image.open(image_path).convert('RGB')
+            image_input = self.clip_preprocess(image).unsqueeze(0).to(self.device)
+            
+            # Process text
+            text_input = clip.tokenize([prompt]).to(self.device)
+            
+            # Calculate similarity
+            with torch.no_grad():
+                image_features = self.clip_model.encode_image(image_input)
+                text_features = self.clip_model.encode_text(text_input)
+                
+                # Normalize features
+                image_features = image_features / image_features.norm(dim=-1, keepdim=True)
+                text_features = text_features / text_features.norm(dim=-1, keepdim=True)
+                
+                # Calculate similarity
+                similarity = (100.0 * image_features @ text_features.T).item()
+                
+            # Convert to 0-10 scale
+            return min(10, max(0, similarity / 10))
+        except Exception as e:
+            print(f"Error calculating prompt similarity: {e}")
+            return 5.0
+    
+    def calculate_all_metrics(self, image_path, prompt=None):
+        """
+        Calculate all aesthetic metrics for an image.
+        
+        Args:
+            image_path: path to the image file
+            prompt: optional text prompt used to generate the image
+            
+        Returns:
+            dict: dictionary with all metric scores
+        """
+        metrics = {
+            'aesthetic_score': self.calculate_aesthetic_score(image_path),
+            'composition_score': self.calculate_composition_score(image_path),
+            'color_harmony': self.calculate_color_harmony(image_path),
+        }
+        
+        # Add prompt similarity if prompt is provided
+        if prompt:
+            metrics['prompt_similarity'] = self.calculate_prompt_similarity(image_path, prompt)
+        
+        return metrics

modules/aggregator.py

@@ -0,0 +1,215 @@
+"""
+Module for aggregating results from different evaluation metrics.
+"""
+
+import pandas as pd
+import numpy as np
+from collections import defaultdict
+
+
+class ResultsAggregator:
+    """Class for aggregating and analyzing image evaluation results."""
+    
+    def __init__(self):
+        """Initialize the aggregator."""
+        # Weights for different metric categories
+        self.default_weights = {
+            # Technical metrics
+            'sharpness': 1.0,
+            'noise': 1.0,
+            'contrast': 1.0,
+            'saturation': 1.0,
+            'entropy': 1.0,
+            'compression_artifacts': 1.0,
+            'dynamic_range': 1.0,
+            
+            # Aesthetic metrics
+            'aesthetic_score': 1.5,
+            'composition_score': 1.2,
+            'color_harmony': 1.2,
+            
+            # Prompt metrics
+            'prompt_similarity': 2.0,
+        }
+        
+        # Metrics where lower is better
+        self.inverse_metrics = ['noise', 'compression_artifacts']
+    
+    def normalize_metric(self, values, metric_name):
+        """
+        Normalize metric values to 0-10 scale.
+        
+        Args:
+            values: list of metric values
+            metric_name: name of the metric
+            
+        Returns:
+            list: normalized values
+        """
+        if not values:
+            return []
+            
+        # For metrics where lower is better, invert the values
+        if metric_name in self.inverse_metrics:
+            values = [max(values) - v + min(values) for v in values]
+        
+        # Normalize to 0-10 scale
+        min_val = min(values)
+        max_val = max(values)
+        
+        if max_val == min_val:
+            return [5.0] * len(values)  # Default to middle value if all values are the same
+            
+        return [10 * (v - min_val) / (max_val - min_val) for v in values]
+    
+    def aggregate_model_results(self, model_results, custom_weights=None):
+        """
+        Aggregate results for a single model across multiple images.
+        
+        Args:
+            model_results: list of metric dictionaries for images from the same model
+            custom_weights: optional dictionary of custom weights for metrics
+            
+        Returns:
+            dict: aggregated metrics
+        """
+        if not model_results:
+            return {}
+            
+        # Use default weights if custom weights not provided
+        weights = custom_weights if custom_weights else self.default_weights
+        
+        # Initialize aggregated results
+        aggregated = {}
+        
+        # Collect all metrics
+        all_metrics = set()
+        for result in model_results:
+            all_metrics.update(result.keys())
+        
+        # Aggregate each metric
+        for metric in all_metrics:
+            # Skip non-numeric metrics
+            values = [result.get(metric) for result in model_results if metric in result 
+                     and isinstance(result[metric], (int, float))]
+            
+            if values:
+                aggregated[metric] = {
+                    'mean': np.mean(values),
+                    'median': np.median(values),
+                    'std': np.std(values),
+                    'min': np.min(values),
+                    'max': np.max(values),
+                    'count': len(values)
+                }
+        
+        # Calculate overall score
+        score_components = []
+        weight_sum = 0
+        
+        for metric, stats in aggregated.items():
+            if metric in weights:
+                # Normalize the mean value to 0-10 scale
+                normalized_value = stats['mean']
+                if metric in self.inverse_metrics:
+                    # For metrics where lower is better, invert the scale
+                    normalized_value = 10 - normalized_value
+                
+                # Apply weight
+                weight = weights[metric]
+                score_components.append(normalized_value * weight)
+                weight_sum += weight
+        
+        # Calculate weighted average
+        if weight_sum > 0:
+            aggregated['overall_score'] = sum(score_components) / weight_sum
+        else:
+            aggregated['overall_score'] = 5.0  # Default middle score
+        
+        return aggregated
+    
+    def compare_models(self, model_results_dict, custom_weights=None):
+        """
+        Compare results across different models.
+        
+        Args:
+            model_results_dict: dictionary with model names as keys and lists of results as values
+            custom_weights: optional dictionary of custom weights for metrics
+            
+        Returns:
+            dict: comparison results
+        """
+        # Aggregate results for each model
+        aggregated_results = {}
+        for model_name, results in model_results_dict.items():
+            aggregated_results[model_name] = self.aggregate_model_results(results, custom_weights)
+        
+        # Extract key metrics for comparison
+        comparison = {}
+        for model_name, agg_results in aggregated_results.items():
+            model_comparison = {
+                'overall_score': agg_results.get('overall_score', 5.0)
+            }
+            
+            # Add mean values of all metrics
+            for metric, stats in agg_results.items():
+                if metric != 'overall_score' and isinstance(stats, dict) and 'mean' in stats:
+                    model_comparison[f"{metric}"] = stats['mean']
+            
+            comparison[model_name] = model_comparison
+        
+        return comparison
+    
+    def analyze_by_prompt(self, results_by_prompt, custom_weights=None):
+        """
+        Analyze results grouped by prompt.
+        
+        Args:
+            results_by_prompt: dictionary with prompts as keys and dictionaries of model results as values
+            custom_weights: optional dictionary of custom weights for metrics
+            
+        Returns:
+            dict: analysis results by prompt
+        """
+        prompt_analysis = {}
+        
+        for prompt, model_results in results_by_prompt.items():
+            # Compare models for this prompt
+            prompt_comparison = self.compare_models(model_results, custom_weights)
+            
+            # Find best model for this prompt
+            best_model = None
+            best_score = -1
+            
+            for model, metrics in prompt_comparison.items():
+                score = metrics.get('overall_score', 0)
+                if score > best_score:
+                    best_score = score
+                    best_model = model
+            
+            prompt_analysis[prompt] = {
+                'model_comparison': prompt_comparison,
+                'best_model': best_model,
+                'best_score': best_score
+            }
+        
+        return prompt_analysis
+    
+    def create_comparison_dataframe(self, comparison_results):
+        """
+        Create a pandas DataFrame from comparison results.
+        
+        Args:
+            comparison_results: dictionary with model names as keys and metric dictionaries as values
+            
+        Returns:
+            pandas.DataFrame: comparison table
+        """
+        # Convert to DataFrame
+        df = pd.DataFrame.from_dict(comparison_results, orient='index')
+        
+        # Sort by overall score
+        if 'overall_score' in df.columns:
+            df = df.sort_values('overall_score', ascending=False)
+        
+        return df

modules/metadata_extractor.py

@@ -0,0 +1,168 @@
+"""
+Module for extracting metadata from image files, particularly focusing on
+Stable Diffusion metadata from PNG files.
+"""
+
+import io
+from PIL import Image, PngImagePlugin
+import re
+
+
+class MetadataExtractor:
+    """Class for extracting and parsing metadata from images."""
+    
+    @staticmethod
+    def extract_metadata(image_path):
+        """
+        Extract metadata from an image file.
+        
+        Args:
+            image_path: path to the image file
+            
+        Returns:
+            dict: dictionary with extracted metadata
+        """
+        try:
+            # Open image with PIL
+            image = Image.open(image_path)
+            
+            # Extract metadata from PNG info
+            metadata_text = image.info.get("parameters", "")
+            
+            # Parse the metadata
+            parsed_metadata = MetadataExtractor.parse_metadata(metadata_text)
+            
+            # Add basic image info
+            parsed_metadata.update({
+                'width': image.width,
+                'height': image.height,
+                'format': image.format,
+                'mode': image.mode,
+            })
+            
+            return parsed_metadata
+        except Exception as e:
+            print(f"Error extracting metadata from {image_path}: {e}")
+            return {'error': str(e)}
+    
+    @staticmethod
+    def parse_metadata(metadata_text):
+        """
+        Parse Stable Diffusion metadata text into structured data.
+        
+        Args:
+            metadata_text: raw metadata text from image
+            
+        Returns:
+            dict: structured metadata
+        """
+        if not metadata_text:
+            return {'raw_text': ''}
+        
+        result = {'raw_text': metadata_text}
+        
+        # Extract prompt
+        prompt_end = metadata_text.find("Negative prompt:")
+        if prompt_end > 0:
+            result['prompt'] = metadata_text[:prompt_end].strip()
+            negative_prompt_end = metadata_text.find("\n", prompt_end)
+            if negative_prompt_end > 0:
+                result['negative_prompt'] = metadata_text[prompt_end + len("Negative prompt:"):negative_prompt_end].strip()
+        else:
+            result['prompt'] = metadata_text.strip()
+        
+        # Extract model name
+        model_match = re.search(r'Model: ([^,\n]+)', metadata_text)
+        if model_match:
+            result['model'] = model_match.group(1).strip()
+        
+        # Extract other parameters
+        params = {
+            'steps': r'Steps: (\d+)',
+            'sampler': r'Sampler: ([^,\n]+)',
+            'cfg_scale': r'CFG scale: ([^,\n]+)',
+            'seed': r'Seed: ([^,\n]+)',
+            'size': r'Size: ([^,\n]+)',
+            'model_hash': r'Model hash: ([^,\n]+)',
+        }
+        
+        for key, pattern in params.items():
+            match = re.search(pattern, metadata_text)
+            if match:
+                result[key] = match.group(1).strip()
+        
+        return result
+    
+    @staticmethod
+    def group_images_by_model(metadata_list):
+        """
+        Group images by model name.
+        
+        Args:
+            metadata_list: list of (image_path, metadata) tuples
+            
+        Returns:
+            dict: dictionary with model names as keys and lists of image paths as values
+        """
+        result = {}
+        
+        for image_path, metadata in metadata_list:
+            model = metadata.get('model', 'unknown')
+            if model not in result:
+                result[model] = []
+            result[model].append(image_path)
+        
+        return result
+    
+    @staticmethod
+    def group_images_by_prompt(metadata_list):
+        """
+        Group images by prompt.
+        
+        Args:
+            metadata_list: list of (image_path, metadata) tuples
+            
+        Returns:
+            dict: dictionary with prompts as keys and lists of image paths as values
+        """
+        result = {}
+        
+        for image_path, metadata in metadata_list:
+            prompt = metadata.get('prompt', 'unknown')
+            # Use first 50 chars as key to avoid extremely long keys
+            prompt_key = prompt[:50] + ('...' if len(prompt) > 50 else '')
+            if prompt_key not in result:
+                result[prompt_key] = []
+            result[prompt_key].append((image_path, metadata.get('model', 'unknown')))
+        
+        return result
+    
+    @staticmethod
+    def update_metadata(image_path, new_metadata, output_path=None):
+        """
+        Update metadata in an image file.
+        
+        Args:
+            image_path: path to the input image file
+            new_metadata: new metadata text to write
+            output_path: path to save the updated image (if None, overwrites input)
+            
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        try:
+            # Open image with PIL
+            image = Image.open(image_path)
+            
+            # Create a PngInfo object to store metadata
+            pnginfo = PngImagePlugin.PngInfo()
+            pnginfo.add_text("parameters", new_metadata)
+            
+            # Save the image with the updated metadata
+            save_path = output_path if output_path else image_path
+            image.save(save_path, format="PNG", pnginfo=pnginfo)
+            
+            return True
+        except Exception as e:
+            print(f"Error updating metadata: {e}")
+            return False

modules/technical_metrics.py

@@ -0,0 +1,189 @@
+"""
+Technical metrics for image quality assessment without using AI models.
+These metrics evaluate basic technical aspects of images like sharpness, noise, etc.
+"""
+
+import numpy as np
+import cv2
+from skimage.metrics import structural_similarity as ssim
+from skimage.measure import shannon_entropy
+from PIL import Image, ImageStat
+
+
+class TechnicalMetrics:
+    """Class for computing technical image quality metrics."""
+    
+    @staticmethod
+    def calculate_sharpness(image_array):
+        """
+        Calculate image sharpness using Laplacian variance.
+        Higher values indicate sharper images.
+        
+        Args:
+            image_array: numpy array of the image
+            
+        Returns:
+            float: sharpness score
+        """
+        if len(image_array.shape) == 3:
+            gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = image_array
+            
+        # Calculate variance of Laplacian
+        return cv2.Laplacian(gray, cv2.CV_64F).var()
+    
+    @staticmethod
+    def calculate_noise(image_array):
+        """
+        Estimate image noise level.
+        Lower values indicate less noisy images.
+        
+        Args:
+            image_array: numpy array of the image
+            
+        Returns:
+            float: noise level
+        """
+        if len(image_array.shape) == 3:
+            gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = image_array
+            
+        # Estimate noise using median filter difference
+        denoised = cv2.medianBlur(gray, 5)
+        diff = cv2.absdiff(gray, denoised)
+        return np.mean(diff)
+    
+    @staticmethod
+    def calculate_contrast(image_array):
+        """
+        Calculate image contrast.
+        Higher values indicate higher contrast.
+        
+        Args:
+            image_array: numpy array of the image
+            
+        Returns:
+            float: contrast score
+        """
+        if len(image_array.shape) == 3:
+            gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = image_array
+            
+        # Calculate standard deviation as a measure of contrast
+        return np.std(gray)
+    
+    @staticmethod
+    def calculate_saturation(image_array):
+        """
+        Calculate color saturation.
+        Higher values indicate more saturated colors.
+        
+        Args:
+            image_array: numpy array of the image
+            
+        Returns:
+            float: saturation score
+        """
+        if len(image_array.shape) != 3:
+            return 0.0  # Grayscale images have no saturation
+            
+        # Convert to HSV and calculate mean saturation
+        hsv = cv2.cvtColor(image_array, cv2.COLOR_RGB2HSV)
+        return np.mean(hsv[:, :, 1])
+    
+    @staticmethod
+    def calculate_entropy(image_array):
+        """
+        Calculate image entropy as a measure of detail/complexity.
+        Higher values indicate more complex images.
+        
+        Args:
+            image_array: numpy array of the image
+            
+        Returns:
+            float: entropy score
+        """
+        if len(image_array.shape) == 3:
+            gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = image_array
+            
+        return shannon_entropy(gray)
+    
+    @staticmethod
+    def detect_compression_artifacts(image_array):
+        """
+        Detect JPEG compression artifacts.
+        Higher values indicate more artifacts.
+        
+        Args:
+            image_array: numpy array of the image
+            
+        Returns:
+            float: artifact score
+        """
+        if len(image_array.shape) == 3:
+            gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = image_array
+            
+        # Apply edge detection to find blocky artifacts
+        edges = cv2.Canny(gray, 100, 200)
+        return np.mean(edges) / 255.0
+    
+    @staticmethod
+    def calculate_dynamic_range(image_array):
+        """
+        Calculate dynamic range of the image.
+        Higher values indicate better use of available intensity range.
+        
+        Args:
+            image_array: numpy array of the image
+            
+        Returns:
+            float: dynamic range score
+        """
+        if len(image_array.shape) == 3:
+            gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = image_array
+            
+        p1 = np.percentile(gray, 1)
+        p99 = np.percentile(gray, 99)
+        return (p99 - p1) / 255.0
+    
+    @staticmethod
+    def calculate_all_metrics(image_path):
+        """
+        Calculate all technical metrics for an image.
+        
+        Args:
+            image_path: path to the image file
+            
+        Returns:
+            dict: dictionary with all metric scores
+        """
+        # Load image with PIL for metadata
+        pil_image = Image.open(image_path)
+        
+        # Convert to numpy array for OpenCV processing
+        image_array = np.array(pil_image)
+        
+        # Calculate all metrics
+        metrics = {
+            'sharpness': TechnicalMetrics.calculate_sharpness(image_array),
+            'noise': TechnicalMetrics.calculate_noise(image_array),
+            'contrast': TechnicalMetrics.calculate_contrast(image_array),
+            'saturation': TechnicalMetrics.calculate_saturation(image_array),
+            'entropy': TechnicalMetrics.calculate_entropy(image_array),
+            'compression_artifacts': TechnicalMetrics.detect_compression_artifacts(image_array),
+            'dynamic_range': TechnicalMetrics.calculate_dynamic_range(image_array),
+            'resolution': f"{pil_image.width}x{pil_image.height}",
+            'aspect_ratio': pil_image.width / pil_image.height if pil_image.height > 0 else 0,
+            'file_size_kb': pil_image.fp.tell() / 1024 if hasattr(pil_image.fp, 'tell') else 0,
+        }
+        
+        return metrics

modules/visualizer.py

@@ -0,0 +1,480 @@
+"""
+Module for visualizing image evaluation results and creating comparison tables.
+"""
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from matplotlib.colors import LinearSegmentedColormap
+import os
+import io
+from PIL import Image
+import base64
+
+
+class Visualizer:
+    """Class for visualizing image evaluation results."""
+    
+    def __init__(self, output_dir='./results'):
+        """
+        Initialize visualizer with output directory.
+        
+        Args:
+            output_dir: directory to save visualization results
+        """
+        self.output_dir = output_dir
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Set up color schemes
+        self.setup_colors()
+    
+    def setup_colors(self):
+        """Set up color schemes for visualizations."""
+        # Custom colormap for heatmaps
+        self.cmap = LinearSegmentedColormap.from_list(
+            'custom_cmap', ['#FF5E5B', '#FFED66', '#00CEFF', '#0089BA', '#008F7A'], N=256
+        )
+        
+        # Color palette for bar charts
+        self.palette = sns.color_palette("viridis", 10)
+        
+        # Set Seaborn style
+        sns.set_style("whitegrid")
+    
+    def create_comparison_table(self, results_dict, metrics_list=None):
+        """
+        Create a comparison table from evaluation results.
+        
+        Args:
+            results_dict: dictionary with model names as keys and evaluation results as values
+            metrics_list: list of metrics to include in the table (if None, include all)
+            
+        Returns:
+            pandas.DataFrame: comparison table
+        """
+        # Initialize empty dataframe
+        df = pd.DataFrame()
+        
+        # Process each model's results
+        for model_name, model_results in results_dict.items():
+            # Create a row for this model
+            model_row = {'Model': model_name}
+            
+            # Add metrics to the row
+            for metric_name, metric_value in model_results.items():
+                if metrics_list is None or metric_name in metrics_list:
+                    # Format numeric values to 2 decimal places
+                    if isinstance(metric_value, (int, float)):
+                        model_row[metric_name] = round(metric_value, 2)
+                    else:
+                        model_row[metric_name] = metric_value
+            
+            # Append to dataframe
+            df = pd.concat([df, pd.DataFrame([model_row])], ignore_index=True)
+        
+        # Set Model as index
+        if not df.empty:
+            df.set_index('Model', inplace=True)
+        
+        return df
+    
+    def plot_metric_comparison(self, df, metric_name, title=None, figsize=(10, 6)):
+        """
+        Create a bar chart comparing models on a specific metric.
+        
+        Args:
+            df: pandas DataFrame with comparison data
+            metric_name: name of the metric to plot
+            title: optional custom title
+            figsize: figure size as (width, height)
+            
+        Returns:
+            str: path to saved figure
+        """
+        if metric_name not in df.columns:
+            raise ValueError(f"Metric '{metric_name}' not found in dataframe")
+        
+        # Create figure
+        plt.figure(figsize=figsize)
+        
+        # Create bar chart
+        ax = sns.barplot(x=df.index, y=df[metric_name], palette=self.palette)
+        
+        # Set title and labels
+        if title:
+            plt.title(title, fontsize=14)
+        else:
+            plt.title(f"Model Comparison: {metric_name}", fontsize=14)
+        
+        plt.xlabel("Model", fontsize=12)
+        plt.ylabel(metric_name, fontsize=12)
+        
+        # Rotate x-axis labels for better readability
+        plt.xticks(rotation=45, ha='right')
+        
+        # Add value labels on top of bars
+        for i, v in enumerate(df[metric_name]):
+            ax.text(i, v + 0.1, str(round(v, 2)), ha='center')
+        
+        plt.tight_layout()
+        
+        # Save figure
+        output_path = os.path.join(self.output_dir, f"{metric_name}_comparison.png")
+        plt.savefig(output_path, dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        return output_path
+    
+    def plot_radar_chart(self, df, metrics_list, title=None, figsize=(10, 8)):
+        """
+        Create a radar chart comparing models across multiple metrics.
+        
+        Args:
+            df: pandas DataFrame with comparison data
+            metrics_list: list of metrics to include in the radar chart
+            title: optional custom title
+            figsize: figure size as (width, height)
+            
+        Returns:
+            str: path to saved figure
+        """
+        # Filter metrics that exist in the dataframe
+        metrics = [m for m in metrics_list if m in df.columns]
+        
+        if not metrics:
+            raise ValueError("None of the specified metrics found in dataframe")
+        
+        # Number of metrics
+        N = len(metrics)
+        
+        # Create figure
+        fig = plt.figure(figsize=figsize)
+        ax = fig.add_subplot(111, polar=True)
+        
+        # Compute angle for each metric
+        angles = [n / float(N) * 2 * np.pi for n in range(N)]
+        angles += angles[:1]  # Close the loop
+        
+        # Plot each model
+        for i, model in enumerate(df.index):
+            values = df.loc[model, metrics].values.flatten().tolist()
+            values += values[:1]  # Close the loop
+            
+            # Plot values
+            ax.plot(angles, values, linewidth=2, linestyle='solid', label=model, color=self.palette[i % len(self.palette)])
+            ax.fill(angles, values, alpha=0.1, color=self.palette[i % len(self.palette)])
+        
+        # Set labels
+        plt.xticks(angles[:-1], metrics, size=12)
+        
+        # Set y-axis limits
+        ax.set_ylim(0, 10)
+        
+        # Add legend
+        plt.legend(loc='upper right', bbox_to_anchor=(0.1, 0.1))
+        
+        # Set title
+        if title:
+            plt.title(title, size=16, y=1.1)
+        else:
+            plt.title("Model Comparison Across Metrics", size=16, y=1.1)
+        
+        # Save figure
+        output_path = os.path.join(self.output_dir, "radar_comparison.png")
+        plt.savefig(output_path, dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        return output_path
+    
+    def plot_heatmap(self, df, title=None, figsize=(12, 8)):
+        """
+        Create a heatmap of all metrics across models.
+        
+        Args:
+            df: pandas DataFrame with comparison data
+            title: optional custom title
+            figsize: figure size as (width, height)
+            
+        Returns:
+            str: path to saved figure
+        """
+        # Create figure
+        plt.figure(figsize=figsize)
+        
+        # Create heatmap
+        ax = sns.heatmap(df, annot=True, cmap=self.cmap, fmt=".2f", linewidths=.5)
+        
+        # Set title
+        if title:
+            plt.title(title, fontsize=16)
+        else:
+            plt.title("Model Comparison Heatmap", fontsize=16)
+        
+        plt.tight_layout()
+        
+        # Save figure
+        output_path = os.path.join(self.output_dir, "comparison_heatmap.png")
+        plt.savefig(output_path, dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        return output_path
+    
+    def plot_prompt_performance(self, prompt_results, metric_name, top_n=5, figsize=(12, 8)):
+        """
+        Create a grouped bar chart showing model performance on different prompts.
+        
+        Args:
+            prompt_results: dictionary with prompts as keys and model results as values
+            metric_name: name of the metric to plot
+            top_n: number of top prompts to include
+            figsize: figure size as (width, height)
+            
+        Returns:
+            str: path to saved figure
+        """
+        # Create dataframe from results
+        data = []
+        for prompt, models_data in prompt_results.items():
+            for model, metrics in models_data.items():
+                if metric_name in metrics:
+                    data.append({
+                        'Prompt': prompt,
+                        'Model': model,
+                        metric_name: metrics[metric_name]
+                    })
+        
+        df = pd.DataFrame(data)
+        
+        if df.empty:
+            raise ValueError(f"No data found for metric '{metric_name}'")
+        
+        # Get top N prompts by average metric value
+        top_prompts = df.groupby('Prompt')[metric_name].mean().nlargest(top_n).index.tolist()
+        df_filtered = df[df['Prompt'].isin(top_prompts)]
+        
+        # Create figure
+        plt.figure(figsize=figsize)
+        
+        # Create grouped bar chart
+        ax = sns.barplot(x='Prompt', y=metric_name, hue='Model', data=df_filtered, palette=self.palette)
+        
+        # Set title and labels
+        plt.title(f"Model Performance by Prompt: {metric_name}", fontsize=14)
+        plt.xlabel("Prompt", fontsize=12)
+        plt.ylabel(metric_name, fontsize=12)
+        
+        # Rotate x-axis labels for better readability
+        plt.xticks(rotation=45, ha='right')
+        
+        # Adjust legend
+        plt.legend(title="Model", bbox_to_anchor=(1.05, 1), loc='upper left')
+        
+        plt.tight_layout()
+        
+        # Save figure
+        output_path = os.path.join(self.output_dir, f"prompt_performance_{metric_name}.png")
+        plt.savefig(output_path, dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        return output_path
+    
+    def create_image_grid(self, image_paths, titles=None, cols=3, figsize=(15, 15)):
+        """
+        Create a grid of images for visual comparison.
+        
+        Args:
+            image_paths: list of paths to images
+            titles: optional list of titles for each image
+            cols: number of columns in the grid
+            figsize: figure size as (width, height)
+            
+        Returns:
+            str: path to saved figure
+        """
+        # Calculate number of rows needed
+        rows = (len(image_paths) + cols - 1) // cols
+        
+        # Create figure
+        fig, axes = plt.subplots(rows, cols, figsize=figsize)
+        axes = axes.flatten()
+        
+        # Add each image to the grid
+        for i, img_path in enumerate(image_paths):
+            if i < len(axes):
+                try:
+                    img = Image.open(img_path)
+                    axes[i].imshow(np.array(img))
+                    
+                    # Add title if provided
+                    if titles and i < len(titles):
+                        axes[i].set_title(titles[i])
+                    
+                    # Remove axis ticks
+                    axes[i].set_xticks([])
+                    axes[i].set_yticks([])
+                except Exception as e:
+                    print(f"Error loading image {img_path}: {e}")
+                    axes[i].text(0.5, 0.5, f"Error loading image", ha='center', va='center')
+                    axes[i].set_xticks([])
+                    axes[i].set_yticks([])
+        
+        # Hide unused subplots
+        for j in range(len(image_paths), len(axes)):
+            axes[j].axis('off')
+        
+        plt.tight_layout()
+        
+        # Save figure
+        output_path = os.path.join(self.output_dir, "image_comparison_grid.png")
+        plt.savefig(output_path, dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        return output_path
+    
+    def export_comparison_table(self, df, format='csv'):
+        """
+        Export comparison table to file.
+        
+        Args:
+            df: pandas DataFrame with comparison data
+            format: export format ('csv', 'excel', or 'html')
+            
+        Returns:
+            str: path to saved file
+        """
+        if format == 'csv':
+            output_path = os.path.join(self.output_dir, "comparison_table.csv")
+            df.to_csv(output_path)
+        elif format == 'excel':
+            output_path = os.path.join(self.output_dir, "comparison_table.xlsx")
+            df.to_excel(output_path)
+        elif format == 'html':
+            output_path = os.path.join(self.output_dir, "comparison_table.html")
+            df.to_html(output_path)
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+        
+        return output_path
+    
+    def generate_html_report(self, comparison_table, image_paths, metrics_list):
+        """
+        Generate a comprehensive HTML report with all visualizations.
+        
+        Args:
+            comparison_table: pandas DataFrame with comparison data
+            image_paths: dictionary of generated visualization image paths
+            metrics_list: list of metrics included in the analysis
+            
+        Returns:
+            str: path to saved HTML report
+        """
+        # Create HTML content
+        html_content = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>Image Model Evaluation Report</title>
+            <style>
+                body {{
+                    font-family: Arial, sans-serif;
+                    line-height: 1.6;
+                    margin: 0;
+                    padding: 20px;
+                    color: #333;
+                }}
+                h1, h2, h3 {{
+                    color: #2c3e50;
+                }}
+                .container {{
+                    max-width: 1200px;
+                    margin: 0 auto;
+                }}
+                table {{
+                    border-collapse: collapse;
+                    width: 100%;
+                    margin-bottom: 20px;
+                }}
+                th, td {{
+                    border: 1px solid #ddd;
+                    padding: 8px;
+                    text-align: left;
+                }}
+                th {{
+                    background-color: #f2f2f2;
+                }}
+                tr:nth-child(even) {{
+                    background-color: #f9f9f9;
+                }}
+                .visualization {{
+                    margin: 20px 0;
+                    text-align: center;
+                }}
+                .visualization img {{
+                    max-width: 100%;
+                    height: auto;
+                    box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+                }}
+                .metrics-list {{
+                    background-color: #f8f9fa;
+                    padding: 15px;
+                    border-radius: 5px;
+                    margin-bottom: 20px;
+                }}
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <h1>Image Model Evaluation Report</h1>
+                
+                <h2>Metrics Overview</h2>
+                <div class="metrics-list">
+                    <h3>Metrics included in this analysis:</h3>
+                    <ul>
+        """
+        
+        # Add metrics list
+        for metric in metrics_list:
+            html_content += f"            <li><strong>{metric}</strong></li>\n"
+        
+        html_content += """
+                    </ul>
+                </div>
+                
+                <h2>Comparison Table</h2>
+        """
+        
+        # Add comparison table
+        html_content += comparison_table.to_html(classes="table table-striped")
+        
+        # Add visualizations
+        html_content += """
+                <h2>Visualizations</h2>
+        """
+        
+        for title, img_path in image_paths.items():
+            if os.path.exists(img_path):
+                # Convert image to base64 for embedding
+                with open(img_path, "rb") as img_file:
+                    img_data = base64.b64encode(img_file.read()).decode('utf-8')
+                
+                html_content += f"""
+                <div class="visualization">
+                    <h3>{title}</h3>
+                    <img src="data:image/png;base64,{img_data}" alt="{title}">
+                </div>
+                """
+        
+        # Close HTML
+        html_content += """
+            </div>
+        </body>
+        </html>
+        """
+        
+        # Save HTML report
+        output_path = os.path.join(self.output_dir, "evaluation_report.html")
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(html_content)
+        
+        return output_path

requirements.txt

@@ -0,0 +1,14 @@
+gradio>=4.0.0
+pillow>=9.0.0
+numpy>=1.20.0
+pandas>=1.3.0
+matplotlib>=3.5.0
+seaborn>=0.11.0
+scikit-image>=0.19.0
+opencv-python>=4.5.0
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.30.0
+clip>=0.2.0
+timm>=0.6.0
+openpyxl>=3.0.0

utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+Utility modules for the Image Evaluator tool.
+"""

utils/data_handling.py

@@ -0,0 +1,155 @@
+"""
+Utility functions for data handling and export.
+"""
+
+import os
+import json
+import csv
+import pandas as pd
+from datetime import datetime
+
+
+def save_json(data, file_path):
+    """
+    Save data to a JSON file.
+    
+    Args:
+        data: data to save
+        file_path: path to the output file
+        
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        return True
+    except Exception as e:
+        print(f"Error saving JSON: {e}")
+        return False
+
+
+def load_json(file_path):
+    """
+    Load data from a JSON file.
+    
+    Args:
+        file_path: path to the JSON file
+        
+    Returns:
+        dict: loaded data, or None if an error occurred
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"Error loading JSON: {e}")
+        return None
+
+
+def save_csv(data, file_path, headers=None):
+    """
+    Save data to a CSV file.
+    
+    Args:
+        data: list of dictionaries or list of lists
+        file_path: path to the output file
+        headers: optional list of column headers
+        
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        if isinstance(data, list) and len(data) > 0:
+            if isinstance(data[0], dict):
+                # List of dictionaries
+                if headers is None:
+                    headers = list(data[0].keys())
+                
+                with open(file_path, 'w', newline='', encoding='utf-8') as f:
+                    writer = csv.DictWriter(f, fieldnames=headers)
+                    writer.writeheader()
+                    writer.writerows(data)
+            else:
+                # List of lists
+                with open(file_path, 'w', newline='', encoding='utf-8') as f:
+                    writer = csv.writer(f)
+                    if headers:
+                        writer.writerow(headers)
+                    writer.writerows(data)
+        return True
+    except Exception as e:
+        print(f"Error saving CSV: {e}")
+        return False
+
+
+def dataframe_to_formats(df, base_path, formats=None):
+    """
+    Export a pandas DataFrame to multiple formats.
+    
+    Args:
+        df: pandas DataFrame
+        base_path: base path for output files (without extension)
+        formats: list of formats to export to ('csv', 'excel', 'html', 'json')
+        
+    Returns:
+        dict: dictionary with format names as keys and file paths as values
+    """
+    if formats is None:
+        formats = ['csv', 'excel', 'html']
+    
+    result = {}
+    
+    try:
+        for fmt in formats:
+            if fmt == 'csv':
+                file_path = f"{base_path}.csv"
+                df.to_csv(file_path)
+                result['csv'] = file_path
+            elif fmt == 'excel':
+                file_path = f"{base_path}.xlsx"
+                df.to_excel(file_path)
+                result['excel'] = file_path
+            elif fmt == 'html':
+                file_path = f"{base_path}.html"
+                df.to_html(file_path)
+                result['html'] = file_path
+            elif fmt == 'json':
+                file_path = f"{base_path}.json"
+                df.to_json(file_path, orient='records', indent=2)
+                result['json'] = file_path
+    except Exception as e:
+        print(f"Error exporting DataFrame: {e}")
+    
+    return result
+
+
+def generate_timestamp():
+    """
+    Generate a timestamp string for file naming.
+    
+    Returns:
+        str: timestamp string
+    """
+    return datetime.now().strftime("%Y%m%d_%H%M%S")
+
+
+def create_results_filename(prefix="evaluation", extension=""):
+    """
+    Create a filename for results with timestamp.
+    
+    Args:
+        prefix: prefix for the filename
+        extension: file extension (with or without dot)
+        
+    Returns:
+        str: filename with timestamp
+    """
+    timestamp = generate_timestamp()
+    
+    if extension:
+        if not extension.startswith('.'):
+            extension = f".{extension}"
+        return f"{prefix}_{timestamp}{extension}"
+    else:
+        return f"{prefix}_{timestamp}"

utils/image_processing.py

@@ -0,0 +1,103 @@
+"""
+Utility functions for image processing and data handling.
+"""
+
+import os
+import shutil
+import tempfile
+from PIL import Image
+import numpy as np
+
+
+def create_thumbnail(image_path, max_size=(200, 200)):
+    """
+    Create a thumbnail of an image.
+    
+    Args:
+        image_path: path to the image file
+        max_size: maximum size of the thumbnail as (width, height)
+        
+    Returns:
+        PIL.Image: thumbnail image
+    """
+    try:
+        image = Image.open(image_path)
+        image.thumbnail(max_size)
+        return image
+    except Exception as e:
+        print(f"Error creating thumbnail for {image_path}: {e}")
+        return None
+
+
+def create_temp_directory():
+    """
+    Create a temporary directory for storing intermediate files.
+    
+    Returns:
+        str: path to the temporary directory
+    """
+    temp_dir = tempfile.mkdtemp(prefix="image_evaluator_")
+    return temp_dir
+
+
+def cleanup_temp_directory(temp_dir):
+    """
+    Clean up a temporary directory.
+    
+    Args:
+        temp_dir: path to the temporary directory
+    """
+    if os.path.exists(temp_dir):
+        shutil.rmtree(temp_dir)
+
+
+def ensure_directory(directory):
+    """
+    Ensure that a directory exists, creating it if necessary.
+    
+    Args:
+        directory: path to the directory
+        
+    Returns:
+        str: path to the directory
+    """
+    os.makedirs(directory, exist_ok=True)
+    return directory
+
+
+def is_valid_image(file_path):
+    """
+    Check if a file is a valid image.
+    
+    Args:
+        file_path: path to the file
+        
+    Returns:
+        bool: True if the file is a valid image, False otherwise
+    """
+    try:
+        with Image.open(file_path) as img:
+            img.verify()
+        return True
+    except:
+        return False
+
+
+def convert_to_rgb(image_path):
+    """
+    Convert an image to RGB mode if necessary.
+    
+    Args:
+        image_path: path to the image file
+        
+    Returns:
+        numpy.ndarray: RGB image array
+    """
+    try:
+        image = Image.open(image_path)
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        return np.array(image)
+    except Exception as e:
+        print(f"Error converting image to RGB: {e}")
+        return None