nv-flip

bindings to Nvidia Labs's [ꟻLIP] image comparison and error visualization library.

This library allows you to visualize and reason about the human-noticable differences between rendered images. Especially when comparing images that are noisy or other small differences, FLIP's comparison can be more meaningful than a simple pixel-wise comparison.

comp

In order to keep a small dependency closure, this crate does not depend on image, but interop is simple.

Example

```rust // First we load the "reference image". This is the image we want to compare against. // // We make sure to turn the image into RGB8 as FLIP doesn't deal with alpha. let refimagedata = image::open("../etc/tree-ref.png").unwrap().intorgb8(); let refimage = nvflip::FlipImageRgb8::withdata( refimagedata.width(), refimagedata.height(), &refimagedata );

// We then load the "test image". This is the image we want to compare to the reference. let testimagedata = image::open("../etc/tree-test.png").unwrap().intorgb8(); let testimage = nvflip::FlipImageRgb8::withdata( testimagedata.width(), testimagedata.height(), &testimagedata );

// We now run the comparison. This will produce a "error map" that that is the per-pixel // visual difference between the two images between 0 and 1. // // The last parameter is the number of pixels per degree of visual angle. This is used // to determine the size of imperfections that can be seen. See the pixels_per_degree // for more information. By default this value is 67.0. let errormap = nvflip::flip(refimage, testimage, nvflip::DEFAULTPIXELSPERDEGREE);

// We can now visualize the error map using a LUT that maps the error value to a color. let visualized = errormap.applycolorlut(&nvflip::magma_lut());

// Finally we can the final image into an image crate image and save it. let image = image::RgbImage::fromraw( visualized.width(), visualized.height(), visualized.tovec() ).unwrap();

// We can get statistics about the error map by using their "Pool" type, // which is essentially a weighted histogram. let mut pool = nvflip::FlipPool::fromimage(&error_map);

// These are the same statistics shown by the command line. // // The paper's writers recommend that, if you are to use a single number to // represent the error, they recommend the mean. println!("Mean: {}", pool.mean()); println!("Weighted median: {}", pool.getpercentile(0.5, true)); println!("1st weighted quartile: {}", pool.getpercentile(0.25, true)); println!("3rd weighted quartile: {}", pool.getpercentile(0.75, true)); println!("Min: {}", pool.minvalue()); println!("Max: {}", pool.max_value()); ``` The result of this example looks like this:

| Reference | ⠀⠀Test⠀⠀ | ⠀Result⠀ | |:---------:|:---------:|:---------:| | comp | comp | comp |

License

The binding and rust interop code is tri-licensed under MIT, Apache-2.0, and ZLib.

The ꟻLIP library itself is licensed under the BSD-3-Clause license.

The example images used are licensed under the [Unsplash License].

License: MIT OR Apache-2.0 OR Zlib