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;

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

Using standard image library:

 

import (

"image/jpeg"

"os"

)

 

if err != nil {

}

defer f.Close()

if err != nil {

}

}

if err != nil {

}

if i50.ColorModel() != i100.ColorModel() {

}

b := i50.Bounds()

if !b.Eq(i100.Bounds()) {

}

var sum int64

for y := b.Min.Y; y < b.Max.Y; y++ {

r1, g1, b1, _ := i50.At(x, y).RGBA()

r2, g2, b2, _ := i100.At(x, y).RGBA()

}

}

nPixels := (b.Max.X - b.Min.X) * (b.Max.Y - b.Min.Y)

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.IOException;

 

}

}

int r1 = (rgb1 >> 16) & 0xff;

int g1 = (rgb1 >> 8) & 0xff;

int r2 = (rgb2 >> 16) & 0xff;

int g2 = (rgb2 >> 8) & 0xff;

}

 

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

<pre>Total Difference between both Lenas = 1.62559%</pre>

 

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