Percentage difference between images: Difference between revisions

=={{header|Ada}}==

[[wp:Distance|1-norm distance]] in the luminance space:

begin

if Left > Right then

return Count (Right) - Count (Left);

end if;

1-norm distance in the color space multiplied to 3:

begin

return (Left.R - Right.R) + (Left.G - Left.G) + (Left.B - Right.B);

Mean of 1-norm distances. Constraint_Error is propagated when images have different size.

Offs_I : constant Integer := Right'First (1) - Left'First (1);

Offs_J : constant Integer := Right'First (2) - Left'First (2);

end loop;

return Float (Sum) / (3.0 * Float (Left'Length (1) * Left'Length (2)));

Example of use:

begin

Open (F1, In_File, "city.ppm");

Ada.Text_IO.Put_Line ("Diff" & Float'Image (Diff (Get_PPM (F1), Get_PPM (F2))));

Close (F1);

=={{header|AutoHotkey}}==

{{works with | AutoHotkey_L}}

uses [http://www.autohotkey.com/forum/topic32238.html gdip.ahk]

dibSection := getPixels("lenna100.jpg")

dibSection2 := getPixels("lenna50.jpg") ; ("File-Lenna100.jpg")

}

#Include Gdip.ahk ; Thanks to tic (Tariq Porter) for his GDI+ Library

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

I would have preferred to calculate the RMS difference but it would be inconsistent with other results.

hbm2% = FNloadimage("C:lenna100.jpg")

SYS !(!pic%+12), pic%, ^hbm% : REM. IPicture::get_Handle

SYS "FreeLibrary", ole%

'''Output:'''

<pre>

The <tt>read_image</tt> function is from [[Read image file through a pipe|here]].

#include <stdlib.h>

#include <math.h>

free_img(im1);

free_img(im2);

The output on Lenna is:

=={{header|C sharp|C#}}==

using System.Drawing;

Console.WriteLine("diff: {0} %", 100 * (diff / 255) / (img1.Width * img1.Height * 3));

}

=={{header|C++}}==

based upon C version, using Qt 4.4

#include <cstdlib>

#include <QColor>

(totaldiff * 100) / (w * h * 3) << " % !\n" ;

return 0 ;

output on pictures given;

This is based upon the C version. Strangely enough, the percentage is 1.77% which is off by about a tenth of a percent.

;;; the JPEG library uses simple-vectors to store data. this is insane!

(defun compare-images (file1 file2)

CL-USER> (* 100 (compare-images "Lenna50.jpg" "Lenna100.jpg"))

=={{header|D}}==

{{trans|Python}}

void main() {

writeln("Difference (percentage): ",

(dif / 255.0 * 100) / nData);

{{out}}

<pre>Difference (percentage): 1.62559</pre>

By dividing only at the end, we work with integers only as the sum and avoid floating-point error from adding small numbers (per-pixel difference) to large ones (sum of differences).

require(a.width() == b.width())

require(a.height() == b.height())

def d := imageDifference(a, b)

println(`${d * 100}% different.`)

The result on the provided images is 1.6255930981604882%.

=={{header|F_Sharp|F#}}==

//Percentage difference between 2 images. Nigel Galloway April 18th., 2018

let img50 = new System.Drawing.Bitmap("Lenna50.jpg")

let img100 = new System.Drawing.Bitmap("Lenna100.jpg")

let diff=Seq.cast<System.Drawing.Color*System.Drawing.Color>(Array2D.init img50.Width img50.Height (fun n g->(img50.GetPixel(n,g),img100.GetPixel(n,g))))|>Seq.fold(fun i (e,l)->i+abs(int(e.R)-int(l.R))+abs(int(e.B)-int(l.B))+abs(int(e.G)-int(l.G))) 0

{{out}}

<pre>

=={{header|Forth}}==

over 255 and over 255 and - abs >r 8 rshift swap 8 rshift

over 255 and over 255 and - abs >r 8 rshift swap 8 rshift

: .bdiff ( bmp1 bmp2 -- )

=={{header|Fortran}}==

use RCImageBasic

call free_img(lenna2)

This gives 1.6555154.

=={{header|Frink}}==

img1 = new image["file:Lenna50.jpg"]

img2 = new image["file:Lenna100.jpg"]

errors = sum / (w1 * h1 * 3)

println["Error is " + (errors->"percent")]

This gives an error of approximately 1.625593 percent.

=={{header|Go}}==

Using standard image library:

import (

fmt.Printf("Image difference: %f%%\n",

float64(sum*100)/(float64(nPixels)*0xffff*3))

Output:

<pre>

</pre>

Using code from bitmap task:

// Files required to build supporting package raster are found in:

fmt.Printf("Image difference: %f%%\n",

float64(sum)*100/(float64(b1c*b1r)*255*3))

Output:

<pre>

This implementation takes PPMs as input. It uses modules defined in [[Basic bitmap storage]] and [[Write ppm file]].

import Bitmap.Netpbm

import Bitmap.RGB

toEnum (3 * 255 * length i1)

where (RGB (r1, g1, b1)) `minus` (RGB (r2, g2, b2)) =

=={{header|Icon}} and {{header|Unicon}}==

The Icon and Unicon graphics facilities are under documented with respect to some features. Unicon can support reading and writing to a number of additional image formats. I'm not sure if this will run under Icon or not. Some minor reworking of the open would be the minimum requirement; however, Icon may not have read support for jpg files.

procedure main() # % difference between images

}

return L

Output:<pre>%difference of files "Lenna100.jpg" & "Lenna50.jpg" = 1.625587</pre>

=={{header|J}}==

'Lenna50.jpg' (+/@,@:|@:- % 2.55 * */@$@])&read_image 'Lenna100.jpg'

=={{header|Java}}==

import java.io.File;

import java.io.IOException;

return Math.abs(r1 - r2) + Math.abs(g1 - g2) + Math.abs(b1 - b2);

}

=={{header|JavaScript}}==

var img = document.createElement('img');

var canvas = document.createElement('canvas');

compare('Lenna50.jpg', 'Lenna100.jpg', function (result) {

console.log(result);

=={{header|Julia}}==

absdiff(a::RGB{T}, b::RGB{T}) where T = sum(abs(col(a) - col(b)) for col in (red, green, blue))

d = pctdiff(img50, img100)

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

import java.awt.image.BufferedImage

val p = getDifferencePercent(img1, img2)

println("The percentage difference is ${"%.6f".format(p)}%")

{{out}}

=={{header|Lua}}==

Using the Bitmap class from [[Bitmap/Bresenham%27s_line_algorithm#Lua|here]] and ImageMagick to preprocess jpg->ppm to simplify loading:

local fp = io.open( filename, "rb" )

if fp == nil then return false end

bm100:loadPPM("Lenna100.ppm")

{{out}}

<pre>%diff: 1.6255930981605</pre>

LB uses here a DLL to allow loading the jpgs. I get the 'other' result if I use LB's native bmp load and convert the jpgs to bmp with the Gimp!

The GUI shows the 'difference image'. [http://www.diga.me.uk/right.gif SceenDisplay]

now =time$( "seconds")

nomainwin

close #j

end

=={{header|Mathematica}}/{{header|Wolfram Language}}==

img100 = ImageData@Import[NotebookDirectory[] <> "Lenna100.jpg"];

diff = img50 - img100;

Print["Total Difference between both Lenas = ",

'''Output'''

=={{header|MATLAB}}==

% Percentage difference between images

function p = PercentageDifferenceBetweenImages(im1,im2)

p = sum(d(:))./numel(im1)*100;

'''Output'''

=={{header|MAXScript}}==

(

local img1 = selectBitmap caption:"Select Image 1"

)

format "Diff: %\%\n" (totalDiff / ((img1.width * img1.height * 3) as float) * 100)

=={{header|Nim}}==

{{libheader|imageman}}

We use the procedure <code>loadImage</code> which sets default values for JPEG decoding parameters. With these parameters, the difference between the images is about 1.7747 %. Using the less convenient procedure <code>readImage</code> which works on an open file, it is possible to change the parameters in order to get the smaller difference of 1.6256 %.

import imageman

sum += abs(color1[i].int - color2[i].int)

{{out}}

{{libheader|glMLite}}

#directory "+glMLite/"

#load "jpeg_loader.cma"

let diff_percent = !sum /. float !num in

Printf.printf " diff: %f percent\n" diff_percent;

=={{header|Perl}}==

my $img1 = Image::Imlib2->load('Lenna50.jpg') || die;

}

{{out}}

<pre>% difference = 1.7747</pre>

Alternative solution:

use List::AllUtils qw(sum pairwise);

}

{{out}}

<pre>

=={{header|Phix}}==

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Percentage_difference_between_images.exw</span>

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (file i/o)</span>

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

=={{header|PicoLisp}}==

(call "convert" "Lenna100.jpg" (tmp "Lenna100.ppm"))

255 ) )

(inc 'Total) ) ) )

Output:

<pre>Difference is 1.6256 percent</pre>

=={{header|PureBasic}}==

This program downloads both jpg files, decodes them & saves them in 2D-arrays for simple comparison which part is comparable with the other languages.

#URL2="http://rosettacode.org/mw/images/b/b6/Lenna100.jpg"

Next x

=={{header|Python}}==

{{works with|python version 3.x}}

i1 = Image.open("image1.jpg")

ncomponents = i1.size[0] * i1.size[1] * 3

{{works with|python version 2.x}}

import Image

ncomponents = i1.size[0] * i1.size[1] * 3

=={{header|Racket}}==

Note: On OS X I get 1.6192% as the result. (soegaard)

(require racket/draw)

(define lenna100 (read-bitmap "lenna100.jpg"))

=={{header|Raku}}==

Using [https://modules.raku.org/search/?q=GD%3A%3ARaw GD::Raw from the Raku ecosystem].

my $fh1 = fopen('./Lenna50.jpg', "rb") or die;

gdImageDestroy($img1);

gdImageDestroy($img2);

{{out}}

<pre>

=={{header|REBOL}}==

Title: "Percent Image Difference"

URL: http://rosettacode.org/wiki/Percentage_of_difference_between_2_images

button "b" #"b" [flip 'b]

button "difference" #"d" [flip 'diff]

Output:

=={{header|Ruby}}==

uses the <code>[[Raster graphics operations/Ruby|raster_graphics]]</code> library

class RGBColour

lenna100 = Pixmap.open_from_jpeg('Lenna100.jpg')

produces:

=={{header|Rust}}==

use image::{GenericImageView, Rgba};

}

println!("Percent difference {}", accum as f64 * 100.0/ (255.0 * 3.0 * (img1.width() * img1.height()) as f64));

produces:

=={{header|Sidef}}==

func img_diff(a, b) {

}

{{out}}

<pre>

=={{header|Swift}}==

{

var width = 0

compareImages(image1: image1, image2: image2)

=={{header|Tcl}}==

{{libheader|Tk}}

This version uses the '''Img''' package, but only to provide a convenient JPEG loader; it's utterly unnecessary for the process of actually computing the difference.

proc imageDifference {img1 img2} {

image create photo lenna100 -file lenna100.jpg

puts "difference is [expr {[imageDifference lenna50 lenna100]*100.}]%"

It produces this output:

difference is 1.6255930981604882%

This implementation compares two BMP images.

File_Open("Lenna50.bmp", BROWSE)

#10 = Buf_Num // #10 = buffer for 1st image

Buf_Switch(#10) Buf_Quit(OK)

Output, when comparing the Lenna images that were converted to BMP:

{{trans|Kotlin}}

{{libheader|DOME}}

import "dome" for Window

}

{{out}}

=={{header|zkl}}==

Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

if(img1.w!=img2.w or img1.h!=img2.h)

throw(Exception.ValueError("width/height of the images must match!"));

.reduce(fcn(totalDiff,[(a,b)]){ totalDiff + (a - b).abs() },0)

.toFloat()/img1.w/img1.h/3/255; // or: .toFloat()/img1.data.len()/255

Take the bytes in each image, zip them together [lazily], sum the differences between each byte and normalize.

p:=System.popen("convert \"%s\" ppm:-".fmt(fileName),"r");

img:=PPM.readPPM(p);

p.close();

img

Use the convert utility from ImageMagick to convert a JPEG image to PPM.

Compute the diff between the two Lennas, format and print it. More conventionally, this would be written as

imageDiff(readJPG2PPM("lenna50.jpg"),readJPG2PPM("lenna100.jpg")) * 100)

{{out}}

<pre>