feat: add SSIM perceptual diffing and JSON output support

- Integrated image-compare crate for structural similarity (SSIM)
- Added --json flag for machine-readable results
- Improved image handling with automatic padding for mismatched dimensions
- Updated CLI output with detailed pixel and structural statistics

Author: maskedsyntax

Cargo.toml

@@ -15,3 +15,6 @@ colored = "2.1.0"
 indicatif = "0.17.8"
 terminal_size = "0.3.0"
 pathdiff = "0.2.1"
+serde = { version = "1.0.200", features = ["derive"] }
+serde_json = "1.0.116"
+image-compare = "0.5.0"

src/compare.rs

@@ -1,11 +1,16 @@
 use anyhow::Result;
 use image::{GenericImageView, ImageBuffer, Rgba};
+use image_compare::Algorithm;
+use serde::Serialize;
 use std::path::Path;
 
+#[derive(Serialize)]
 pub struct DiffResult {
     pub score: f64,
+    pub ssim_score: f64,
     pub diff_pixels: u64,
     pub total_pixels: u64,
+    #[serde(skip)]
     pub diff_image: Option<ImageBuffer<Rgba<u8>, Vec<u8>>>,
 }
 
@@ -24,6 +29,23 @@ pub fn compare_images(
     let max_width = width_a.max(width_b);
     let max_height = height_a.max(height_b);
 
+    // For SSIM, we need identical dimensions.
+    // We'll use the max dimensions and pad with transparent pixels if needed.
+    let mut rgba_a = img_a.to_rgba8();
+    let mut rgba_b = img_b.to_rgba8();
+
+    if width_a != max_width || height_a != max_height {
+        let mut new_a = ImageBuffer::new(max_width, max_height);
+        image::imageops::overlay(&mut new_a, &rgba_a, 0, 0);
+        rgba_a = new_a;
+    }
+
+    if width_b != max_width || height_b != max_height {
+        let mut new_b = ImageBuffer::new(max_width, max_height);
+        image::imageops::overlay(&mut new_b, &rgba_b, 0, 0);
+        rgba_b = new_b;
+    }
+
     let mut diff_pixels = 0u64;
     let total_pixels = (max_width as u64) * (max_height as u64);
 
@@ -35,30 +57,19 @@ pub fn compare_images(
 
     for y in 0..max_height {
         for x in 0..max_width {
-            let pixel_a = if x < width_a && y < height_a {
-                img_a.get_pixel(x, y)
-            } else {
-                Rgba([0, 0, 0, 0])
-            };
-
-            let pixel_b = if x < width_b && y < height_b {
-                img_b.get_pixel(x, y)
-            } else {
-                Rgba([0, 0, 0, 0])
-            };
-
-            let dist = color_distance(&pixel_a, &pixel_b);
+            let pixel_a = rgba_a.get_pixel(x, y);
+            let pixel_b = rgba_b.get_pixel(x, y);
+
+            let dist = color_distance(pixel_a, pixel_b);
 
             let is_different = dist > (threshold as f64);
 
             if is_different {
                 diff_pixels += 1;
                 if let Some(ref mut buffer) = diff_buffer {
-                    // Magenta for differences
                     buffer.put_pixel(x, y, Rgba([255, 0, 255, 255]));
                 }
             } else if let Some(ref mut buffer) = diff_buffer {
-                // Dimmed version of original for non-diff
                 let r = (pixel_a[0] as f32 * 0.1) as u8;
                 let g = (pixel_a[1] as f32 * 0.1) as u8;
                 let b = (pixel_a[2] as f32 * 0.1) as u8;
@@ -69,14 +80,21 @@ pub fn compare_images(
 
     let score = 1.0 - (diff_pixels as f64 / total_pixels as f64);
 
+    // Calculate SSIM using RGB
+    let rgb_a = image::DynamicImage::ImageRgba8(rgba_a).to_rgb8();
+    let rgb_b = image::DynamicImage::ImageRgba8(rgba_b).to_rgb8();
+    let ssim_score = image_compare::rgb_similarity_structure(&Algorithm::MSSIMSimple, &rgb_a, &rgb_b).unwrap().score;
+
     Ok(DiffResult {
         score,
+        ssim_score,
         diff_pixels,
         total_pixels,
         diff_image: diff_buffer,
     })
 }
 
+
 fn color_distance(p1: &Rgba<u8>, p2: &Rgba<u8>) -> f64 {
     let r_diff = (p1[0] as f64 - p2[0] as f64) / 255.0;
     let g_diff = (p1[1] as f64 - p2[1] as f64) / 255.0;

src/dir.rs

@@ -3,14 +3,18 @@ use anyhow::Result;
 use indicatif::{ProgressBar, ProgressStyle};
 use rayon::prelude::*;
 use std::path::{Path, PathBuf};
+use serde::Serialize;
 use walkdir::WalkDir;
 
+#[derive(Serialize)]
+#[serde(tag = "type", content = "data")]
 pub enum DirDiffStatus {
     Match(DiffResult),
     MissingInB,
     Error(String),
 }
 
+#[derive(Serialize)]
 pub struct DirDiffItem {
     pub relative_path: PathBuf,
     pub status: DirDiffStatus,

src/main.rs

@@ -31,6 +31,10 @@ struct Args {
     /// Fail if any difference is found (non-zero exit code)
     #[arg(long)]
     fail_on_diff: bool,
+
+    /// Output results in JSON format
+    #[arg(long)]
+    json: bool,
 }
 
 fn main() -> Result<()> {
@@ -51,21 +55,26 @@ fn run_file_diff(args: &Args) -> Result<()> {
         args.output.is_some() || args.preview,
     )?;
 
-    println!("{}", "Comparison Result:".bold());
-    println!("  Similarity: {:.2}%", res.score * 100.0);
-    println!("  Diff Pixels: {}", res.diff_pixels);
-    println!("  Total Pixels: {}", res.total_pixels);
-
-    if let Some(diff_img) = &res.diff_image {
-        if let Some(output_path) = &args.output {
-            diff_img.save(output_path)?;
-            println!("  Diff image saved to: {}", output_path.display().to_string().cyan());
-        }
+    if args.json {
+        println!("{}", serde_json::to_string_pretty(&res)?);
+    } else {
+        println!("{}", "Comparison Result:".bold());
+        println!("  Pixel Similarity: {:.2}%", res.score * 100.0);
+        println!("  SSIM Score:       {:.4}", res.ssim_score);
+        println!("  Diff Pixels:      {}", res.diff_pixels);
+        println!("  Total Pixels:     {}", res.total_pixels);
+
+        if let Some(diff_img) = &res.diff_image {
+            if let Some(output_path) = &args.output {
+                diff_img.save(output_path)?;
+                println!("  Diff image saved to: {}", output_path.display().to_string().cyan());
+            }
 
-        if args.preview {
-            println!("\n{}", "Terminal Preview:".bold());
-            let dynamic_img = image::DynamicImage::ImageRgba8(diff_img.clone());
-            terminal::print_preview(&dynamic_img);
+            if args.preview {
+                println!("\n{}", "Terminal Preview:".bold());
+                let dynamic_img = image::DynamicImage::ImageRgba8(diff_img.clone());
+                terminal::print_preview(&dynamic_img);
+            }
         }
     }
 
@@ -79,49 +88,61 @@ fn run_file_diff(args: &Args) -> Result<()> {
 fn run_dir_diff(args: &Args) -> Result<()> {
     let items = dir::compare_directories(&args.path_a, &args.path_b, args.threshold)?;
 
-    println!("\n{:<40} {:<10} {:<10}", "File", "Score", "Status");
-    println!("{}", "-".repeat(65));
-
     let mut diff_count = 0;
 
-    let total_files = items.len();
-    for item in items {
-        match item.status {
-            dir::DirDiffStatus::Match(res) => {
-                let status = if res.diff_pixels > 0 {
-                    diff_count += 1;
-                    "DIFF".red()
-                } else {
-                    "OK".green()
-                };
-                println!("{:<40} {:<10.2}% {:<10}", 
-                    item.relative_path.display().to_string(),
-                    res.score * 100.0,
-                    status
-                );
-            }
-            dir::DirDiffStatus::MissingInB => {
-                diff_count += 1;
-                println!("{:<40} {:<10} {:<10}", 
-                    item.relative_path.display().to_string(),
-                    "-".dimmed(),
-                    "MISSING".yellow()
-                );
+    if args.json {
+        println!("{}", serde_json::to_string_pretty(&items)?);
+        // Calculate diff_count for exit code even in JSON mode
+        for item in &items {
+            match item.status {
+                dir::DirDiffStatus::Match(ref res) if res.diff_pixels > 0 => diff_count += 1,
+                dir::DirDiffStatus::MissingInB => diff_count += 1,
+                _ => {}
             }
-            dir::DirDiffStatus::Error(e) => {
-                println!("{:<40} {:<10} {:<10}", 
-                    item.relative_path.display().to_string(),
-                    "ERROR".red(),
-                    e.yellow()
-                );
+        }
+    } else {
+        println!("\n{:<40} {:<10} {:<10} {:<10}", "File", "Pixel", "SSIM", "Status");
+        println!("{}", "-".repeat(75));
+
+        for item in &items {
+            match item.status {
+                dir::DirDiffStatus::Match(ref res) => {
+                    let status = if res.diff_pixels > 0 {
+                        diff_count += 1;
+                        "DIFF".red()
+                    } else {
+                        "OK".green()
+                    };
+                    println!("{:<40} {:<10.2}% {:<10.4} {:<10}", 
+                        item.relative_path.display().to_string(),
+                        res.score * 100.0,
+                        res.ssim_score,
+                        status
+                    );
+                }
+                dir::DirDiffStatus::MissingInB => {
+                    diff_count += 1;
+                    println!("{:<40} {:<10} {:<10}", 
+                        item.relative_path.display().to_string(),
+                        "-".dimmed(),
+                        "MISSING".yellow()
+                    );
+                }
+                dir::DirDiffStatus::Error(ref e) => {
+                    println!("{:<40} {:<10} {:<10}", 
+                        item.relative_path.display().to_string(),
+                        "ERROR".red(),
+                        e.yellow()
+                    );
+                }
             }
         }
-    }
 
-    println!("\nSummary: {} files compared, {} differences found.", 
-        total_files, 
-        diff_count
-    );
+        println!("\nSummary: {} files compared, {} differences found.", 
+            items.len(), 
+            diff_count
+        );
+    }
 
     if args.fail_on_diff && diff_count > 0 {
         std::process::exit(1);