From 1e4760418c1b8a47a26b325d1e28761e46cd9522 Mon Sep 17 00:00:00 2001 From: Kornel Date: Fri, 10 Nov 2017 15:42:06 +0000 Subject: [PATCH] Initial public release --- .gitignore | 3 + Cargo.toml | 30 +++ README.md | 73 +++++++ src/blur.rs | 238 +++++++++++++++++++++++ src/dssim.rs | 387 +++++++++++++++++++++++++++++++++++++ src/ffi.rs | 84 ++++++++ src/image.rs | 296 ++++++++++++++++++++++++++++ src/lib.rs | 12 ++ src/linear.rs | 129 +++++++++++++ src/main.rs | 159 +++++++++++++++ src/tolab.rs | 107 ++++++++++ src/val.rs | 148 ++++++++++++++ tests/gray-profile.png | Bin 0 -> 15871 bytes tests/gray-profile2.png | Bin 0 -> 15601 bytes tests/gray1-gray.png | Bin 0 -> 1095 bytes tests/gray1-pal.png | Bin 0 -> 1165 bytes tests/gray1-rgba.png | Bin 0 -> 2232 bytes tests/gray1.jpg | Bin 0 -> 989 bytes tests/profile-stripped.png | Bin 0 -> 8570 bytes tests/profile.png | Bin 0 -> 9196 bytes tests/test1-sm.png | Bin 0 -> 103280 bytes tests/test2-sm.png | Bin 0 -> 83235 bytes 22 files changed, 1666 insertions(+) create mode 100644 .gitignore create mode 100644 Cargo.toml create mode 100644 README.md create mode 100644 src/blur.rs create mode 100644 src/dssim.rs create mode 100644 src/ffi.rs create mode 100644 src/image.rs create mode 100644 src/lib.rs create mode 100644 src/linear.rs create mode 100644 src/main.rs create mode 100644 src/tolab.rs create mode 100644 src/val.rs create mode 100644 tests/gray-profile.png create mode 100644 tests/gray-profile2.png create mode 100644 tests/gray1-gray.png create mode 100644 tests/gray1-pal.png create mode 100644 tests/gray1-rgba.png create mode 100644 tests/gray1.jpg create mode 100644 tests/profile-stripped.png create mode 100644 tests/profile.png create mode 100644 tests/test1-sm.png create mode 100644 tests/test2-sm.png diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..17dc43b --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +dssim +Cargo.lock +target/ diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..ae1ebae --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,30 @@ +[package] +authors = ["Kornel "] +categories = ["multimedia::images", "command-line-utilities"] +description = "Measures structural similarity between images using a multi-scale variant of the SSIM algorithm." +documentation = "https://github.com/pornel/dssim#readme" +homepage = "https://kornel.ski/dssim" +include = ["README.md", "Cargo.toml", "tests/*.png", "src/*.rs"] +keywords = ["ssim", "image", "comparison"] +license = "AGPL-3.0" +name = "dssim" +readme = "README.md" +repository = "https://github.com/pornel/dssim.git" +version = "2.8.0" + +[[bin]] +doctest = false +name = "dssim" +path = "src/main.rs" + +[dependencies] +getopts = "0.2.15" +imgref = "1.3.0" +itertools = "0.7.2" +lodepng = "2.0.4" +rgb = "0.8.1" +unzip3 = "0.1.0" + +[lib] +doctest = false +name = "dssim" diff --git a/README.md b/README.md new file mode 100644 index 0000000..d8a3257 --- /dev/null +++ b/README.md @@ -0,0 +1,73 @@ +# RGBA Structural Similarity + +This tool computes (dis)similarity between two or more PNG images using an algorithm approximating human vision. + +Comparison is done using [the SSIM algorithm](https://ece.uwaterloo.ca/~z70wang/research/ssim/) at multiple weighed resolutions. + +The value returned is 1/SSIM-1, where 0 means identical image, and >0 (unbounded) is amount of difference. Values are not directly comparable with other tools. [See below](#interpreting-the-values) on interpreting the values. + +## Features + +* Comparison is done in in L\*a\*b\* color space (D65 white point, sRGB gamma) with chroma subsampling. Other implementations use "RGB" or grayscale without gamma correction. +* Supports alpha channel. +* No OpenCV or MATLAB needed. + - DSSIM [version 1.x](https://github.com/pornel/dssim/tree/dssim1-c) uses C (C99) and `libpng` or Cocoa on macOS. + - DSSIM version 2.x is easy to build with [Rust](https://www.rust-lang.org/). + +## Usage + + dssim file-original.png file-modified.png + +Will output something like "0.02341" (smaller is better) followed by a filename. + +You can supply multiple filenames to compare them all with the first file: + + dssim file.png modified1.png modified2.png modified3.png + +You can save an image visualising the difference between the files: + + dssim -o difference.png file.png file-modified.png + +The `dssim.c` file is also usable as a C library. + +### Interpreting the values + +The amount of difference goes from 0 to infinity. It's not a percentage. + +If you're comparing two different image compression codecs, then ensure you either: + +* compress images to the same file size, and then use DSSIM to compare which one is closests to the original, or +* compress images to the same DSSIM value, and compare file sizes to see how much file size gain each option gives. + +[More about benchmarking image compression](https://kornel.ski/faircomparison). + +When you quote results, please include DSSIM version, since the scale has changed between versions. +The version is printed when you run `dssim -h`. + +## Build or Download + +You need Rust + + cargo build --release + +Will give you `./target/release/dssim`. + +## Accuracy + +Scores for version 2.0 measured against [TID2013][1] database: + +TID2013 Category | Spearman correlation +--- | --- +Noise | -0.930 +Actual | -0.937 +Simple | -0.945 +Exotic | -0.842 +New | -0.771 +Color | -0.779 +Full | -0.851 + +[1]: http://www.ponomarenko.info/tid2013.htm + +## License + +DSSIM is dual-licensed under [AGPL](LICENSE) or [commercial](https://supportedsource.org/projects/dssim) license. diff --git a/src/blur.rs b/src/blur.rs new file mode 100644 index 0000000..a2df38e --- /dev/null +++ b/src/blur.rs @@ -0,0 +1,238 @@ +const KERNEL: [f32; 9] = [ + 1./16., 2./16., 1./16., + 2./16., 4./16., 2./16., + 1./16., 2./16., 1./16., +]; + +#[cfg(target_os = "macos")] +mod mac { + use std; + use ffi::vImage_Buffer; + use ffi::vImageConvolve_PlanarF; + use ffi::vImage_Flags::kvImageEdgeExtend; + use super::KERNEL; + + pub fn blur(src: &[f32], tmp: &mut [f32], dst: &mut [f32], width: usize, height: usize) { + assert_eq!(src.len(), width * height); + assert_eq!(dst.len(), width * height); + + let srcbuf = vImage_Buffer { + width: width as u64, + height: height as u64, + rowBytes: width * std::mem::size_of::(), + data: src.as_ptr(), + }; + let mut dstbuf = vImage_Buffer { + width: width as u64, + height: height as u64, + rowBytes: width * std::mem::size_of::(), + data: dst.as_mut_ptr(), + }; + + do_blur(&srcbuf, tmp, &mut dstbuf, width, height); + } + + pub fn blur_in_place(srcdst: &mut [f32], tmp: &mut [f32], width: usize, height: usize) { + assert_eq!(srcdst.len(), width * height); + + let srcbuf = vImage_Buffer { + width: width as u64, + height: height as u64, + rowBytes: width * std::mem::size_of::(), + data: srcdst.as_ptr(), + }; + let mut dstbuf = vImage_Buffer { + width: width as u64, + height: height as u64, + rowBytes: width * std::mem::size_of::(), + data: srcdst.as_mut_ptr(), + }; + + do_blur(&srcbuf, tmp, &mut dstbuf, width, height); + } + + pub fn do_blur(srcbuf: &vImage_Buffer<*const f32>, tmp: &mut [f32], dstbuf: &mut vImage_Buffer<*mut f32>, width: usize, height: usize) { + assert_eq!(tmp.len(), width * height); + + unsafe { + let mut tmpwrbuf = vImage_Buffer { + width: width as u64, + height: height as u64, + rowBytes: width * std::mem::size_of::(), + data: tmp.as_mut_ptr(), + }; + let res = vImageConvolve_PlanarF(srcbuf, &mut tmpwrbuf, std::ptr::null_mut(), 0, 0, KERNEL.as_ptr(), 3, 3, 0., kvImageEdgeExtend); + assert_eq!(0, res); + + let tmprbuf = vImage_Buffer { + width: width as u64, + height: height as u64, + rowBytes: width * std::mem::size_of::(), + data: tmp.as_ptr(), + }; + let res = vImageConvolve_PlanarF(&tmprbuf, dstbuf, std::ptr::null_mut(), 0, 0, KERNEL.as_ptr(), 3, 3, 0., kvImageEdgeExtend); + assert_eq!(0, res); + } + } +} + +#[cfg(not(target_os = "macos"))] +mod portable { + use std::cmp::min; + use super::KERNEL; + + #[inline] + fn do3f(prev: &[f32], curr: &[f32], next: &[f32], i: usize) -> f32 { + debug_assert!(i > 0); + + let c0 = i-1; + let c1 = i; + let c2 = i+1; + + unsafe { + prev.get_unchecked(c0)*KERNEL[0] + prev.get_unchecked(c1)*KERNEL[1] + prev.get_unchecked(c2)*KERNEL[2] + + curr.get_unchecked(c0)*KERNEL[3] + curr.get_unchecked(c1)*KERNEL[4] + curr.get_unchecked(c2)*KERNEL[5] + + next.get_unchecked(c0)*KERNEL[6] + next.get_unchecked(c1)*KERNEL[7] + next.get_unchecked(c2)*KERNEL[8] + } + } + + fn do3(prev: &[f32], curr: &[f32], next: &[f32], i: usize, width: usize) -> f32 { + let c0 = if i > 0 {i-1} else {0}; + let c1 = i; + let c2 = min(i+1, width-1); + + prev[c0]*KERNEL[0] + prev[c1]*KERNEL[1] + prev[c2]*KERNEL[2] + + curr[c0]*KERNEL[3] + curr[c1]*KERNEL[4] + curr[c2]*KERNEL[5] + + next[c0]*KERNEL[6] + next[c1]*KERNEL[7] + next[c2]*KERNEL[8] + } + + pub fn blur(src: &[f32], tmp: &mut [f32], dst: &mut [f32], width: usize, height: usize) { + do_blur(src, tmp, width, height); + do_blur(tmp, dst, width, height); + } + + pub fn do_blur(src: &[f32], dst: &mut [f32], width: usize, height: usize) { + assert!(width > 0); + assert!(width < 1<<24); + assert!(height > 0); + assert!(height < 1<<24); + assert!(src.len() >= width*height); + assert!(dst.len() >= width*height); + + let mut prev = &src[0..width]; + let mut curr = prev; + let mut next = prev; + for y in 0..height { + prev = curr; + curr = next; + next = if y+1 < height {&src[(y+1)*width..(y+2)*width]} else {curr}; + + let mut dstrow = &mut dst[y*width..y*width+width]; + + dstrow[0] = do3(prev, curr, next, 0, width); + for i in 1..width-1 { + dstrow[i] = do3f(prev, curr, next, i); + } + if width > 1 { + dstrow[width-1] = do3(prev, curr, next, width-1, width); + } + } + } + + pub fn blur_in_place(srcdst: &mut [f32], tmp: &mut [f32], width: usize, height: usize) { + do_blur(srcdst, tmp, width, height); + do_blur(tmp, srcdst, width, height); + } +} + + +#[cfg(target_os = "macos")] +pub use self::mac::*; + +#[cfg(not(target_os = "macos"))] +pub use self::portable::*; + +#[test] +fn blur_zero() { + let src = vec![0.25]; + + let mut tmp = vec![-55.; 1]; + let mut dst = vec![-99.; 1]; + + let mut src2 = src.clone(); + + blur(&src[..], &mut tmp[..], &mut dst[..], 1, 1); + blur_in_place(&mut src2[..], &mut tmp[..], 1, 1); + + assert_eq!(src2, dst); + assert_eq!(0.25, dst[0]); +} + +#[test] +fn blur_one() { + let src = vec![ + 0.,0.,0.,0.,0., + 0.,0.,0.,0.,0., + 0.,0.,1.,0.,0., + 0.,0.,0.,0.,0., + 0.,0.,0.,0.,0., + ]; + let mut tmp = vec![-55.; 5*5]; + let mut dst = vec![999.; 5*5]; + + let mut src2 = src.clone(); + + blur(&src[..], &mut tmp[..], &mut dst[..], 5, 5); + blur_in_place(&mut src2[..], &mut tmp[..], 5, 5); + + assert_eq!(src2, dst); + + assert_eq!(1./256., dst[0]); + assert_eq!(1./256., dst[5*5-1]); + let center = 1./16.*1./16. + 2./16.*2./16. + 1./16.*1./16. + + 2./16.*2./16. + 4./16.*4./16. + 2./16.*2./16. + + 1./16.*1./16. + 2./16.*2./16. + 1./16.*1./16.; + assert_eq!(center, dst[2*5+2]); + +} + +#[test] +fn blur_two() { + let src = vec![ + 0.,1.,1.,1., + 1.,1.,1.,1., + 1.,1.,1.,1., + 1.,1.,1.,1., + ]; + let mut tmp = vec![-55.; 4*4]; + let mut dst = vec![999.; 4*4]; + + let mut src2 = src.clone(); + + blur(&src[..], &mut tmp[..], &mut dst[..], 4, 4); + blur_in_place(&mut src2[..], &mut tmp[..], 4, 4); + + assert_eq!(src2, dst); + + let z00 = 0.*1./16. + 0.*2./16. + 1.*1./16. + + 0.*2./16. + 0.*4./16. + 1.*2./16. + + 1.*1./16. + 1.*2./16. + 1.*1./16.; + let z01 = 0.*1./16. + 1.*2./16. + 1.*1./16. + + 0.*2./16. + 1.*4./16. + 1.*2./16. + + 1.*1./16. + 1.*2./16. + 1.*1./16.; + + let z10 = 0.*1./16. + 0.*2./16. + 1.*1./16. + + 1.*2./16. + 1.*4./16. + 1.*2./16. + + 1.*1./16. + 1.*2./16. + 1.*1./16.; + let z11 = 0.*1./16. + 1.*2./16. + 1.*1./16. + + 1.*2./16. + 1.*4./16. + 1.*2./16. + + 1.*1./16. + 1.*2./16. + 1.*1./16.; + let exp = z00*1./16. + z00*2./16. + z01*1./16. + + z00*2./16. + z00*4./16. + z01*2./16. + + z10*1./16. + z10*2./16. + z11*1./16.; + + assert_eq!(1., dst[3]); + assert_eq!(1., dst[3 * 4]); + assert_eq!(1., dst[4 * 4 - 1]); + assert_eq!(exp, dst[0]); +} diff --git a/src/dssim.rs b/src/dssim.rs new file mode 100644 index 0000000..edb5922 --- /dev/null +++ b/src/dssim.rs @@ -0,0 +1,387 @@ +#![allow(non_upper_case_globals)] +#![allow(non_snake_case)] +/* + * © 2011-2017 Kornel Lesiński. All rights reserved. + * + * This file is part of DSSIM. + * + * DSSIM is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * DSSIM is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the license along with DSSIM. + * If not, see . + */ + +extern crate itertools; + +use self::itertools::multizip; +use blur; +use image::*; +use std; +use std::ops; +pub use val::Dssim as Val; +pub use tolab::ToLABBitmap; + +trait Channable { + fn img1_img2_blur<'a>(&self, modified: &mut Self, tmp: &mut [I]) -> Vec; +} + +pub struct DssimChan { + pub width: usize, + pub height: usize, + pub img: Option>, + pub mu: Vec, + pub img_sq_blur: Vec, + pub is_chroma: bool, +} + +pub struct Dssim { + scale_weights: Vec, + save_maps_scales: u8, +} + +struct DssimChanScale { + chan: Vec>, +} + +pub struct DssimImage { + scale: Vec>, +} + +// Scales are taken from IW-SSIM, but this is not IW-SSIM algorithm +const DEFAULT_WEIGHTS: [f64; 5] = [0.0448, 0.2856, 0.3001, 0.2363, 0.1333]; + +pub struct SsimMap { + pub width: usize, + pub height: usize, + pub ssim: f64, + pub data: Vec, +} + +pub fn new() -> Dssim { + Dssim::new() +} + +impl DssimChan { + pub fn new(bitmap: Vec, width: usize, height: usize, is_chroma: bool) -> DssimChan { + DssimChan { + img: Some(bitmap), + mu: Vec::with_capacity(width * height), + img_sq_blur: Vec::new(), + width: width, + height: height, + is_chroma: is_chroma, + } + } +} + +impl DssimChan { + fn preprocess(&mut self, tmp: &mut [f32]) { + let width = self.width; + let height = self.height; + let tmp = &mut tmp[0..width * height]; + + let img = self.img.as_mut().unwrap(); + assert_eq!(img.len(), self.width * self.height); + assert!(width > 1); + assert!(height > 1); + + unsafe { + if self.is_chroma { + blur::blur_in_place(&mut img[..], tmp, width, height); + } + + self.mu.reserve(self.width * self.height); + self.mu.set_len(self.width * self.height); + blur::blur(&img[..], tmp, &mut self.mu[..], width, height); + + self.img_sq_blur = img.iter().cloned().map(|i| i * i).collect(); + blur::blur_in_place(&mut self.img_sq_blur[..], tmp, width, height); + } + } +} + +impl Channable for [DssimChan] { + fn img1_img2_blur<'a>(&self, modified: &mut Self, tmp32: &mut [f32]) -> Vec { + + let blurred:Vec<_> = self.iter().zip(modified.iter_mut()).map(|(o,m)|{ + o.img1_img2_blur(m, tmp32) + }).collect(); + + return multizip((blurred[0].iter(), blurred[1].iter(), blurred[2].iter())).map(|(l,a,b)| { + LAB{l:*l,a:*a,b:*b} + }).collect(); + } +} + +impl Channable for DssimChan { + fn img1_img2_blur<'a>(&self, modified: &mut Self, tmp32: &mut [f32]) -> Vec { + let mut modified_img = modified.img.take().unwrap(); + + for (img2, img1) in modified_img.iter_mut().zip(self.img.as_ref().unwrap().iter()) { + *img2 *= *img1 + } + + blur::blur_in_place(&mut modified_img[..], tmp32, self.width, self.height); + return modified_img; + } +} + +impl Dssim { + pub fn new() -> Dssim { + Dssim { + scale_weights: DEFAULT_WEIGHTS.iter().cloned().take(4).collect(), + save_maps_scales: 0, + } + } + + pub fn set_scales(&mut self, scales: &[f64]) { + self.scale_weights = scales.to_vec(); + } + + pub fn set_save_ssim_maps(&mut self, num_scales: u8) { + self.save_maps_scales = num_scales; + } + + pub fn create_scales(&self, src_img: &InBitmap) -> Vec + where + InBitmap: Downsample, + OutBitmap: Downsample, + { + let num_scales = self.scale_weights.len(); + + let mut downsampled: Vec = Vec::with_capacity(num_scales); + for _ in 1..num_scales { // 1, because unscaled bitmap will be added + let s = if let Some(l) = downsampled.last() { + l.downsample() + } else { + src_img.downsample() + }; + if let Some(s) = s { + downsampled.push(s); + } else { + break; + } + } + + return downsampled; + } + + pub fn create_image(&mut self, src_img: &InBitmap) -> Option> + where InBitmap: ToLABBitmap, + OutBitmap: ToLABBitmap, + InBitmap: Downsample, + OutBitmap: Downsample + { + let mut all_sizes = std::iter::once(src_img.to_lab()) + .chain(self.create_scales(src_img).into_iter().map(|s| s.to_lab())) + .peekable(); + + let mut tmp = { + let largest = all_sizes.peek().unwrap(); + let pixels = largest[0].width() * largest[0].height(); + let mut tmp = Vec::with_capacity(pixels); + unsafe { tmp.set_len(pixels) }; + tmp + }; + + return Some(DssimImage { + scale: all_sizes.map(|s| { + DssimChanScale { + chan: s.into_iter().enumerate().map(|(n,l)| { + let w = l.width(); + let h = l.height(); + let mut ch = DssimChan::new(l.buf, w, h, n > 0); + ch.preprocess(&mut tmp[..]); + ch + }).collect(), + } + }).collect(), + }); + } + + pub fn compare(&mut self, original_image: &DssimImage, modified_image: DssimImage) -> (Val, Vec) { + let width = original_image.scale[0].chan[0].width; + let height = original_image.scale[0].chan[0].height; + + let mut tmp = Vec::with_capacity(width * height); + unsafe { tmp.set_len(width * height) }; + + let mut ssim_sum = 0.0; + let mut weight_sum = 0.0; + let mut ssim_maps = Vec::new(); + + for (n, (weight, mut modified_image_scale, original_image_scale)) in multizip(( + self.scale_weights.iter().cloned(), + modified_image.scale.into_iter(), + original_image.scale.iter(), + )).enumerate() { + + let scale_width = original_image_scale.chan[0].width; + let scale_height = original_image_scale.chan[0].height; + + let mut ssim_map = match original_image_scale.chan.len() { + 3 => { + let img1_img2_blur = original_image_scale.chan.img1_img2_blur(&mut modified_image_scale.chan, &mut tmp[0 .. scale_width*scale_height]); + + let original_lab = Self::lab_chan(&original_image_scale); + let modified_lab = Self::lab_chan(&modified_image_scale); + + Self::compare_channel(&original_lab, &modified_lab, &img1_img2_blur) + }, + 1 => { + let img1_img2_blur = original_image_scale.chan[0].img1_img2_blur(&mut modified_image_scale.chan[0], &mut tmp[0 .. scale_width*scale_height]); + Self::compare_channel(&original_image_scale.chan[0], &modified_image_scale.chan[0], &img1_img2_blur) + }, + _ => panic!(), + }; + + let half = avgworst(&ssim_map.data[..], ssim_map.width, ssim_map.height); + let half = avg(&half.buf[..], half.width(), half.height()); + let half = worst(&half.buf[..], half.width(), half.height()); + + let sum = half.buf.iter().fold(0., |sum, i| sum + *i as f64); + let score = sum / (half.buf.len() as f64); + + ssim_map.width = half.width(); + ssim_map.height = half.height(); + ssim_map.data = half.buf; + ssim_map.ssim = score; + + ssim_sum += weight * score; + weight_sum += weight; + + if self.save_maps_scales as usize > n { + ssim_maps.push(ssim_map); + } + } + + return (to_dssim(ssim_sum / weight_sum).into(), ssim_maps); + } + + fn lab_chan(scale: &DssimChanScale) -> DssimChan { + let l = &scale.chan[0]; + let a = &scale.chan[1]; + let b = &scale.chan[2]; + assert_eq!(l.width, a.width); + assert_eq!(b.width, a.width); + DssimChan { + img_sq_blur: multizip((l.img_sq_blur.iter(), a.img_sq_blur.iter(), b.img_sq_blur.iter())).map(|(l,a,b)|LAB{l:*l,a:*a,b:*b}).collect(), + img: if l.img.is_some() {Some(multizip((l.img.as_ref().unwrap().iter(), a.img.as_ref().unwrap().iter(), b.img.as_ref().unwrap().iter())).map(|(l,a,b)|LAB{l:*l,a:*a,b:*b}).collect())} else {None}, + mu: multizip((l.mu.iter(), a.mu.iter(), b.mu.iter())).map(|(l,a,b)|LAB{l:*l,a:*a,b:*b}).collect(), + is_chroma: false, + width: l.width, + height: l.height, + } + } + + fn compare_channel(original: &DssimChan, modified: &DssimChan, img1_img2_blur: &[L]) -> SsimMap + where L: Clone + Copy + ops::Mul + ops::Sub, + f32: std::convert::From + { + assert_eq!(original.width, modified.width); + assert_eq!(original.height, modified.height); + + let width = original.width; + let height = original.height; + + let c1 = 0.01 * 0.01; + let c2 = 0.03 * 0.03; + + let mut map_out = Vec::with_capacity(width * height); + unsafe { map_out.set_len(width * height) }; + + // FIXME: slice https://users.rust-lang.org/t/how-to-zip-two-slices-efficiently/2048 + for (img1_img2_blur, mu1, mu2, img1_sq_blur, img2_sq_blur, map_out) in + multizip((img1_img2_blur.iter().cloned(), + original.mu.iter().cloned(), + modified.mu.iter().cloned(), + original.img_sq_blur.iter().cloned(), + modified.img_sq_blur.iter().cloned(), + map_out.iter_mut())) { + + let mu1mu1 = mu1 * mu1; + let mu1mu2 = mu1 * mu2; + let mu2mu2 = mu2 * mu2; + let mu1_sq: f32 = mu1mu1.into(); + let mu2_sq: f32 = mu2mu2.into(); + let mu1_mu2: f32 = mu1mu2.into(); + let sigma1_sq: f32 = (img1_sq_blur - mu1mu1).into(); + let sigma2_sq: f32 = (img2_sq_blur - mu2mu2).into(); + let sigma12: f32 = (img1_img2_blur - mu1mu2).into(); + + let ssim = (2. * mu1_mu2 + c1) * (2. * sigma12 + c2) / + ((mu1_sq + mu2_sq + c1) * (sigma1_sq + sigma2_sq + c2)); + + *map_out = ssim; + } + + return SsimMap { + width: width, + height: height, + ssim: -1., + data: map_out, + }; + } +} + +fn to_dssim(ssim: f64) -> f64 { + debug_assert!(ssim > 0.0); + return 1.0 / ssim.min(1.0) - 1.0; +} + +impl SsimMap { + pub fn new() -> SsimMap { + SsimMap { + width: 0, + height: 0, + data: Vec::new(), + ssim: -1., + } + } + + pub fn data(&self) -> Option<&[f32]> { + if self.width == 0 { + return None; + } + return Some(&self.data[..]); + } +} + + +#[test] +fn png_compare() { + extern crate lodepng; + + use imgref::*; + use linear::*; + + let mut d = new(); + let file1 = lodepng::decode32_file("tests/test1-sm.png").unwrap(); + let file2 = lodepng::decode32_file("tests/test2-sm.png").unwrap(); + + let buf1 = &file1.buffer.to_rgbaplu()[..]; + let buf2 = &file2.buffer.to_rgbaplu()[..]; + let img1 = d.create_image(&Img::new(buf1, file1.width, file1.height)).unwrap(); + let img2 = d.create_image(&Img::new(buf2, file2.width, file2.height)).unwrap(); + + let (res, _) = d.compare(&img1, img2); + assert!((0.003297 - res).abs() < 0.0001, "res is {}", res); + assert!(res < 0.0033); + assert!(0.0032 < res); + + let img1b = d.create_image(&Img::new(buf1, file1.width, file1.height)).unwrap(); + let (res, _) = d.compare(&img1, img1b); + + assert!(0.000000000000001 > res); + assert!(res < 0.000000000000001); + assert_eq!(res, res); +} + diff --git a/src/ffi.rs b/src/ffi.rs new file mode 100644 index 0000000..bf0c837 --- /dev/null +++ b/src/ffi.rs @@ -0,0 +1,84 @@ +#![allow(dead_code)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] + +use std::os::raw::c_ulong; + +pub type dssim_px_t = f32; + +#[link(name = "Accelerate", kind = "framework")] +#[cfg(target_os = "macos")] +extern "C" { + pub fn vImageConvolve_PlanarF(src: *const vImage_Buffer<*const f32>, + dest: *mut vImage_Buffer<*mut f32>, + tempBuffer: *mut f32, + srcOffsetToROI_X: vImagePixelCount, + srcOffsetToROI_Y: vImagePixelCount, + kernel: *const f32, + kernel_height: u32, + kernel_width: u32, + backgroundColor: Pixel_F, + flags: vImage_Flags) -> vImage_Error; +} + +pub type vImagePixelCount = c_ulong; +pub type vImage_Error = isize; +pub type Pixel_F = f32; + +#[repr(u32)] +pub enum vImage_Flags { + kvImageNoFlags = 0, + + /* Operate on red, green and blue channels only. Alpha is copied from source + to destination. For Interleaved formats only. */ + kvImageLeaveAlphaUnchanged = 1, + + /* Copy edge pixels. Convolution Only. */ + kvImageCopyInPlace = 2, + + /* Use the background color for missing pixels. */ + kvImageBackgroundColorFill = 4, + + /* Use the nearest pixel for missing pixels. */ + kvImageEdgeExtend = 8, + + /* Pass to turn off internal tiling and disable internal multithreading. Use this if + you want to do your own tiling, or to use the Min/Max filters in place. */ + kvImageDoNotTile = 16, + + /* Use a higher quality, slower resampling filter for Geometry operations + (shear, scale, rotate, affine transform, etc.) */ + kvImageHighQualityResampling = 32, + + /* Use only the part of the kernel that overlaps the image. For integer kernels, + real_divisor = divisor * (sum of used kernel elements) / (sum of kernel elements). + This should preserve image brightness at the edges. Convolution only. */ + kvImageTruncateKernel = 64, + + /* The function will return the number of bytes required for the temp buffer. + If this value is negative, it is an error, per standard usage. */ + kvImageGetTempBufferSize = 128, + + /* Some functions such as vImageConverter_CreateWithCGImageFormat have so many possible error conditions + that developers may need more help than a simple error code to diagnose problems. When this + flag is set and an error is encountered, an informative error message will be logged to the Apple + System Logger (ASL). The output should be visible in Console.app. */ + kvImagePrintDiagnosticsToConsole = 256, + + /* Pass this flag to prevent vImage from allocating additional storage. */ + kvImageNoAllocate = 512, + + /* Use methods that are HDR-aware, capable of providing correct results for input images with pixel values + outside the otherwise limited (typically [-2,2]) range. This may be slower. */ + kvImageHDRContent = 1024 +} + + +#[repr(C)] +pub struct vImage_Buffer { + pub data: T, + pub height: vImagePixelCount, + pub width: vImagePixelCount, + pub rowBytes: usize, +} + diff --git a/src/image.rs b/src/image.rs new file mode 100644 index 0000000..32082f2 --- /dev/null +++ b/src/image.rs @@ -0,0 +1,296 @@ +#![allow(dead_code)] + +use std; +use rgb::*; +use imgref::*; + +/// RGBA, but: premultiplied alpha, linear, f32 unit +pub type RGBAPLU = RGBA; +pub type RGBLU = RGB; + +#[derive(Debug, Copy, Clone)] +pub struct LAB { + pub l: f32, + pub a: f32, + pub b: f32, +} + +impl std::ops::Mul for LAB { + type Output = LAB; + fn mul(self, other: LAB) -> Self::Output { + LAB { + l: self.l * other.l, + a: self.a * other.a, + b: self.b * other.b, + } + } +} + +impl std::ops::Mul for f32 { + type Output = LAB; + fn mul(self, other: LAB) -> Self::Output { + LAB { + l: self * other.l, + a: self * other.a, + b: self * other.b, + } + } +} + +impl std::ops::Mul for LAB { + type Output = LAB; + fn mul(self, other: f32) -> Self::Output { + LAB { + l: self.l * other, + a: self.a * other, + b: self.b * other, + } + } +} + +impl std::ops::Add for LAB { + type Output = LAB; + fn add(self, other: Self::Output) -> Self::Output { + LAB { + l: self.l + other.l, + a: self.a + other.a, + b: self.b + other.b, + } + } +} + +impl std::ops::Add for LAB { + type Output = LAB; + fn add(self, other: f32) -> Self::Output { + LAB { + l: self.l + other, + a: self.a + other, + b: self.b + other, + } + } +} + +impl std::ops::Sub for LAB { + type Output = LAB; + fn sub(self, other: LAB) -> Self::Output { + LAB { + l: self.l - other.l, + a: self.a - other.a, + b: self.b - other.b, + } + } +} + +impl LAB { + pub fn avg(&self) -> f32 { + (self.l + self.a + self.b) / 3.0 + } +} + +impl From for f64 { + fn from(other: LAB) -> f64 { + other.avg() as f64 + } +} + +impl From for f32 { + fn from(other: LAB) -> f32 { + other.avg() + } +} + +impl std::ops::Div for LAB { + type Output = LAB; + fn div(self, other: Self::Output) -> Self::Output { + LAB { + l: self.l / other.l, + a: self.a / other.a, + b: self.b / other.b, + } + } +} + +pub trait Sum4 { + fn sum4(a: Self, b: Self, c: Self, d: Self) -> Self; +} + +impl Sum4 for f32 { + fn sum4(a: Self, b: Self, c: Self, d: Self) -> Self { + (a + b + c + d) * 0.25 + } +} + +impl Sum4 for RGBAPLU { + fn sum4(a: Self, b: Self, c: Self, d: Self) -> Self { + RGBAPLU { + r: Sum4::sum4(a.r, b.r, c.r, d.r), + g: Sum4::sum4(a.g, b.g, c.g, d.g), + b: Sum4::sum4(a.b, b.b, c.b, d.b), + a: Sum4::sum4(a.a, b.a, c.a, d.a), + } + } +} + +impl Sum4 for RGBLU { + fn sum4(a: Self, b: Self, c: Self, d: Self) -> Self { + RGBLU { + r: Sum4::sum4(a.r, b.r, c.r, d.r), + g: Sum4::sum4(a.g, b.g, c.g, d.g), + b: Sum4::sum4(a.b, b.b, c.b, d.b), + } + } +} + +pub trait ToRGB { + fn to_rgb(self, n: usize) -> RGBLU; +} + +impl ToRGB for RGBAPLU { + fn to_rgb(self, n: usize) -> RGBLU { + let mut r = self.r; + let mut g = self.g; + let mut b = self.b; + let a = self.a; + if a < 255.0 { + if (n & 16) != 0 { + r += 1.0 - a; + } + if (n & 8) != 0 { + g += 1.0 - a; // assumes premultiplied alpha + } + if (n & 32) != 0 { + b += 1.0 - a; + } + } + + RGBLU { + r: r, + g: g, + b: b, + } + } +} + + +////////////////////////////// + +pub trait Downsample { + type Output; + fn downsample(&self) -> Option; +} + +impl Downsample for ImgVec where T: Sum4 + Copy { + type Output = ImgVec; + fn downsample(&self) -> Option { + self.as_ref().downsample() + } +} + +impl<'a, T> Downsample for ImgRef<'a, T> where T: Sum4 + Copy { + type Output = ImgVec; + fn downsample(&self) -> Option { + let width = self.width(); + let height = self.height(); + + if width < 8 || height < 8 { + return None; + } + + assert_eq!(width * height, self.buf.len()); + + let half_height = height / 2; + let half_width = width / 2; + + // crop odd pixels + let bitmap = &self.buf[0..width * half_height * 2]; + + let scaled:Vec<_> = bitmap.chunks(width * 2).flat_map(|pair|{ + let (top, bot) = pair.split_at(half_width * 2); + let bot = &bot[0..half_width * 2]; + + return top.chunks(2).zip(bot.chunks(2)).map(|(a,b)| Sum4::sum4(a[0], a[1], b[0], b[1])) + }).collect(); + + assert_eq!(half_width * half_height, scaled.len()); + return Some(Img::new(scaled, half_width, half_height)); + } +} + +#[allow(dead_code)] +pub fn worst(input: &[f32], width: usize, height: usize) -> ImgVec { + let half_height = height / 2; + let half_width = width / 2; + + if half_height < 4 || half_width < 4 { + return Img::new(input.iter().cloned().collect(), width, height); + } + + // crop odd pixels + let bitmap = &input[0..width * half_height * 2]; + + let scaled:Vec<_> = bitmap.chunks(width * 2).flat_map(|pair|{ + let (top, bot) = pair.split_at(half_width * 2); + let bot = &bot[0..half_width * 2]; + + return top.chunks(2).zip(bot.chunks(2)).map(|(a,b)| { + a[0].min(a[1]).min(b[0].min(b[1])) + }); + }).collect(); + + assert_eq!(half_width * half_height, scaled.len()); + Img::new(scaled, half_width, half_height) +} + +#[allow(dead_code)] +pub fn avgworst(input: &[f32], width: usize, height: usize) -> ImgVec { + let half_height = height / 2; + let half_width = width / 2; + + if half_height < 4 || half_width < 4 { + return Img::new(input.iter().cloned().collect(), width, height); + } + + // crop odd pixels + let bitmap = &input[0..width * half_height * 2]; + + let scaled:Vec<_> = bitmap.chunks(width * 2).flat_map(|pair|{ + let (top, bot) = pair.split_at(half_width * 2); + let bot = &bot[0..half_width * 2]; + + return top.chunks(2).zip(bot.chunks(2)).map(|(a,b)| { + (a[0].min(a[1]).min(b[0].min(b[1])) + ((a[0] + a[1] + b[0] + b[1]) * 0.25))*0.5 + }); + }).collect(); + + assert_eq!(half_width * half_height, scaled.len()); + Img::new(scaled, half_width, half_height) +} + +#[allow(dead_code)] +pub fn avg(input: &[f32], width: usize, height: usize) -> ImgVec { + let half_height = height / 2; + let half_width = width / 2; + + if half_height < 4 || half_width < 4 { + return Img::new( + input.iter().cloned().collect(), + width, + height, + ); + } + + // crop odd pixels + let bitmap = &input[0..width * half_height * 2]; + + let scaled:Vec<_> = bitmap.chunks(width * 2).flat_map(|pair|{ + let (top, bot) = pair.split_at(half_width * 2); + let bot = &bot[0..half_width * 2]; + + return top.chunks(2).zip(bot.chunks(2)).map(|(a,b)| { + (a[0] + a[1] + b[0] + b[1]) * 0.25 + }); + }).collect(); + + assert_eq!(half_width * half_height, scaled.len()); + Img::new(scaled, half_width, half_height) +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..dce6214 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,12 @@ +extern crate rgb; +extern crate imgref; +mod dssim; +mod image; +mod blur; +mod ffi; +mod val; +mod linear; +mod tolab; +pub use dssim::*; +pub use image::*; +pub use linear::*; diff --git a/src/linear.rs b/src/linear.rs new file mode 100644 index 0000000..7b74ecd --- /dev/null +++ b/src/linear.rs @@ -0,0 +1,129 @@ +use super::image::RGBAPLU; +use rgb::*; +extern crate lodepng; + +pub trait GammaComponent { + fn max_value() -> usize; + fn to_linear(&self, lut: &[f32]) -> f32; +} + +pub trait GammaPixel { + type Component: GammaComponent; + type Output; + + fn to_linear(&self, gamma_lut: &[f32]) -> Self::Output; + + fn make_lut() -> Vec { + (0..Self::Component::max_value() + 1) + .map(|i| to_linear(i as f32 / Self::Component::max_value() as f32)) + .collect() + } +} + +fn to_linear(s: f32) -> f32 { + if s <= 0.04045 { + s / 12.92 + } else { + ((s + 0.055) / 1.055).powf(2.4) + } +} + +pub trait ToRGBAPLU { + fn to_rgbaplu(&self) -> Vec; +} + +pub trait ToGLU { + fn to_glu(&self) -> Vec; +} + +impl GammaComponent for u8 { + fn max_value() -> usize { 255 } + fn to_linear(&self, lut: &[f32]) -> f32 { + lut[*self as usize] + } +} + +impl GammaComponent for u16 { + fn max_value() -> usize { 65535 } + fn to_linear(&self, lut: &[f32]) -> f32 { + lut[*self as usize] + } +} + +impl ToGLU for [M] where M: GammaPixel { + fn to_glu(&self) -> Vec { + let gamma_lut = M::make_lut(); + self.iter().map(|px| px.to_linear(&gamma_lut)).collect() + } +} + +impl GammaPixel for RGBA where M: Clone + Into + GammaComponent { + type Component = M; + type Output = RGBAPLU; + fn to_linear(&self, gamma_lut: &[f32]) -> RGBAPLU { + let a_unit = self.a.clone().into() / M::max_value() as f32; + RGBAPLU { + r: self.r.to_linear(gamma_lut) * a_unit, + g: self.g.to_linear(gamma_lut) * a_unit, + b: self.b.to_linear(gamma_lut) * a_unit, + a: a_unit, + } + } +} + +impl GammaPixel for RGB where M: GammaComponent { + type Component = M; + type Output = RGBAPLU; + fn to_linear(&self, gamma_lut: &[f32]) -> RGBAPLU { + RGBAPLU { + r: self.r.to_linear(gamma_lut), + g: self.g.to_linear(gamma_lut), + b: self.b.to_linear(gamma_lut), + a: 1.0, + } + } +} + +impl GammaPixel for lodepng::GreyAlpha where M: Copy + Clone + Into + GammaComponent { + type Component = M; + type Output = RGBAPLU; + fn to_linear(&self, gamma_lut: &[f32]) -> RGBAPLU { + let a_unit = self.1.clone().into() / M::max_value() as f32; + let g = self.0.to_linear(gamma_lut); + RGBAPLU { + r: g * a_unit, + g: g * a_unit, + b: g * a_unit, + a: a_unit, + } + } +} + +impl GammaPixel for M where M: GammaComponent { + type Component = M; + type Output = f32; + fn to_linear(&self, gamma_lut: &[f32]) -> f32 { + self.to_linear(gamma_lut) + } +} + +impl GammaPixel for lodepng::Grey where M: Copy + GammaComponent { + type Component = M; + type Output = RGBAPLU; + fn to_linear(&self, gamma_lut: &[f32]) -> RGBAPLU { + let g = self.0.to_linear(gamma_lut); + RGBAPLU { + r: g, + g: g, + b: g, + a: 1.0, + } + } +} + +impl

ToRGBAPLU for [P] where P: GammaPixel { + fn to_rgbaplu(&self) -> Vec { + let gamma_lut = P::make_lut(); + self.iter().map(|px| px.to_linear(&gamma_lut)).collect() + } +} diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..f4b4780 --- /dev/null +++ b/src/main.rs @@ -0,0 +1,159 @@ +/* + * © 2011-2017 Kornel Lesiński. All rights reserved. + * + * This file is part of DSSIM. + * + * DSSIM is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * DSSIM is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the license along with DSSIM. + * If not, see . + */ + +extern crate getopts; +extern crate lodepng; +extern crate dssim; +extern crate imgref; +extern crate rgb; + +use std::env; +use std::path::{Path, PathBuf}; +use getopts::Options; +use dssim::*; +use imgref::*; + +fn usage(argv0: &str) { + eprintln!("\ + Usage: {} original.png modified.png [modified.png...]\ + \n or: {} -o difference.png original.png modified.png\n\n\ + Compares first image against subsequent images, and outputs\n\ + 1/SSIM-1 difference for each of them in order (0 = identical).\n\n\ + Images must have identical size, but may have different gamma & depth.\n\ + \nVersion {} https://kornel.ski/dssim\n", argv0, argv0, env!("CARGO_PKG_VERSION")); +} + +fn to_byte(i: f32) -> u8 { + if i <= 0.0 {0} + else if i >= 255.0/256.0 {255} + else {(i * 256.0) as u8} +} + +fn load>(path: P) -> Result, lodepng::Error> { + let image = lodepng::decode32_file(path.as_ref())?; + Ok(Img::new(image.buffer.to_rgbaplu(), image.width, image.height)) +} + +fn main() { + let args: Vec = env::args().collect(); + let (program, rest_args) = args.split_at(1); + + let mut opts = Options::new(); + opts.optopt("o", "", "set output file name", "NAME"); + opts.optflag("h", "help", "print this help menu"); + let matches = match opts.parse(rest_args) { + Ok(m) => m, + Err(err) => { + eprintln!("{}", err); + std::process::exit(1); + }, + }; + + if matches.opt_present("h") { + usage(&program[0]); + return; + } + + let map_output_file_tmp = matches.opt_str("o"); + let map_output_file = map_output_file_tmp.as_ref(); + let mut files: Vec = matches.free.iter().map(|p| p.into()).collect(); + + if files.len() < 2 { + eprintln!("You must specify at least 2 files to compare\n"); + usage(&program[0]); + std::process::exit(1); + } + + let file1 = files.remove(0); + + let orig_rgba = match load(&file1) { + Ok(image) => image, + Err(err) => { + eprintln!("Can't read {}: {}", file1.display(), err); + std::process::exit(1); + }, + }; + + let mut attr = dssim::Dssim::new(); + let original = attr.create_image(&orig_rgba).expect("orig image creation"); + + for file2 in files { + + let mod_rgba = match load(&file2) { + Ok(image) => image, + Err(err) => { + eprintln!("Can't read {}: {}", file2.display(), err); + std::process::exit(1); + }, + }; + + if orig_rgba.width() != mod_rgba.width() || orig_rgba.height() != mod_rgba.height() { + eprintln!("Image {} has a different size ({}x{}) than {} ({}x{})\n", + file2.display(), mod_rgba.width(), mod_rgba.height(), + file1.display(), orig_rgba.width(), orig_rgba.height()); + std::process::exit(1); + } + + let modified = attr.create_image(&mod_rgba).expect("mod image creation"); + + if map_output_file.is_some() { + attr.set_save_ssim_maps(8); + } + + let (dssim, ssim_maps) = attr.compare(&original, modified); + + println!("{:.6}\t{}", dssim, file2.display()); + + if map_output_file.is_some() { + for (n, map_meta) in ssim_maps.iter().enumerate() { + let avgssim = map_meta.ssim as f32; + let out: Vec<_> = map_meta.data().expect("map should have data").iter().map(|ssim|{ + let max = 1_f32 - ssim; + let maxsq = max * max; + rgb::RGBA8 { + r: to_byte(maxsq * 16.0), + g: to_byte(max * 3.0), + b: to_byte(max / ((1_f32 - avgssim) * 4_f32)), + a: 255, + } + }).collect(); + let write_res = lodepng::encode32_file(format!("{}-{}.png", map_output_file.unwrap(), n), &out, map_meta.width as usize, map_meta.height as usize); + if write_res.is_err() { + eprintln!("Can't write {}: {:?}", map_output_file.unwrap(), write_res); + std::process::exit(1); + } + } + } + } +} + +#[test] +fn image_gray() { + let mut attr = dssim::Dssim::new(); + + let g1 = attr.create_image(&load("tests/gray1-rgba.png").unwrap()).unwrap(); + let g2 = attr.create_image(&load("tests/gray1-pal.png").unwrap()).unwrap(); + let g3 = attr.create_image(&load("tests/gray1-gray.png").unwrap()).unwrap(); + + let (diff, _) = attr.compare(&g1, g2); + assert!(diff < 0.00001); + + let (diff, _) = attr.compare(&g1, g3); + assert!(diff < 0.00001); +} diff --git a/src/tolab.rs b/src/tolab.rs new file mode 100644 index 0000000..6247588 --- /dev/null +++ b/src/tolab.rs @@ -0,0 +1,107 @@ +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] + +pub extern crate unzip3; +use self::unzip3::Unzip3; + +use image::RGBAPLU; +use image::RGBLU; +use image::ToRGB; +use imgref::*; + +const D65x: f64 = 0.9505; +const D65y: f64 = 1.0; +const D65z: f64 = 1.089; + +pub type GBitmap = ImgVec; + +pub trait ToLAB { + fn to_lab(&self) -> (f32, f32, f32); +} + +impl ToLAB for RGBLU { + fn to_lab(&self) -> (f32, f32, f32) { + let fx = ((self.r as f64 * 0.4124 + self.g as f64 * 0.3576 + self.b as f64 * 0.1805) / D65x) as f32; + let fy = ((self.r as f64 * 0.2126 + self.g as f64 * 0.7152 + self.b as f64 * 0.0722) / D65y) as f32; + let fz = ((self.r as f64 * 0.0193 + self.g as f64 * 0.1192 + self.b as f64 * 0.9505) / D65z) as f32; + + let epsilon: f32 = 216. / 24389.; + let k = ((24389. / 27.) / 116.) as f32; // http://www.brucelindbloom.com/LContinuity.html + let X = if fx > epsilon {fx.powf(1./3.) - 16./116.} else {k * fx}; + let Y = if fy > epsilon {fy.powf(1./3.) - 16./116.} else {k * fy}; + let Z = if fz > epsilon {fz.powf(1./3.) - 16./116.} else {k * fz}; + + return ( + Y * 1.16, + (86.2/ 220.0 + 500.0/ 220.0 * (X - Y)), /* 86 is a fudge to make the value positive */ + (107.9/ 220.0 + 200.0/ 220.0 * (Y - Z)), /* 107 is a fudge to make the value positive */ + ); + } +} + +pub trait ToLABBitmap { + fn to_lab(&self) -> Vec; +} + +impl ToLABBitmap for ImgVec { + fn to_lab(&self) -> Vec { + self.as_ref().to_lab() + } +} + +impl ToLABBitmap for ImgVec { + fn to_lab(&self) -> Vec { + vec![ + Img::new( + self.buf.iter().cloned().map(|fy| { + let epsilon: f32 = 216. / 24389.; + // http://www.brucelindbloom.com/LContinuity.html + let Y = if fy > epsilon { fy.powf(1. / 3.) - 16. / 116. } else { ((24389. / 27.) / 116.) * fy }; + + return Y * 1.16; + }).collect(), + self.width(), + self.height(), + ) + ] + } +} + +impl<'a> ToLABBitmap for ImgRef<'a, RGBAPLU> { + fn to_lab(&self) -> Vec { + let width = self.width(); + let height = self.height(); + let mut x=11; // offset so that block-based compressors don't align + let mut y=11; + + let (l,a,b) = self.buf.iter().map(|px|{ + let n = x ^ y; + if x >= width { + x=0; + y+=1; + } + x += 1; + px.to_rgb(n).to_lab() + }).unzip3(); + + return vec![ + Img::new(l, width, height), + Img::new(a, width, height), + Img::new(b, width, height), + ]; + } +} + +impl<'a> ToLABBitmap for ImgRef<'a, RGBLU> { + fn to_lab(&self) -> Vec { + let width = self.width(); + let height = self.height(); + let (l, a, b) = self.buf.iter().map(|px| px.to_lab()).unzip3(); + + return vec![ + Img::new(l, width, height), + Img::new(a, width, height), + Img::new(b, width, height), + ]; + } +} diff --git a/src/val.rs b/src/val.rs new file mode 100644 index 0000000..815fa6e --- /dev/null +++ b/src/val.rs @@ -0,0 +1,148 @@ +#![allow(dead_code)] + +use ::std::fmt; +use ::std::cmp::Ordering; +use ::std::ops::Sub; +use ::std::ops::Add; +use ::std::ops::Mul; +use ::std::ops::Div; + +#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)] +pub struct Dssim(f64); + +impl Dssim { + pub fn new(v: f64) -> Dssim { + debug_assert!(v.is_finite()); + Dssim(v) + } +} + +impl fmt::Display for Dssim { + fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> { + write!(fmt, "{:.6}", self.0) + } +} + +impl Eq for Dssim { + // Result never has NaN +} + +impl PartialEq for f64 { + fn eq(&self, other: &Dssim) -> bool { + *self == other.0 + } + + fn ne(&self, other: &Dssim) -> bool { + *self != other.0 + } +} + +impl PartialEq for Dssim { + fn eq(&self, other: &f64) -> bool { + self.0 == *other + } + + fn ne(&self, other: &f64) -> bool { + self.0 != *other + } +} + +impl From for f64 { + fn from(s: Dssim) -> f64 { + s.0 + } +} + +impl From for Dssim { + fn from(s: f64) -> Dssim { + Dssim(s) + } +} + +impl> Sub for Dssim { + type Output = f64; + fn sub(self, r: RHS) -> Self::Output { + let rval = r.into(); + debug_assert!(rval.is_finite()); + self.0.sub(rval) + } +} + + +impl Sub for f64 { + type Output = f64; + fn sub(self, r: Dssim) -> Self::Output { + self.sub(r.0) + } +} + +impl> Add for Dssim { + type Output = f64; + fn add(self, r: RHS) -> Self::Output { + let rval = r.into(); + debug_assert!(rval.is_finite()); + self.0.add(rval) + } +} + +impl Add for f64 { + type Output = f64; + fn add(self, r: Dssim) -> Self::Output { + self.add(r.0) + } +} + +impl> Mul for Dssim { + type Output = Dssim; + fn mul(self, r: RHS) -> Self::Output { + let rval = r.into(); + debug_assert!(rval.is_finite()); + self.0.mul(rval).into() + } +} + +impl Mul for f64 { + type Output = Dssim; + fn mul(self, r: Dssim) -> Self::Output { + self.mul(r.0).into() + } +} + +impl> Div for Dssim { + type Output = f64; + fn div(self, r: RHS) -> Self::Output { + let rval = r.into(); + debug_assert!(rval.is_finite() && rval != 0.); + self.0.div(rval) + } +} + +impl Div for f64 { + type Output = f64; + fn div(self, r: Dssim) -> Self::Output { + debug_assert!(r.0 != 0.); + self.div(r.0) + } +} + +impl PartialOrd for Dssim { + fn partial_cmp(&self, other: &f64) -> Option { + self.0.partial_cmp(other) + } + + fn lt(&self, other: &f64) -> bool { self.0.lt(other) } + fn le(&self, other: &f64) -> bool { self.0.le(other) } + fn gt(&self, other: &f64) -> bool { self.0.gt(other) } + fn ge(&self, other: &f64) -> bool { self.0.ge(other) } +} + +impl PartialOrd for f64 { + fn partial_cmp(&self, other: &Dssim) -> Option { + self.partial_cmp(&other.0) + } + + fn lt(&self, other: &Dssim) -> bool { self.lt(&other.0) } + fn le(&self, other: &Dssim) -> bool { self.le(&other.0) } + fn gt(&self, other: &Dssim) -> bool { self.gt(&other.0) } + fn ge(&self, other: &Dssim) -> bool { self.ge(&other.0) } +} diff --git a/tests/gray-profile.png b/tests/gray-profile.png new file mode 100644 index 0000000000000000000000000000000000000000..03fa07d7be768bdd01d61030697c6706bf437002 GIT binary patch literal 15871 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 literal 0 HcmV?d00001 diff --git a/tests/gray1-pal.png b/tests/gray1-pal.png new file mode 100644 index 0000000000000000000000000000000000000000..172b0f3e1076a1c0d7d403b4c8e97f3e63cc99da GIT binary patch literal 1165 zcmV;81akX{P)qKR-W2L_{(&GBYzXJv}{2N=ipZM>se*K0ZD{K|w%3Ktn@AIyyQuG&DOq zJ4s1NMMXtMMn)hYATcp9LPA1IOG{2pPA@MnP*6}jJUmiTQYI!QAt50(H8mE8X6i^RaI72Rw*edC@3f}Ffbw_A}lN{O-)T4 z92{6!SO5S3TU%Qj8yg-T9vK-K7#J8)QBfBc7g}0cD=RBmSy>DW3=j|y9UUEWb8{6H z6=P##Q&UrAWo1rJPkMTKS65duGc#adU~+PDMn^|BH#eJ`n-dcgM@UF&YHDw9Zzw4# z78Vv16ckZXQXd~5g@uIz0s=QUIB98VUteE{h=^xrXFEJR($dnUrKQo)(Qt5ZUtnN3 zIXU9u;$&rIXlZF5ARuXKY9JvYU0q#0K0e>y-%3kMZf2FW|BrdXhmw3f*i4vh1XqbEv7()t-X0 zgbFBQBDEQ!6jHCp)K3k`eknz+fmPL}W`Nin5lsazqtKHvqdLichaF}swzhN=!}LWua}!IBrPu>w?(BsYqOAMc8SB4ABK&$&AgDxt;<_{^nXi83>h zKy;l@O{Q%z4M zVDo@a32&kHt8ANF0k_s~y?q}wCi*oHW)U?)QS;a@n$Y(f$Kh>tr`8(y zgOkmEd#7ay%dcj4X5V}ZVfdg>zl*+K2II56`ol@m+{5^2RvT;&>LBWqX|QhlODxW< z{+@-8h-_{8jh#Wc4dYF&V3z${SHvypSGig2&9{D=K03H_1S3GWgw=eudJN+%-bE}Q)t*+~9RQeY#RmZ0{ f{==bJM>FMrn*?Ej&#?}500000NkvXXu0mjfu8Y?F literal 0 HcmV?d00001 diff --git a/tests/gray1-rgba.png b/tests/gray1-rgba.png new file mode 100644 index 0000000000000000000000000000000000000000..93667aa6665c73ad6ad28ec3b8feb74ed25006b4 GIT binary patch literal 2232 zcmY*a3pmqlAO3G4mR)(JoSEfZw%H<zH1?slLANd#>v_{r>lJ-_QMf{@3$da&@+YLewAt06>ZMwr-MM zW4+4CNLmK;O*#O8Y-t37E0I8exiaX%wBtblV0h&yiR4DyY1l?qB$3*l?=XTeqTCV^ zlHEu#LSYxI2___U!m_gb{okr6ynPHvq13iU*S82|3z1W?oz3a3o9?^0C8crav|%X+ z5QfHN5-AxZ$mlo#u@TF_{B(`fJM+O5Wss(9U=>i^t0Tsd%oG-+`8hlo6}BSBo94wm zakirnrlmnwD7;o2b4#!LKbsuT%=y&6nWh>Lh%##p{v_)uXCRBqrO7!~=++iW+3xwM z?6EDVgqm(>0VWuDHeryyE_O|A!tP`iMpfmjvMI_ZS~}6iCPD9cAZg%ryAXC_lTL|% z!{s){bIC)?<2{AwGUXebrCnph4}twejltnJQsR9Zik+0KL!42m{QU72H6N`N^ZJ6s zTIN_qj#>6fC{p_zZFbEX0A+-TR&}6plC;W2*!wa8VAGcM3IcNSR3u6ErFrc1j2(77oQY-Q;6D&p$#^}Cgu{M7SfMz$kCQ8m zKxYKO%n-W}C^#MhgTbsAfx%ce+x@?mOJ+FuF%~NVi$q36MIoXv2s(p`G_|y}M5540 zG}=UhFkzkwXOY<^;mqwnN&drQ8^k=yphd7~^l;cZFPTD*WZ~fOb)nzo=RR4q;QuOx zGk@8V7(}jrL7E~^$lu(OrB>@vtP6t{BvD@H$D3OHK>lCsmyQ*3UHpGG^V8{%sKhEB zVuk#jHax_!*}xY7q-%+`dp+!-xc<6uB|in3w;0@5#?xR-E-+L9meb`W$lebO)Romm zAK@z7jGD5cfpUK+@_fLGsMw@r-%bj@8Z`D#zxOcV01kKd!DLnAYPtK!?WtE)^v3w~Dg6iroi&zVbtTp9r+Z^Zt0TUB52n+@jG}V8*xU{tN`}gIV&gaiFDl01m zM_W_AzVEm?_wm)xkYDE2s~uGVjXevCpWhTCQ8|MVv#zj>MGgghAsO1%=hC@cZcie0 z<{Efmaq%ksO@m%rd%HvS$|~*^iNCD1sHmc)YLvU1?kwMw+pu=t%qgvjKhPKxv;1v7 z^ono&h%-1TDM^)s2@(9k@1005E-pqZ=zPoIwZsz{EoWp@C><6R@a0DAb#iUiO zj@Sc1Er37y>ye7^IUP0g^Yij|Bw2ar?Y0vk7LIrd-2pLLiJrN&k6IB|Ay=5TqzP7$nh^_a0bdQkD7CP*0}H)_-x z%(1G<2HR%B^X(uvf!M!w-p`EGr;#+XFI;;4sp4XFXWKsT;i*L6lvt;;S{HdKFCn!r z$Gt>tdTyfEk~`orh@);U^1ZCB-e4e~Yz*Cwu}i6j>2A>U(Q_(b&y;(mK$fgZy2n~C z*VHW?jMI)+2(g>Aq#47^Ih_t`W`B-cHgL&z)EkgVlE0uqIyqVCW$Gw6-`d*B9BoUc z)IFN?;AyI&Km(dU7Wqj1*TEX9DnIxWv`{H0&P`MoIpx(*-qO<2K6H=X@v_J+jsNX& zh|)*{kw=2q2;cj-zrfBD#~Q!2N1MdLC}+1TRlgBMv)N0ZyJs``BT}gfxeKo!ouM-; zd__CJ!pRGIex60)#}~yK30Cacf;{UO{2p&j=`>aKA^Y=pyRPlIN{>#`f5;i=_CH)+ zfxcIwHJ%Suhd$n4zvJRsgs3MH{aV+45FWXaB}%rYr_0uv+qBWP9ZvzWzoj4(iHp1mxeSC?P zdV;Q0?B#Js!~U(4yAmz2*hBw1QFK8l0u+2}YMO~Mu~aAlN*b5`kWJj~=Ri}s<~LP- z;0)pBQ^SDAS60mhCA_AL9p3FCkq5e;tI_BAWwV9_FE!P3da3MX#PN*|LIM!{H2Bso zC7NB$u(_tAe3DPT#R>S}nfjq_n_F{VpdQZGuo+HX0Y`<)a*jt5mnmEB&%CIizW9(^ zsx$IstQGU1>)XekVzD7(d9Fi8VWb3s-%Nyv=ciu97$k^U`W2FEC79H7C6w27Q-vrh{rB+=*TT7Xhfv4$e6A%Jn?RE#Tnz!{}wksij$Re$>qHv(GP97C%#i z!Kal4QQuc4`>yXTB;Gh2N;yg9+r@Yz+15 gzKTHmm9lS}%Qj@cORXCkSbqzN`Px# literal 0 HcmV?d00001 diff --git a/tests/gray1.jpg b/tests/gray1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3af9b3473f107acb096bf2c0c729553b42cbdb32 GIT binary patch literal 989 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 AS^xk5 literal 0 HcmV?d00001 diff --git a/tests/profile.png b/tests/profile.png new file mode 100644 index 0000000000000000000000000000000000000000..1af6a6dc5b822acd91ee65a538e03bb13865a4cb GIT binary patch literal 9196 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 iyFYPm$ppM~rwy=-$gScm3JNf9636>Af08^<{ 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%0Dvyi^CV;m5o=FXmWm!4; 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 literal 0 HcmV?d00001