Upload 11 files

README.md

@@ -1,13 +1,34 @@
----
-title: Heatmap
-emoji: 🚀
-colorFrom: indigo
-colorTo: green
-sdk: streamlit
-sdk_version: 1.43.1
-app_file: app.py
-pinned: false
-short_description: Part of Verification System
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Deepfake Detection System with Heatmap Visualization
+
+This project implements a deepfake detection system that processes images through multiple stages:
+
+1. **Verification Module**: Uses Nvidia AI model for image comparison
+   - Calculates SMI (Structural Matching Index)
+   - Generates difference images
+   - Applies threshold visualization
+   - Adds bounding boxes around detected areas
+
+2. **Labeling System**: Labels detected areas based on threat level
+
+3. **Heatmap Visualization**: Creates heatmaps highlighting high-threat areas
+
+## Project Structure
+
+- `deepfake_detector.py`: Core detection functionality using Nvidia AI model
+- `image_processor.py`: Image processing utilities
+- `labeling.py`: Threat labeling system
+- `heatmap_generator.py`: Heatmap visualization tools
+- `main.py`: Main application entry point
+- `requirements.txt`: Project dependencies
+
+## Setup and Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+```bash
+python main.py --input_dir /path/to/images --output_dir /path/to/output
+```

combined_visualization.py

@@ -0,0 +1,221 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from image_processor import ImageProcessor
+from heatmap_generator import HeatmapGenerator
+
+class CombinedVisualizer:
+    def __init__(self):
+        """
+        Initialize the combined visualizer for creating overlaid threat visualizations
+        """
+        self.image_processor = ImageProcessor()
+        self.heatmap_generator = HeatmapGenerator()
+    
+    def create_combined_visualization(self, image_pair_results, output_path, alpha_diff=0.4, alpha_low=0.3, alpha_medium=0.4, dpi=300):
+        """
+        Create a combined visualization that overlays difference image, low and medium threat heatmaps,
+        and bounding boxes on top of each other.
+        
+        Args:
+            image_pair_results: Dictionary containing all processing results
+            output_path: Path to save the visualization
+            alpha_diff: Transparency for difference image overlay
+            alpha_low: Transparency for low threat heatmap overlay
+            alpha_medium: Transparency for medium threat heatmap overlay
+            dpi: Resolution for saved image
+            
+        Returns:
+            Path to the generated visualization
+        """
+        # Extract required components from results
+        original_image = image_pair_results['original_image']
+        difference_image = image_pair_results['difference_image']
+        bounding_boxes = image_pair_results['bounding_boxes']
+        multi_heatmaps = image_pair_results.get('multi_heatmaps', {})
+        labeled_regions = [r for r in image_pair_results.get('labeled_regions', []) 
+                          if 'bbox' in r and 'threat_level' in r]
+        
+        # If labeled_regions not provided, extract from bounding boxes
+        if not labeled_regions and 'threat_summary' in image_pair_results:
+            # Create simplified labeled regions from bounding boxes
+            for bbox in bounding_boxes:
+                # Default to medium threat if specific threat level not available
+                labeled_regions.append({
+                    'bbox': bbox,
+                    'threat_level': 'medium',
+                    'difference_percentage': 50  # Default value
+                })
+        
+        # Start with a copy of the original image
+        combined_image = original_image.copy()
+        
+        # 1. Overlay the difference image with transparency
+        # Convert difference image to RGB if it's grayscale
+        if len(difference_image.shape) == 2 or difference_image.shape[2] == 1:
+            diff_colored = cv2.applyColorMap(difference_image, cv2.COLORMAP_HOT)
+            diff_colored = cv2.cvtColor(diff_colored, cv2.COLOR_BGR2RGB)
+        else:
+            diff_colored = difference_image
+        
+        # Overlay difference image
+        combined_image = self.image_processor.overlay_images(combined_image, diff_colored, alpha_diff)
+        
+        # 2. Overlay low threat heatmap if available
+        if 'low' in multi_heatmaps:
+            low_heatmap = multi_heatmaps['low']
+            combined_image = self.image_processor.overlay_images(combined_image, low_heatmap, alpha_low)
+        
+        # 3. Overlay medium threat heatmap if available
+        if 'medium' in multi_heatmaps:
+            medium_heatmap = multi_heatmaps['medium']
+            combined_image = self.image_processor.overlay_images(combined_image, medium_heatmap, alpha_medium)
+        
+        # 4. Draw bounding boxes with threat level colors
+        threat_colors = {
+            'low': (0, 255, 0),      # Green
+            'medium': (0, 165, 255), # Orange
+            'high': (0, 0, 255)      # Red
+        }
+        
+        # Draw bounding boxes based on threat levels
+        for region in labeled_regions:
+            bbox = region['bbox']
+            threat_level = region['threat_level']
+            x, y, w, h = bbox
+            
+            # Get color for this threat level (default to red if not found)
+            color = threat_colors.get(threat_level, (0, 0, 255))
+            
+            # Convert BGR to RGB for matplotlib
+            color_rgb = (color[2]/255, color[1]/255, color[0]/255)
+            
+            # Draw rectangle with threat level color
+            cv2.rectangle(combined_image, (x, y), (x + w, y + h), color, 2)
+            
+            # Add label text with threat level
+            if 'difference_percentage' in region:
+                label_text = f"{threat_level.upper()}: {region['difference_percentage']:.1f}%"
+            else:
+                label_text = f"{threat_level.upper()}"
+                
+            cv2.putText(combined_image, label_text, (x, y - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+        
+        # Save the combined visualization
+        plt.figure(figsize=(12, 8))
+        plt.imshow(combined_image)
+        plt.title('Combined Threat Visualization')
+        plt.axis('off')
+        plt.tight_layout()
+        plt.savefig(output_path, dpi=dpi, bbox_inches='tight')
+        plt.close()
+        
+        # Also save the raw image for potential further processing
+        raw_output_path = output_path.replace('.png', '_raw.png')
+        self.image_processor.save_image(combined_image, raw_output_path)
+        
+        return output_path
+    
+    def create_combined_visualization_from_files(self, original_path, difference_path, 
+                                               low_heatmap_path, medium_heatmap_path,
+                                               bounding_boxes, output_path, 
+                                               alpha_diff=0.4, alpha_low=0.3, alpha_medium=0.4):
+        """
+        Create a combined visualization from individual image files
+        
+        Args:
+            original_path: Path to original image
+            difference_path: Path to difference image
+            low_heatmap_path: Path to low threat heatmap
+            medium_heatmap_path: Path to medium threat heatmap
+            bounding_boxes: List of bounding boxes (x, y, w, h)
+            output_path: Path to save the visualization
+            alpha_diff: Transparency for difference image overlay
+            alpha_low: Transparency for low threat heatmap overlay
+            alpha_medium: Transparency for medium threat heatmap overlay
+            
+        Returns:
+            Path to the generated visualization
+        """
+        # Load images
+        original_image = self.image_processor.load_image(original_path)
+        difference_image = self.image_processor.load_image(difference_path)
+        
+        # Load heatmaps if paths are provided
+        low_heatmap = None
+        medium_heatmap = None
+        
+        if low_heatmap_path:
+            low_heatmap = self.image_processor.load_image(low_heatmap_path)
+            
+        if medium_heatmap_path:
+            medium_heatmap = self.image_processor.load_image(medium_heatmap_path)
+        
+        # Create a mock image_pair_results dictionary
+        image_pair_results = {
+            'original_image': original_image,
+            'difference_image': difference_image,
+            'bounding_boxes': bounding_boxes,
+            'multi_heatmaps': {}
+        }
+        
+        if low_heatmap is not None:
+            image_pair_results['multi_heatmaps']['low'] = low_heatmap
+            
+        if medium_heatmap is not None:
+            image_pair_results['multi_heatmaps']['medium'] = medium_heatmap
+        
+        # Call the main visualization method
+        return self.create_combined_visualization(
+            image_pair_results, output_path, alpha_diff, alpha_low, alpha_medium
+        )
+
+# Example usage
+if __name__ == "__main__":
+    import os
+    from deepfake_detector import DeepfakeDetector
+    from labeling import ThreatLabeler
+    
+    # Initialize components
+    detector = DeepfakeDetector()
+    labeler = ThreatLabeler()
+    heatmap_gen = HeatmapGenerator()
+    img_processor = ImageProcessor()
+    visualizer = CombinedVisualizer()
+    
+    # Example paths
+    image1_path = "path/to/original.jpg"
+    image2_path = "path/to/modified.jpg"
+    output_dir = "path/to/output"
+    
+    # Ensure output directory exists
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    # Process images
+    results = detector.process_image_pair(image1_path, image2_path)
+    
+    # Label regions
+    original_image = img_processor.load_image(image1_path)
+    labeled_image, labeled_regions = labeler.label_regions(
+        original_image, results['difference_image'], results['bounding_boxes']
+    )
+    
+    # Generate multi-level heatmaps
+    multi_heatmaps = heatmap_gen.generate_multi_level_heatmap(original_image, labeled_regions)
+    
+    # Prepare results for combined visualization
+    image_pair_results = {
+        'original_image': original_image,
+        'difference_image': results['difference_image'],
+        'bounding_boxes': results['bounding_boxes'],
+        'multi_heatmaps': multi_heatmaps,
+        'labeled_regions': labeled_regions
+    }
+    
+    # Create combined visualization
+    output_path = os.path.join(output_dir, "combined_visualization.png")
+    visualizer.create_combined_visualization(image_pair_results, output_path)
+    
+    print(f"Combined visualization saved to: {output_path}")

compare_images.py

@@ -0,0 +1,96 @@
+import os
+import sys
+from deepfake_detector import DeepfakeDetector
+from image_processor import ImageProcessor
+from labeling import ThreatLabeler
+from heatmap_generator import HeatmapGenerator
+from comparison_interface import ComparisonInterface
+
+def ensure_dir(directory):
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+def compare_images(image1_path, image2_path, output_dir, threshold=30, min_area=100):
+    # Initialize components
+    detector = DeepfakeDetector()
+    labeler = ThreatLabeler()
+    heatmap_gen = HeatmapGenerator()
+    img_processor = ImageProcessor()
+    comparison = ComparisonInterface()
+    
+    # Create output directory
+    ensure_dir(output_dir)
+    
+    # Get base filename for outputs
+    base_name = os.path.splitext(os.path.basename(image1_path))[0]
+    
+    print(f"Processing images: {image1_path} and {image2_path}")
+    
+    # Step 1: Verification Module - Process the image pair
+    results = detector.process_image_pair(image1_path, image2_path, threshold, min_area)
+    
+    # Step 2: Labeling System - Label detected regions by threat level
+    original_image = img_processor.load_image(image1_path)
+    modified_image = img_processor.load_image(image2_path)
+    labeled_image, labeled_regions = labeler.label_regions(
+        original_image, results['difference_image'], results['bounding_boxes'])
+    
+    # Get threat summary
+    threat_summary = labeler.get_threat_summary(labeled_regions)
+    
+    # Step 3: Heatmap Visualization - Generate heatmaps for threat visualization
+    # Generate standard heatmap
+    heatmap = heatmap_gen.generate_threat_heatmap(original_image, labeled_regions)
+    
+    # Generate multi-level heatmaps
+    multi_heatmaps = heatmap_gen.generate_multi_level_heatmap(original_image, labeled_regions)
+    
+    # Prepare results for comparison interface
+    image_pair_results = {
+        'original_image': original_image,
+        'modified_image': modified_image,
+        'difference_image': results['difference_image'],
+        'threshold_image': results['threshold_image'],
+        'annotated_image': results['annotated_image'],
+        'labeled_image': labeled_image,
+        'heatmap_overlay': heatmap,
+        'multi_heatmaps': multi_heatmaps,
+        'threat_summary': threat_summary,
+        'smi_score': results['smi_score'],
+        'bounding_boxes': results['bounding_boxes']
+    }
+    
+    # Create comprehensive visualization
+    output_path = os.path.join(output_dir, f"{base_name}_comparison.png")
+    comparison.create_comparison_grid(image_pair_results, output_path)
+    
+    # Print summary information
+    print(f"\nAnalysis Results:")
+    print(f"SMI Score: {results['smi_score']:.4f} (1.0 = identical, 0.0 = completely different)")
+    print(f"Total regions detected: {threat_summary['total_regions']}")
+    print(f"Threat counts: Low={threat_summary['threat_counts']['low']}, "
+          f"Medium={threat_summary['threat_counts']['medium']}, "
+          f"High={threat_summary['threat_counts']['high']}")
+    if threat_summary['max_threat']:
+        print(f"Maximum threat: {threat_summary['max_threat']['level'].upper()} "
+              f"({threat_summary['max_threat']['percentage']:.1f}%)")
+    print(f"Average difference: {threat_summary['average_difference']:.1f}%")
+    
+    print(f"\nComparison visualization saved to: {output_path}")
+    return output_path
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: python compare_images.py <image1_path> <image2_path> [output_dir]")
+        sys.exit(1)
+    
+    image1_path = sys.argv[1]
+    image2_path = sys.argv[2]
+    
+    # Use default output directory if not specified
+    output_dir = sys.argv[3] if len(sys.argv) > 3 else "./comparison_output"
+    
+    compare_images(image1_path, image2_path, output_dir)
+
+if __name__ == "__main__":
+    main()

comparison_interface.py

@@ -0,0 +1,410 @@
+import os
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.gridspec import GridSpec
+from deepfake_detector import DeepfakeDetector
+from image_processor import ImageProcessor
+from labeling import ThreatLabeler
+from heatmap_generator import HeatmapGenerator
+
+class ComparisonInterface:
+    def __init__(self):
+        """
+        Initialize the comparison interface for visualizing all processing stages
+        """
+        self.img_processor = ImageProcessor()
+        
+    def create_comparison_grid(self, image_pair_results, output_path, figsize=(18, 12), dpi=300):
+        """
+        Create a comprehensive grid visualization of all processing stages
+        
+        Args:
+            image_pair_results: Dictionary containing all processing results
+            output_path: Path to save the visualization
+            figsize: Figure size (width, height) in inches
+            dpi: Resolution for saved image
+        """
+        # Extract images from results
+        original_image = image_pair_results['original_image']
+        modified_image = image_pair_results['modified_image']
+        difference_image = image_pair_results['difference_image']
+        threshold_image = image_pair_results['threshold_image']
+        annotated_image = image_pair_results['annotated_image']
+        labeled_image = image_pair_results['labeled_image']
+        heatmap_overlay = image_pair_results['heatmap_overlay']
+        
+        # Extract multi-level heatmaps if available
+        multi_heatmaps = image_pair_results.get('multi_heatmaps', {})
+        
+        # Create figure with grid layout
+        fig = plt.figure(figsize=figsize)
+        gs = GridSpec(3, 4, figure=fig)
+        
+        # Row 1: Original images and difference
+        ax1 = fig.add_subplot(gs[0, 0])
+        ax1.imshow(original_image)
+        ax1.set_title('Original Image')
+        ax1.axis('off')
+        
+        ax2 = fig.add_subplot(gs[0, 1])
+        ax2.imshow(modified_image)
+        ax2.set_title('Modified Image')
+        ax2.axis('off')
+        
+        ax3 = fig.add_subplot(gs[0, 2])
+        ax3.imshow(difference_image, cmap='gray')
+        ax3.set_title('Difference Image')
+        ax3.axis('off')
+        
+        ax4 = fig.add_subplot(gs[0, 3])
+        ax4.imshow(threshold_image, cmap='gray')
+        ax4.set_title('Thresholded Difference')
+        ax4.axis('off')
+        
+        # Row 2: Annotated, labeled, and heatmap
+        ax5 = fig.add_subplot(gs[1, 0:2])
+        ax5.imshow(annotated_image)
+        ax5.set_title('Detected Regions')
+        ax5.axis('off')
+        
+        ax6 = fig.add_subplot(gs[1, 2:4])
+        ax6.imshow(labeled_image)
+        ax6.set_title('Threat Labeled Regions')
+        ax6.axis('off')
+        
+        # Row 3: Multi-level heatmaps
+        if 'low' in multi_heatmaps and 'medium' in multi_heatmaps and 'high' in multi_heatmaps:
+            ax7 = fig.add_subplot(gs[2, 0])
+            ax7.imshow(multi_heatmaps['low'])
+            ax7.set_title('Low Threat Heatmap')
+            ax7.axis('off')
+            
+            ax8 = fig.add_subplot(gs[2, 1])
+            ax8.imshow(multi_heatmaps['medium'])
+            ax8.set_title('Medium Threat Heatmap')
+            ax8.axis('off')
+            
+            ax9 = fig.add_subplot(gs[2, 2])
+            ax9.imshow(multi_heatmaps['high'])
+            ax9.set_title('High Threat Heatmap')
+            ax9.axis('off')
+        else:
+            # If multi-level heatmaps not available, show combined heatmap in larger space
+            ax7 = fig.add_subplot(gs[2, 0:3])
+            ax7.imshow(heatmap_overlay)
+            ax7.set_title('Combined Threat Heatmap')
+            ax7.axis('off')
+        
+        # Add threat summary in text box
+        ax10 = fig.add_subplot(gs[2, 3])
+        ax10.axis('off')
+        summary_text = self._format_summary_text(image_pair_results['threat_summary'], image_pair_results['smi_score'])
+        ax10.text(0, 0.5, summary_text, fontsize=10, va='center', ha='left', wrap=True)
+        ax10.set_title('Threat Summary')
+        
+        # Add overall title
+        plt.suptitle(f"Deepfake Detection Analysis", fontsize=16)
+        
+        # Adjust layout and save
+        plt.tight_layout(rect=[0, 0, 1, 0.97])
+        plt.savefig(output_path, dpi=dpi, bbox_inches='tight')
+        plt.close()
+        
+        return output_path
+    
+    def _format_summary_text(self, threat_summary, smi_score):
+        """
+        Format threat summary as text for display
+        """
+        text = f"SMI Score: {smi_score:.4f}\n"
+        text += f"(1.0 = identical, 0.0 = different)\n\n"
+        text += f"Total regions: {threat_summary['total_regions']}\n\n"
+        text += f"Threat counts:\n"
+        text += f"  Low: {threat_summary['threat_counts']['low']}\n"
+        text += f"  Medium: {threat_summary['threat_counts']['medium']}\n"
+        text += f"  High: {threat_summary['threat_counts']['high']}\n\n"
+        
+        if threat_summary['max_threat']:
+            text += f"Maximum threat: {threat_summary['max_threat']['level'].upper()}\n"
+            text += f"  ({threat_summary['max_threat']['percentage']:.1f}%)\n\n"
+            
+        text += f"Average difference: {threat_summary['average_difference']:.1f}%"
+        
+        return text
+    
+    def create_interactive_comparison(self, image_pair_results, output_path):
+        """
+        Create an HTML file with interactive comparison of all processing stages
+        
+        Args:
+            image_pair_results: Dictionary containing all processing results
+            output_path: Path to save the HTML file
+            
+        Returns:
+            Path to the generated HTML file
+        """
+        # Create output directory for individual images
+        output_dir = os.path.dirname(output_path)
+        images_dir = os.path.join(output_dir, 'images')
+        if not os.path.exists(images_dir):
+            os.makedirs(images_dir)
+        
+        # Get base filename for outputs
+        base_name = os.path.basename(output_path).split('.')[0]
+        
+        # Save individual images for HTML display
+        image_paths = {}
+        
+        # Save original and modified images
+        original_path = os.path.join(images_dir, f"{base_name}_original.png")
+        modified_path = os.path.join(images_dir, f"{base_name}_modified.png")
+        self.img_processor.save_image(image_pair_results['original_image'], original_path)
+        self.img_processor.save_image(image_pair_results['modified_image'], modified_path)
+        image_paths['original_image_path'] = os.path.relpath(original_path, output_dir)
+        image_paths['modified_image_path'] = os.path.relpath(modified_path, output_dir)
+        
+        # Save difference and threshold images
+        difference_path = os.path.join(images_dir, f"{base_name}_difference.png")
+        threshold_path = os.path.join(images_dir, f"{base_name}_threshold.png")
+        self.img_processor.save_image(image_pair_results['difference_image'], difference_path)
+        self.img_processor.save_image(image_pair_results['threshold_image'], threshold_path)
+        image_paths['difference_image_path'] = os.path.relpath(difference_path, output_dir)
+        image_paths['threshold_image_path'] = os.path.relpath(threshold_path, output_dir)
+        
+        # Save annotated and labeled images
+        annotated_path = os.path.join(images_dir, f"{base_name}_annotated.png")
+        labeled_path = os.path.join(images_dir, f"{base_name}_labeled.png")
+        self.img_processor.save_image(image_pair_results['annotated_image'], annotated_path)
+        self.img_processor.save_image(image_pair_results['labeled_image'], labeled_path)
+        image_paths['annotated_image_path'] = os.path.relpath(annotated_path, output_dir)
+        image_paths['labeled_image_path'] = os.path.relpath(labeled_path, output_dir)
+        
+        # Save heatmap overlay
+        heatmap_path = os.path.join(images_dir, f"{base_name}_heatmap.png")
+        self.img_processor.save_image(image_pair_results['heatmap_overlay'], heatmap_path)
+        image_paths['heatmap_overlay_path'] = os.path.relpath(heatmap_path, output_dir)
+        
+        # Save multi-level heatmaps if available
+        multi_heatmaps = image_pair_results.get('multi_heatmaps', {})
+        if 'low' in multi_heatmaps and 'medium' in multi_heatmaps and 'high' in multi_heatmaps:
+            low_path = os.path.join(images_dir, f"{base_name}_heatmap_low.png")
+            medium_path = os.path.join(images_dir, f"{base_name}_heatmap_medium.png")
+            high_path = os.path.join(images_dir, f"{base_name}_heatmap_high.png")
+            
+            self.img_processor.save_image(multi_heatmaps['low'], low_path)
+            self.img_processor.save_image(multi_heatmaps['medium'], medium_path)
+            self.img_processor.save_image(multi_heatmaps['high'], high_path)
+            
+            image_paths['low_heatmap_path'] = os.path.relpath(low_path, output_dir)
+            image_paths['medium_heatmap_path'] = os.path.relpath(medium_path, output_dir)
+            image_paths['high_heatmap_path'] = os.path.relpath(high_path, output_dir)
+        
+        # Format threat summary for HTML display
+        threat_summary_text = self._format_summary_text(
+            image_pair_results['threat_summary'], 
+            image_pair_results['smi_score']
+        )
+        
+        # Read HTML template
+        template_path = os.path.join(os.path.dirname(__file__), 'templates', 'interactive_comparison.html')
+        with open(template_path, 'r') as f:
+            html_template = f.read()
+        
+        # Replace placeholders with actual values
+        for key, value in image_paths.items():
+            html_template = html_template.replace(f"{{{{{key}}}}}", value)
+        
+        # Replace threat summary
+        html_template = html_template.replace("{{threat_summary}}", threat_summary_text)
+        
+        # Write HTML file
+        with open(output_path, 'w') as f:
+            f.write(html_template)
+        
+        print(f"Interactive comparison saved to: {output_path}")
+        return output_path
+    
+    def process_and_visualize(self, image1_path, image2_path, output_dir, model_path=None, threshold=30, min_area=100):
+        """
+        Process an image pair and create comprehensive visualization
+        
+        Args:
+            image1_path: Path to first image
+            image2_path: Path to second image
+            output_dir: Directory to save outputs
+            model_path: Path to AI model (optional)
+            threshold: Threshold for difference detection
+            min_area: Minimum area for region detection
+            
+        Returns:
+            Path to the generated comparison visualization
+        """
+        # Initialize components
+        detector = DeepfakeDetector(model_path)
+        labeler = ThreatLabeler()
+        heatmap_gen = HeatmapGenerator()
+        
+        # Create output directory
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+        
+        # Get base filename for outputs
+        base_name = os.path.splitext(os.path.basename(image1_path))[0]
+        
+        # Step 1: Verification Module - Process the image pair
+        print(f"Processing images: {image1_path} and {image2_path}")
+        detection_results = detector.process_image_pair(image1_path, image2_path, threshold, min_area)
+        
+        # Step 2: Labeling System - Label detected regions by threat level
+        original_image = self.img_processor.load_image(image1_path)
+        modified_image = self.img_processor.load_image(image2_path)
+        labeled_image, labeled_regions = labeler.label_regions(
+            original_image, detection_results['difference_image'], detection_results['bounding_boxes'])
+        
+        # Get threat summary
+        threat_summary = labeler.get_threat_summary(labeled_regions)
+        
+        # Step 3: Heatmap Visualization - Generate heatmaps for threat visualization
+        heatmap_overlay = heatmap_gen.generate_threat_heatmap(original_image, labeled_regions)
+        multi_heatmaps = heatmap_gen.generate_multi_level_heatmap(original_image, labeled_regions)
+        
+        # Combine all results
+        all_results = {
+            'original_image': original_image,
+            'modified_image': modified_image,
+            'difference_image': detection_results['difference_image'],
+            'threshold_image': detection_results['threshold_image'],
+            'annotated_image': detection_results['annotated_image'],
+            'labeled_image': labeled_image,
+            'heatmap_overlay': heatmap_overlay,
+            'multi_heatmaps': multi_heatmaps,
+            'threat_summary': threat_summary,
+            'smi_score': detection_results['smi_score'],
+            'bounding_boxes': detection_results['bounding_boxes']
+        }
+        
+        # Create and save comparison visualization
+        grid_output_path = os.path.join(output_dir, f"{base_name}_comparison.png")
+        self.create_comparison_grid(all_results, grid_output_path)
+        
+        # Create interactive HTML comparison
+        html_output_path = os.path.join(output_dir, f"{base_name}_interactive.html")
+        self.create_interactive_comparison(all_results, html_output_path)
+        
+        print(f"Comparison visualization saved to: {grid_output_path}")
+        print(f"Interactive HTML comparison saved to: {html_output_path}")
+        return html_output_path  # Return the interactive HTML path as the primary output
+
+
+def batch_process_directory(input_dir, output_dir, model_path=None, threshold=30, min_area=100):
+    """
+    Process all image pairs in a directory and create comparison visualizations
+    
+    Args:
+        input_dir: Directory containing input images
+        output_dir: Directory to save outputs
+        model_path: Path to AI model (optional)
+        threshold: Threshold for difference detection
+        min_area: Minimum area for region detection
+        
+    Returns:
+        List of paths to generated HTML comparison files
+    """
+    # Ensure output directory exists
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    # Get all image files in input directory
+    image_files = [f for f in os.listdir(input_dir) 
+                  if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
+    
+    if not image_files:
+        print(f"No image files found in {input_dir}")
+        return []
+    
+    # Group images for comparison (assuming pairs with _original and _modified suffixes)
+    original_images = [f for f in image_files if '_original' in f]
+    modified_images = [f for f in image_files if '_modified' in f]
+    
+    # If we don't have clear pairs, just process consecutive images
+    if not (original_images and modified_images):
+        # Process images in pairs (1&2, 3&4, etc.)
+        if len(image_files) < 2:
+            print("Need at least 2 images to compare")
+            return []
+            
+        image_pairs = [(image_files[i], image_files[i+1]) 
+                      for i in range(0, len(image_files)-1, 2)]
+        print(f"No _original/_modified naming pattern found. Processing {len(image_pairs)} consecutive pairs.")
+    else:
+        # Match original and modified pairs
+        image_pairs = []
+        for orig in original_images:
+            base_name = orig.replace('_original', '')
+            for mod in modified_images:
+                if base_name in mod:
+                    image_pairs.append((orig, mod))
+                    break
+        print(f"Found {len(image_pairs)} original/modified image pairs.")
+    
+    if not image_pairs:
+        print("No valid image pairs found to process")
+        return []
+    
+    # Initialize comparison interface
+    interface = ComparisonInterface()
+    
+    # Process each image pair
+    html_paths = []
+    for img1, img2 in image_pairs:
+        img1_path = os.path.join(input_dir, img1)
+        img2_path = os.path.join(input_dir, img2)
+        
+        print(f"\n{'='*50}")
+        print(f"Processing pair: {img1} and {img2}")
+        print(f"{'='*50}")
+        
+        # Process and create comparison visualization
+        html_path = interface.process_and_visualize(
+            img1_path, img2_path, output_dir,
+            model_path, threshold, min_area
+        )
+        html_paths.append(html_path)
+    
+    print(f"\n{'='*50}")
+    print(f"Overall Summary: Processed {len(image_pairs)} image pairs")
+    print(f"{'='*50}")
+    print(f"All comparison visualizations saved to: {output_dir}")
+    
+    return html_paths
+
+
+if __name__ == "__main__":
+    import argparse
+    import webbrowser
+    
+    parser = argparse.ArgumentParser(description='Deepfake Detection Comparison Interface')
+    parser.add_argument('--input_dir', type=str, required=True, help='Directory containing input images')
+    parser.add_argument('--output_dir', type=str, required=True, help='Directory to save output visualizations')
+    parser.add_argument('--model_path', type=str, help='Path to Nvidia AI model (optional)')
+    parser.add_argument('--threshold', type=int, default=30, help='Threshold for difference detection (0-255)')
+    parser.add_argument('--min_area', type=int, default=100, help='Minimum area for region detection')
+    parser.add_argument('--open_browser', action='store_true', help='Automatically open HTML results in browser')
+    
+    args = parser.parse_args()
+    
+    # Process all images in the directory
+    html_paths = batch_process_directory(
+        args.input_dir, args.output_dir,
+        args.model_path, args.threshold, args.min_area
+    )
+    
+    # Open the first result in browser if requested
+    if args.open_browser and html_paths:
+        print(f"\nOpening first result in web browser: {html_paths[0]}")
+        webbrowser.open('file://' + os.path.abspath(html_paths[0]))
+        
+    print("\nTo view interactive results, open the HTML files in your web browser.")
+    print("Example: file://" + os.path.abspath(html_paths[0]) if html_paths else "")
+    print("\nDone!")

deepfake_detector.py

@@ -0,0 +1,235 @@
+import cv2
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+from PIL import Image
+
+class DeepfakeDetector:
+    def __init__(self, model_path=None):
+        """
+        Initialize the deepfake detector with Nvidia AI model
+        
+        Args:
+            model_path: Path to the pre-trained Nvidia AI model
+        """
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.model = self._load_model(model_path)
+        self.transform = transforms.Compose([
+            transforms.Resize((256, 256)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+    
+    def _load_model(self, model_path):
+        """
+        Load the Nvidia AI model for deepfake detection
+        
+        Args:
+            model_path: Path to the pre-trained model
+            
+        Returns:
+            Loaded model
+        """
+        # This is a placeholder for the actual model loading code
+        # In a real implementation, you would load the specific Nvidia AI model here
+        if model_path:
+            try:
+                # Example placeholder for model loading
+                # model = torch.load(model_path, map_location=self.device)
+                print(f"Model loaded from {model_path}")
+                return None  # Replace with actual model
+            except Exception as e:
+                print(f"Error loading model: {e}")
+                return None
+        else:
+            print("No model path provided, using default detection methods")
+            return None
+    
+    def calculate_smi(self, image1, image2):
+        """
+        Calculate Structural Matching Index between two images
+        
+        Args:
+            image1: First image (numpy array or path)
+            image2: Second image (numpy array or path)
+            
+        Returns:
+            SMI score (float between 0 and 1)
+        """
+        # Convert paths to images if needed
+        if isinstance(image1, str):
+            image1 = cv2.imread(image1)
+            image1 = cv2.cvtColor(image1, cv2.COLOR_BGR2RGB)
+        
+        if isinstance(image2, str):
+            image2 = cv2.imread(image2)
+            image2 = cv2.cvtColor(image2, cv2.COLOR_BGR2RGB)
+        
+        # Ensure images are the same size
+        if image1.shape != image2.shape:
+            image2 = cv2.resize(image2, (image1.shape[1], image1.shape[0]))
+        
+        # Calculate SMI (similar to SSIM but adapted for deepfake detection)
+        # This is a simplified version - in a real implementation, you would use
+        # the specific SMI calculation from the Nvidia AI model
+        gray1 = cv2.cvtColor(image1, cv2.COLOR_RGB2GRAY)
+        gray2 = cv2.cvtColor(image2, cv2.COLOR_RGB2GRAY)
+        
+        # Using SSIM as a placeholder for SMI
+        from skimage.metrics import structural_similarity as ssim
+        smi_score, _ = ssim(gray1, gray2, full=True)
+        
+        return smi_score
+    
+    def generate_difference_image(self, image1, image2):
+        """
+        Generate a difference image highlighting areas of discrepancy
+        
+        Args:
+            image1: First image (numpy array or path)
+            image2: Second image (numpy array or path)
+            
+        Returns:
+            Difference image (numpy array)
+        """
+        # Convert paths to images if needed
+        if isinstance(image1, str):
+            image1 = cv2.imread(image1)
+            image1 = cv2.cvtColor(image1, cv2.COLOR_BGR2RGB)
+        
+        if isinstance(image2, str):
+            image2 = cv2.imread(image2)
+            image2 = cv2.cvtColor(image2, cv2.COLOR_BGR2RGB)
+        
+        # Ensure images are the same size
+        if image1.shape != image2.shape:
+            image2 = cv2.resize(image2, (image1.shape[1], image1.shape[0]))
+        
+        # Convert to grayscale
+        gray1 = cv2.cvtColor(image1, cv2.COLOR_RGB2GRAY)
+        gray2 = cv2.cvtColor(image2, cv2.COLOR_RGB2GRAY)
+        
+        # Compute the absolute difference
+        diff = cv2.absdiff(gray1, gray2)
+        
+        # Normalize for better visualization
+        diff_normalized = cv2.normalize(diff, None, 0, 255, cv2.NORM_MINMAX)
+        
+        return diff_normalized
+    
+    def apply_threshold(self, diff_image, threshold=30):
+        """
+        Apply threshold to difference image to highlight significant differences
+        
+        Args:
+            diff_image: Difference image (numpy array)
+            threshold: Threshold value (0-255)
+            
+        Returns:
+            Thresholded image (numpy array)
+        """
+        _, thresh = cv2.threshold(diff_image, threshold, 255, cv2.THRESH_BINARY)
+        return thresh
+    
+    def detect_bounding_boxes(self, thresh_image, min_area=100):
+        """
+        Detect bounding boxes around areas of significant difference
+        
+        Args:
+            thresh_image: Thresholded image (numpy array)
+            min_area: Minimum contour area to consider
+            
+        Returns:
+            List of bounding boxes (x, y, w, h)
+        """
+        # Find contours in the thresholded image
+        contours, _ = cv2.findContours(thresh_image.astype(np.uint8), 
+                                      cv2.RETR_EXTERNAL, 
+                                      cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Filter contours by area and get bounding boxes
+        bounding_boxes = []
+        for contour in contours:
+            area = cv2.contourArea(contour)
+            if area >= min_area:
+                x, y, w, h = cv2.boundingRect(contour)
+                bounding_boxes.append((x, y, w, h))
+        
+        return bounding_boxes
+    
+    def draw_bounding_boxes(self, image, bounding_boxes, color=(0, 255, 0), thickness=2):
+        """
+        Draw bounding boxes on an image
+        
+        Args:
+            image: Image to draw on (numpy array)
+            bounding_boxes: List of bounding boxes (x, y, w, h)
+            color: Box color (B, G, R)
+            thickness: Line thickness
+            
+        Returns:
+            Image with bounding boxes
+        """
+        # Make a copy of the image to avoid modifying the original
+        result = image.copy()
+        
+        # Draw each bounding box
+        for (x, y, w, h) in bounding_boxes:
+            cv2.rectangle(result, (x, y), (x + w, y + h), color, thickness)
+        
+        return result
+    
+    def process_image_pair(self, image1, image2, threshold=30, min_area=100):
+        """
+        Process a pair of images through the complete verification pipeline
+        
+        Args:
+            image1: First image (numpy array or path)
+            image2: Second image (numpy array or path)
+            threshold: Threshold value for difference detection
+            min_area: Minimum area for bounding box detection
+            
+        Returns:
+            Dictionary containing:
+            - smi_score: Structural Matching Index
+            - difference_image: Difference visualization
+            - threshold_image: Thresholded difference image
+            - bounding_boxes: List of detected bounding boxes
+            - annotated_image: Original image with bounding boxes
+        """
+        # Load images if paths are provided
+        if isinstance(image1, str):
+            img1 = cv2.imread(image1)
+            img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
+        else:
+            img1 = image1.copy()
+            
+        if isinstance(image2, str):
+            img2 = cv2.imread(image2)
+            img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
+        else:
+            img2 = image2.copy()
+            
+        # Calculate SMI
+        smi_score = self.calculate_smi(img1, img2)
+        
+        # Generate difference image
+        diff_image = self.generate_difference_image(img1, img2)
+        
+        # Apply threshold
+        thresh_image = self.apply_threshold(diff_image, threshold)
+        
+        # Detect bounding boxes
+        bounding_boxes = self.detect_bounding_boxes(thresh_image, min_area)
+        
+        # Draw bounding boxes on original image
+        annotated_image = self.draw_bounding_boxes(img1, bounding_boxes)
+        
+        # Return results
+        return {
+            'smi_score': smi_score,
+            'difference_image': diff_image,
+            'threshold_image': thresh_image,
+            'bounding_boxes': bounding_boxes,
+            'annotated_image': annotated_image
+        }

demo_combined_visualization.py

@@ -0,0 +1,109 @@
+import os
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from deepfake_detector import DeepfakeDetector
+from image_processor import ImageProcessor
+from labeling import ThreatLabeler
+from heatmap_generator import HeatmapGenerator
+from combined_visualization import CombinedVisualizer
+
+def ensure_dir(directory):
+    """Ensure directory exists"""
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+def demo_combined_visualization(image1_path, image2_path, output_dir, threshold=30, min_area=100):
+    """
+    Demonstrate the combined visualization that overlays difference image, 
+    low and medium threat heatmaps, and bounding boxes.
+    
+    Args:
+        image1_path: Path to original image
+        image2_path: Path to modified image
+        output_dir: Directory to save outputs
+        threshold: Threshold for difference detection
+        min_area: Minimum area for region detection
+    """
+    # Initialize components
+    detector = DeepfakeDetector()
+    labeler = ThreatLabeler()
+    heatmap_gen = HeatmapGenerator()
+    img_processor = ImageProcessor()
+    visualizer = CombinedVisualizer()
+    
+    # Create output directory
+    ensure_dir(output_dir)
+    
+    # Get base filename for outputs
+    base_name = os.path.splitext(os.path.basename(image1_path))[0]
+    
+    print(f"Processing images: {image1_path} and {image2_path}")
+    
+    # Step 1: Verification Module - Process the image pair
+    results = detector.process_image_pair(image1_path, image2_path, threshold, min_area)
+    
+    # Step 2: Labeling System - Label detected regions by threat level
+    original_image = img_processor.load_image(image1_path)
+    modified_image = img_processor.load_image(image2_path)
+    labeled_image, labeled_regions = labeler.label_regions(
+        original_image, results['difference_image'], results['bounding_boxes'])
+    
+    # Get threat summary
+    threat_summary = labeler.get_threat_summary(labeled_regions)
+    
+    # Step 3: Generate multi-level heatmaps
+    multi_heatmaps = heatmap_gen.generate_multi_level_heatmap(original_image, labeled_regions)
+    
+    # Prepare results for combined visualization
+    image_pair_results = {
+        'original_image': original_image,
+        'modified_image': modified_image,
+        'difference_image': results['difference_image'],
+        'threshold_image': results['threshold_image'],
+        'annotated_image': results['annotated_image'],
+        'labeled_image': labeled_image,
+        'multi_heatmaps': multi_heatmaps,
+        'bounding_boxes': results['bounding_boxes'],
+        'labeled_regions': labeled_regions,
+        'threat_summary': threat_summary,
+        'smi_score': results['smi_score']
+    }
+    
+    # Create combined visualization
+    output_path = os.path.join(output_dir, f"{base_name}_combined_overlay.png")
+    visualizer.create_combined_visualization(
+        image_pair_results, 
+        output_path, 
+        alpha_diff=0.4,  # Transparency for difference image
+        alpha_low=0.3,   # Transparency for low threat heatmap
+        alpha_medium=0.4 # Transparency for medium threat heatmap
+    )
+    
+    # Print summary information
+    print(f"\nAnalysis Results:")
+    print(f"SMI Score: {results['smi_score']:.4f} (1.0 = identical, 0.0 = completely different)")
+    print(f"Total regions detected: {threat_summary['total_regions']}")
+    print(f"Threat counts: Low={threat_summary['threat_counts']['low']}, "
+          f"Medium={threat_summary['threat_counts']['medium']}, "
+          f"High={threat_summary['threat_counts']['high']}")
+    if threat_summary['max_threat']:
+        print(f"Maximum threat: {threat_summary['max_threat']['level'].upper()} "
+              f"({threat_summary['max_threat']['percentage']:.1f}%)")
+    print(f"Average difference: {threat_summary['average_difference']:.1f}%")
+    
+    print(f"\nCombined visualization saved to: {output_path}")
+    return output_path
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) < 3:
+        print("Usage: python demo_combined_visualization.py <original_image> <modified_image> [output_dir]")
+        sys.exit(1)
+    
+    image1_path = sys.argv[1]
+    image2_path = sys.argv[2]
+    output_dir = sys.argv[3] if len(sys.argv) > 3 else "./output"
+    
+    demo_combined_visualization(image1_path, image2_path, output_dir)

image_processor.py

@@ -0,0 +1,162 @@
+import cv2
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+
+class ImageProcessor:
+    def __init__(self):
+        """
+        Initialize the image processor for handling image manipulation tasks
+        """
+        pass
+    
+    @staticmethod
+    def load_image(image_path):
+        """
+        Load an image from a file path
+        
+        Args:
+            image_path: Path to the image file
+            
+        Returns:
+            Loaded image as numpy array in RGB format
+        """
+        img = cv2.imread(image_path)
+        if img is None:
+            raise ValueError(f"Could not load image from {image_path}")
+        return cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    
+    @staticmethod
+    def save_image(image, output_path):
+        """
+        Save an image to a file
+        
+        Args:
+            image: Image as numpy array in RGB format
+            output_path: Path to save the image
+        """
+        # Convert from RGB to BGR for OpenCV
+        if len(image.shape) == 3 and image.shape[2] == 3:
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+        cv2.imwrite(output_path, image)
+        
+    @staticmethod
+    def resize_image(image, width=None, height=None):
+        """
+        Resize an image while maintaining aspect ratio
+        
+        Args:
+            image: Image as numpy array
+            width: Target width (if None, calculated from height)
+            height: Target height (if None, calculated from width)
+            
+        Returns:
+            Resized image
+        """
+        if width is None and height is None:
+            return image
+            
+        h, w = image.shape[:2]
+        if width is None:
+            aspect = height / float(h)
+            dim = (int(w * aspect), height)
+        elif height is None:
+            aspect = width / float(w)
+            dim = (width, int(h * aspect))
+        else:
+            dim = (width, height)
+            
+        return cv2.resize(image, dim, interpolation=cv2.INTER_AREA)
+    
+    @staticmethod
+    def normalize_image(image):
+        """
+        Normalize image values to 0-255 range
+        
+        Args:
+            image: Input image
+            
+        Returns:
+            Normalized image
+        """
+        return cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+    
+    @staticmethod
+    def apply_color_map(image, colormap=cv2.COLORMAP_JET):
+        """
+        Apply a colormap to a grayscale image
+        
+        Args:
+            image: Grayscale image
+            colormap: OpenCV colormap type
+            
+        Returns:
+            Color-mapped image
+        """
+        if len(image.shape) == 3:
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        return cv2.applyColorMap(image, colormap)
+    
+    @staticmethod
+    def overlay_images(background, overlay, alpha=0.5):
+        """
+        Overlay one image on top of another with transparency
+        
+        Args:
+            background: Background image
+            overlay: Image to overlay
+            alpha: Transparency factor (0-1)
+            
+        Returns:
+            Combined image
+        """
+        # Ensure images are the same size
+        if background.shape != overlay.shape:
+            overlay = cv2.resize(overlay, (background.shape[1], background.shape[0]))
+            
+        # Blend images
+        return cv2.addWeighted(background, 1-alpha, overlay, alpha, 0)
+    
+    @staticmethod
+    def crop_image(image, x, y, width, height):
+        """
+        Crop a region from an image
+        
+        Args:
+            image: Input image
+            x, y: Top-left corner coordinates
+            width, height: Dimensions of the crop
+            
+        Returns:
+            Cropped image
+        """
+        return image[y:y+height, x:x+width]
+    
+    @staticmethod
+    def display_images(images, titles=None, figsize=(15, 10)):
+        """
+        Display multiple images in a grid
+        
+        Args:
+            images: List of images to display
+            titles: List of titles for each image
+            figsize: Figure size (width, height)
+        """
+        n = len(images)
+        if titles is None:
+            titles = [f'Image {i+1}' for i in range(n)]
+            
+        fig, axes = plt.subplots(1, n, figsize=figsize)
+        if n == 1:
+            axes = [axes]
+            
+        for i, (img, title) in enumerate(zip(images, titles)):
+            if len(img.shape) == 2 or img.shape[2] == 1:  # Grayscale
+                axes[i].imshow(img, cmap='gray')
+            else:  # Color
+                axes[i].imshow(img)
+            axes[i].set_title(title)
+            axes[i].axis('off')
+            
+        plt.tight_layout()
+        return fig

labeling.py

@@ -0,0 +1,146 @@
+import numpy as np
+import cv2
+
+class ThreatLabeler:
+    def __init__(self):
+        """
+        Initialize the threat labeling system for deepfake detection
+        """
+        # Define threat level thresholds
+        self.threat_levels = {
+            'low': (0, 30),      # Low threat: 0-30% difference
+            'medium': (30, 60),  # Medium threat: 30-60% difference
+            'high': (60, 100)    # High threat: 60-100% difference
+        }
+        
+        # Define colors for each threat level (BGR format for OpenCV)
+        self.threat_colors = {
+            'low': (0, 255, 0),      # Green
+            'medium': (0, 165, 255), # Orange
+            'high': (0, 0, 255)      # Red
+        }
+    
+    def calculate_threat_level(self, diff_value):
+        """
+        Calculate threat level based on difference value
+        
+        Args:
+            diff_value: Normalized difference value (0-100)
+            
+        Returns:
+            Threat level string ('low', 'medium', or 'high')
+        """
+        for level, (min_val, max_val) in self.threat_levels.items():
+            if min_val <= diff_value < max_val:
+                return level
+        return 'high'  # Default to high if outside ranges
+    
+    def calculate_region_threat(self, diff_image, bbox):
+        """
+        Calculate the threat level for a specific region
+        
+        Args:
+            diff_image: Difference image (normalized 0-255)
+            bbox: Bounding box (x, y, w, h)
+            
+        Returns:
+            Threat level string and average difference value
+        """
+        x, y, w, h = bbox
+        region = diff_image[y:y+h, x:x+w]
+        
+        # Calculate average difference in the region (normalized to 0-100)
+        avg_diff = np.mean(region) / 255 * 100
+        
+        # Determine threat level
+        threat_level = self.calculate_threat_level(avg_diff)
+        
+        return threat_level, avg_diff
+    
+    def label_regions(self, image, diff_image, bounding_boxes):
+        """
+        Label regions with threat levels and colors
+        
+        Args:
+            image: Original image to label
+            diff_image: Difference image
+            bounding_boxes: List of bounding boxes (x, y, w, h)
+            
+        Returns:
+            Labeled image and list of regions with threat levels
+        """
+        # Make a copy of the image to avoid modifying the original
+        labeled_image = image.copy()
+        labeled_regions = []
+        
+        # Process each bounding box
+        for bbox in bounding_boxes:
+            x, y, w, h = bbox
+            
+            # Calculate threat level for this region
+            threat_level, avg_diff = self.calculate_region_threat(diff_image, bbox)
+            
+            # Get color for this threat level
+            color = self.threat_colors[threat_level]
+            
+            # Draw colored rectangle based on threat level
+            cv2.rectangle(labeled_image, (x, y), (x + w, y + h), color, 2)
+            
+            # Add label text with threat level and percentage
+            label_text = f"{threat_level.upper()}: {avg_diff:.1f}%"
+            cv2.putText(labeled_image, label_text, (x, y - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+            
+            # Store labeled region info
+            labeled_regions.append({
+                'bbox': bbox,
+                'threat_level': threat_level,
+                'difference_percentage': avg_diff
+            })
+        
+        return labeled_image, labeled_regions
+    
+    def get_threat_summary(self, labeled_regions):
+        """
+        Generate a summary of threat levels in the image
+        
+        Args:
+            labeled_regions: List of labeled regions with threat levels
+            
+        Returns:
+            Dictionary with threat summary statistics
+        """
+        if not labeled_regions:
+            return {
+                'total_regions': 0,
+                'threat_counts': {'low': 0, 'medium': 0, 'high': 0},
+                'max_threat': None,
+                'average_difference': 0
+            }
+        
+        # Count regions by threat level
+        threat_counts = {'low': 0, 'medium': 0, 'high': 0}
+        total_diff = 0
+        max_threat = {'level': 'low', 'percentage': 0}
+        
+        for region in labeled_regions:
+            level = region['threat_level']
+            diff = region['difference_percentage']
+            
+            # Update counts
+            threat_counts[level] += 1
+            total_diff += diff
+            
+            # Track maximum threat
+            if diff > max_threat['percentage']:
+                max_threat = {'level': level, 'percentage': diff}
+        
+        # Calculate average difference
+        avg_diff = total_diff / len(labeled_regions) if labeled_regions else 0
+        
+        return {
+            'total_regions': len(labeled_regions),
+            'threat_counts': threat_counts,
+            'max_threat': max_threat,
+            'average_difference': avg_diff
+        }

main.py

@@ -0,0 +1,167 @@
+import os
+import argparse
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from deepfake_detector import DeepfakeDetector
+from image_processor import ImageProcessor
+from labeling import ThreatLabeler
+from heatmap_generator import HeatmapGenerator
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Deepfake Detection with Heatmap Visualization')
+    parser.add_argument('--input_dir', type=str, required=True, help='Directory containing input images')
+    parser.add_argument('--output_dir', type=str, required=True, help='Directory to save output visualizations')
+    parser.add_argument('--model_path', type=str, help='Path to Nvidia AI model (optional)')
+    parser.add_argument('--threshold', type=int, default=30, help='Threshold for difference detection (0-255)')
+    parser.add_argument('--min_area', type=int, default=100, help='Minimum area for region detection')
+    return parser.parse_args()
+
+def ensure_dir(directory):
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+def process_image_pair(image1_path, image2_path, output_dir, model_path=None, threshold=30, min_area=100):
+    # Initialize components
+    detector = DeepfakeDetector(model_path)
+    labeler = ThreatLabeler()
+    heatmap_gen = HeatmapGenerator()
+    img_processor = ImageProcessor()
+    
+    # Create output subdirectories
+    verification_dir = os.path.join(output_dir, 'verification')
+    labeling_dir = os.path.join(output_dir, 'labeling')
+    heatmap_dir = os.path.join(output_dir, 'heatmap')
+    ensure_dir(verification_dir)
+    ensure_dir(labeling_dir)
+    ensure_dir(heatmap_dir)
+    
+    # Get base filename for outputs
+    base_name = os.path.splitext(os.path.basename(image1_path))[0]
+    
+    # Step 1: Verification Module - Process the image pair
+    print(f"Processing images: {image1_path} and {image2_path}")
+    results = detector.process_image_pair(image1_path, image2_path, threshold, min_area)
+    
+    # Save verification results
+    img_processor.save_image(results['difference_image'], 
+                           os.path.join(verification_dir, f"{base_name}_diff.png"))
+    img_processor.save_image(results['threshold_image'], 
+                           os.path.join(verification_dir, f"{base_name}_threshold.png"))
+    img_processor.save_image(results['annotated_image'], 
+                           os.path.join(verification_dir, f"{base_name}_annotated.png"))
+    
+    # Print SMI score
+    print(f"SMI Score: {results['smi_score']:.4f} (1.0 = identical, 0.0 = completely different)")
+    
+    # Step 2: Labeling System - Label detected regions by threat level
+    original_image = img_processor.load_image(image1_path)
+    labeled_image, labeled_regions = labeler.label_regions(
+        original_image, results['difference_image'], results['bounding_boxes'])
+    
+    # Save labeled image
+    img_processor.save_image(labeled_image, 
+                           os.path.join(labeling_dir, f"{base_name}_labeled.png"))
+    
+    # Get threat summary
+    threat_summary = labeler.get_threat_summary(labeled_regions)
+    print("\nThreat Summary:")
+    print(f"Total regions detected: {threat_summary['total_regions']}")
+    print(f"Threat counts: Low={threat_summary['threat_counts']['low']}, "
+          f"Medium={threat_summary['threat_counts']['medium']}, "
+          f"High={threat_summary['threat_counts']['high']}")
+    if threat_summary['max_threat']:
+        print(f"Maximum threat: {threat_summary['max_threat']['level'].upper()} "
+              f"({threat_summary['max_threat']['percentage']:.1f}%)")
+    print(f"Average difference: {threat_summary['average_difference']:.1f}%")
+    
+    # Step 3: Heatmap Visualization - Generate heatmaps for threat visualization
+    # Generate standard heatmap
+    heatmap = heatmap_gen.generate_threat_heatmap(original_image, labeled_regions)
+    img_processor.save_image(heatmap, 
+                           os.path.join(heatmap_dir, f"{base_name}_heatmap.png"))
+    
+    # Generate multi-level heatmaps
+    multi_heatmaps = heatmap_gen.generate_multi_level_heatmap(original_image, labeled_regions)
+    
+    # Save multi-level heatmaps
+    for level, hmap in multi_heatmaps.items():
+        if level != 'overlay':  # 'overlay' is already saved above
+            img_processor.save_image(hmap, 
+                                   os.path.join(heatmap_dir, f"{base_name}_heatmap_{level}.png"))
+    
+    # Save side-by-side visualization
+    heatmap_gen.save_heatmap_visualization(
+        original_image, multi_heatmaps['overlay'],
+        os.path.join(output_dir, f"{base_name}_visualization.png")
+    )
+    
+    print(f"\nProcessing complete. Results saved to {output_dir}")
+    return threat_summary
+
+def main():
+    args = parse_args()
+    
+    # Ensure output directory exists
+    ensure_dir(args.output_dir)
+    
+    # Get all image files in input directory
+    image_files = [f for f in os.listdir(args.input_dir) 
+                  if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
+    
+    # Group images for comparison (assuming pairs with _original and _modified suffixes)
+    # This is a simple example - you might need to adjust based on your naming convention
+    original_images = [f for f in image_files if '_original' in f]
+    modified_images = [f for f in image_files if '_modified' in f]
+    
+    # If we don't have clear pairs, just process consecutive images
+    if not (original_images and modified_images):
+        # Process images in pairs (1&2, 3&4, etc.)
+        image_pairs = [(image_files[i], image_files[i+1]) 
+                      for i in range(0, len(image_files)-1, 2)]
+    else:
+        # Match original and modified pairs
+        image_pairs = []
+        for orig in original_images:
+            base_name = orig.replace('_original', '')
+            for mod in modified_images:
+                if base_name in mod:
+                    image_pairs.append((orig, mod))
+                    break
+    
+    # Process each image pair
+    results = []
+    for img1, img2 in image_pairs:
+        img1_path = os.path.join(args.input_dir, img1)
+        img2_path = os.path.join(args.input_dir, img2)
+        
+        print(f"\n{'='*50}")
+        print(f"Processing pair: {img1} and {img2}")
+        print(f"{'='*50}")
+        
+        result = process_image_pair(
+            img1_path, img2_path, args.output_dir,
+            args.model_path, args.threshold, args.min_area
+        )
+        results.append({
+            'pair': (img1, img2),
+            'summary': result
+        })
+    
+    # Print overall summary
+    print(f"\n{'='*50}")
+    print(f"Overall Summary: Processed {len(image_pairs)} image pairs")
+    print(f"{'='*50}")
+    
+    high_threat_pairs = [r for r in results 
+                        if r['summary']['threat_counts']['high'] > 0]
+    print(f"Pairs with high threats: {len(high_threat_pairs)} / {len(results)}")
+    
+    if high_threat_pairs:
+        print("\nHigh threat pairs:")
+        for r in high_threat_pairs:
+            print(f"- {r['pair'][0]} and {r['pair'][1]}: "
+                  f"{r['summary']['threat_counts']['high']} high threat regions")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,20 @@
+# Core dependencies
+numpy>=1.19.0
+opencv-python>=4.5.0
+pillow>=8.0.0
+scipy>=1.6.0
+matplotlib>=3.3.0
+
+# Deep learning frameworks
+torch>=1.8.0
+torchvision>=0.9.0
+
+# Image processing
+scikit-image>=0.18.0
+
+# Visualization
+seaborn>=0.11.0
+streamlit>=1.20.0
+
+# Nvidia AI model dependencies
+cupy-cuda11x>=10.0.0  # Adjust based on your CUDA version

streamlit_app.py

@@ -0,0 +1,188 @@
+import os
+import streamlit as st
+import tempfile
+from PIL import Image
+import numpy as np
+from comparison_interface import ComparisonInterface
+from deepfake_detector import DeepfakeDetector
+from image_processor import ImageProcessor
+from labeling import ThreatLabeler
+from heatmap_generator import HeatmapGenerator
+
+# Set page configuration
+st.set_page_config(page_title="Deepfake Detection Analysis", layout="wide")
+
+# Initialize components
+comparison = ComparisonInterface()
+img_processor = ImageProcessor()
+
+# Custom CSS to improve the UI
+st.markdown("""
+<style>
+.main-header {
+    font-size: 2.5rem;
+    font-weight: bold;
+    color: #1E3A8A;
+    text-align: center;
+    margin-bottom: 1rem;
+}
+.sub-header {
+    font-size: 1.5rem;
+    font-weight: bold;
+    color: #2563EB;
+    margin-top: 1rem;
+    margin-bottom: 0.5rem;
+}
+.info-text {
+    font-size: 1rem;
+    color: #4B5563;
+}
+.stImage {
+    margin-top: 1rem;
+    margin-bottom: 1rem;
+}
+</style>
+""", unsafe_allow_html=True)
+
+# App header
+st.markdown('<p class="main-header">Deepfake Detection Analysis</p>', unsafe_allow_html=True)
+st.markdown('<p class="info-text">Upload original and modified images to analyze potential deepfakes</p>', unsafe_allow_html=True)
+
+# Create columns for file uploaders
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown('<p class="sub-header">Original Image</p>', unsafe_allow_html=True)
+    original_file = st.file_uploader("Upload the original image", type=["jpg", "jpeg", "png"])
+
+with col2:
+    st.markdown('<p class="sub-header">Modified Image</p>', unsafe_allow_html=True)
+    modified_file = st.file_uploader("Upload the potentially modified image", type=["jpg", "jpeg", "png"])
+
+# Parameters for analysis
+st.markdown('<p class="sub-header">Analysis Parameters</p>', unsafe_allow_html=True)
+col1, col2 = st.columns(2)
+with col1:
+    threshold = st.slider("Difference Threshold", min_value=10, max_value=100, value=30, 
+                         help="Higher values detect only significant differences")
+with col2:
+    min_area = st.slider("Minimum Detection Area", min_value=50, max_value=500, value=100,
+                        help="Minimum area size to consider as a modified region")
+
+# Process images when both are uploaded
+if original_file and modified_file:
+    # Create temporary directory for processing
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Save uploaded files to temporary directory
+        original_path = os.path.join(temp_dir, "original.jpg")
+        modified_path = os.path.join(temp_dir, "modified.jpg")
+        
+        with open(original_path, "wb") as f:
+            f.write(original_file.getbuffer())
+        with open(modified_path, "wb") as f:
+            f.write(modified_file.getbuffer())
+        
+        # Create output directory
+        output_dir = os.path.join(temp_dir, "output")
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Process images and generate visualization
+        with st.spinner("Processing images and generating analysis..."): 
+            # Initialize components
+            detector = DeepfakeDetector()
+            labeler = ThreatLabeler()
+            heatmap_gen = HeatmapGenerator()
+            
+            # Step 1: Verification Module - Process the image pair
+            detection_results = detector.process_image_pair(original_path, modified_path, threshold, min_area)
+            
+            # Step 2: Labeling System - Label detected regions by threat level
+            original_image = img_processor.load_image(original_path)
+            modified_image = img_processor.load_image(modified_path)
+            labeled_image, labeled_regions = labeler.label_regions(
+                original_image, detection_results['difference_image'], detection_results['bounding_boxes'])
+            
+            # Get threat summary
+            threat_summary = labeler.get_threat_summary(labeled_regions)
+            
+            # Step 3: Heatmap Visualization - Generate heatmaps for threat visualization
+            heatmap_overlay = heatmap_gen.generate_threat_heatmap(original_image, labeled_regions)
+            multi_heatmaps = heatmap_gen.generate_multi_level_heatmap(original_image, labeled_regions)
+            
+            # Combine all results
+            all_results = {
+                'original_image': original_image,
+                'modified_image': modified_image,
+                'difference_image': detection_results['difference_image'],
+                'threshold_image': detection_results['threshold_image'],
+                'annotated_image': detection_results['annotated_image'],
+                'labeled_image': labeled_image,
+                'heatmap_overlay': heatmap_overlay,
+                'multi_heatmaps': multi_heatmaps,
+                'threat_summary': threat_summary,
+                'smi_score': detection_results['smi_score'],
+                'bounding_boxes': detection_results['bounding_boxes']
+            }
+            
+            # Create output directory in a permanent location
+            output_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "comparison_output")
+            os.makedirs(output_dir, exist_ok=True)
+            
+            # Generate unique filename based on original image
+            base_name = os.path.splitext(original_file.name)[0]
+            output_path = os.path.join(output_dir, f"{base_name}_combined_overlay.png")
+            
+            # Create and save combined visualization with heatmaps
+            from combined_visualization import CombinedVisualizer
+            visualizer = CombinedVisualizer()
+            combined_results = {
+                'original_image': original_image,
+                'difference_image': detection_results['difference_image'],
+                'bounding_boxes': detection_results['bounding_boxes'],
+                'multi_heatmaps': multi_heatmaps,
+                'labeled_regions': labeled_regions
+            }
+            combined_path = visualizer.create_combined_visualization(
+                combined_results, output_path,
+                alpha_diff=0.4, alpha_low=0.3, alpha_medium=0.4
+            )
+            
+            # Create and save comparison visualization
+            grid_output_path = os.path.join(output_dir, f"{base_name}_comparison.png")
+            comparison.create_comparison_grid(all_results, grid_output_path)
+            
+            # Display the comprehensive visualization
+            st.markdown('<p class="sub-header">Comprehensive Analysis</p>', unsafe_allow_html=True)
+            st.image(grid_output_path, use_container_width=True)
+            
+            # Display threat summary
+            st.markdown('<p class="sub-header">Threat Summary</p>', unsafe_allow_html=True)
+            st.markdown(f"**SMI Score:** {detection_results['smi_score']:.4f} (1.0 = identical, 0.0 = completely different)")
+            st.markdown(f"**Total regions detected:** {threat_summary['total_regions']}")
+            
+            # Create columns for threat counts
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.markdown(f"**Low threats:** {threat_summary['threat_counts']['low']}")
+            with col2:
+                st.markdown(f"**Medium threats:** {threat_summary['threat_counts']['medium']}")
+            with col3:
+                st.markdown(f"**High threats:** {threat_summary['threat_counts']['high']}")
+            
+            if threat_summary['max_threat']:
+                st.markdown(f"**Maximum threat:** {threat_summary['max_threat']['level'].upper()} ({threat_summary['max_threat']['percentage']:.1f}%)")
+            
+            st.markdown(f"**Average difference:** {threat_summary['average_difference']:.1f}%")
+
+else:
+    # Display instructions when images are not yet uploaded
+    st.info("Please upload both original and modified images to begin analysis.")
+    
+    # Display sample image
+    st.markdown('<p class="sub-header">Sample Analysis Output</p>', unsafe_allow_html=True)
+    sample_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "comparison_output", "deepfake1_comparison.png")
+    if os.path.exists(sample_path):
+        st.image(sample_path, use_container_width=True)
+        st.caption("Sample analysis showing all detection stages in a single comprehensive view")
+    else:
+        st.write("Sample image not available. Please upload images to see the analysis.")