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

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:

1.625587

</pre>

 

=={{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;

The difference of the two pictures is 1.62559 % !

</pre>

 

=={{header|Common Lisp}}==

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}}

The percentage difference is 1.625593%

</pre>

 

=={{header|Liberty BASIC}}==

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

 

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|OCaml}}==

{{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>

difference = 1.625593%

</pre>

 

=={{header|Phix}}==

{{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|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:

<pre>difference: 1.62559%</pre>

 

=={{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:

Total bytes: 786432

Difference: 1.619%

</pre>

 

=={{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>