2012-04-04 21:54:07 +00:00
|
|
|
# -*- coding: utf-8 -*-
|
|
|
|
|
2014-04-01 04:15:35 +00:00
|
|
|
import os
|
2012-02-18 16:51:18 +00:00
|
|
|
import sys
|
2012-07-07 00:44:15 +00:00
|
|
|
import mapnik
|
2014-09-06 23:04:01 +00:00
|
|
|
import platform
|
2012-02-18 16:51:18 +00:00
|
|
|
|
2012-11-20 23:08:53 +00:00
|
|
|
try:
|
|
|
|
import json
|
|
|
|
except ImportError:
|
|
|
|
import simplejson as json
|
|
|
|
|
2012-02-18 16:51:18 +00:00
|
|
|
COMPUTE_THRESHOLD = 16
|
|
|
|
|
2014-04-01 04:15:35 +00:00
|
|
|
# testcase images are generated on OS X
|
|
|
|
# so they should exactly match
|
2014-09-06 23:04:01 +00:00
|
|
|
if platform.uname()[0] == 'Darwin':
|
2014-04-02 01:15:31 +00:00
|
|
|
COMPUTE_THRESHOLD = 2
|
2014-04-01 04:15:35 +00:00
|
|
|
|
2012-02-18 16:51:18 +00:00
|
|
|
# returns true if pixels are not identical
|
2012-11-20 23:08:53 +00:00
|
|
|
def compare_pixels(pixel1, pixel2, alpha=True):
|
2012-07-07 00:44:15 +00:00
|
|
|
if pixel1 == pixel2:
|
|
|
|
return False
|
|
|
|
r_diff = abs((pixel1 & 0xff) - (pixel2 & 0xff))
|
|
|
|
g_diff = abs(((pixel1 >> 8) & 0xff) - ((pixel2 >> 8) & 0xff))
|
|
|
|
b_diff = abs(((pixel1 >> 16) & 0xff)- ((pixel2 >> 16) & 0xff))
|
2012-11-20 23:08:53 +00:00
|
|
|
if alpha:
|
|
|
|
a_diff = abs(((pixel1 >> 24) & 0xff) - ((pixel2 >> 24) & 0xff))
|
|
|
|
if(r_diff > COMPUTE_THRESHOLD or
|
|
|
|
g_diff > COMPUTE_THRESHOLD or
|
|
|
|
b_diff > COMPUTE_THRESHOLD or
|
|
|
|
a_diff > COMPUTE_THRESHOLD):
|
|
|
|
return True
|
2012-02-18 16:51:18 +00:00
|
|
|
else:
|
2012-11-20 23:08:53 +00:00
|
|
|
if(r_diff > COMPUTE_THRESHOLD or
|
|
|
|
g_diff > COMPUTE_THRESHOLD or
|
|
|
|
b_diff > COMPUTE_THRESHOLD):
|
|
|
|
return True
|
|
|
|
return False
|
2012-02-18 16:51:18 +00:00
|
|
|
|
2012-07-07 00:44:15 +00:00
|
|
|
# compare two images and return number of different pixels
|
2013-03-25 02:56:14 +00:00
|
|
|
def compare(actual, expected, alpha=True):
|
2012-07-07 00:44:15 +00:00
|
|
|
im1 = mapnik.Image.open(actual)
|
2014-10-01 00:41:31 +00:00
|
|
|
im2 = mapnik.Image.open(expected)
|
2012-02-18 16:51:18 +00:00
|
|
|
diff = 0
|
2012-07-07 00:44:15 +00:00
|
|
|
pixels = im1.width() * im1.height()
|
|
|
|
delta_pixels = (im2.width() * im2.height()) - pixels
|
2012-03-08 17:29:46 +00:00
|
|
|
if delta_pixels != 0:
|
|
|
|
return delta_pixels
|
2012-07-07 00:44:15 +00:00
|
|
|
for x in range(0,im1.width(),2):
|
|
|
|
for y in range(0,im1.height(),2):
|
2012-11-20 23:08:53 +00:00
|
|
|
if compare_pixels(im1.get_pixel(x,y),im2.get_pixel(x,y),alpha=alpha):
|
2012-07-07 00:44:15 +00:00
|
|
|
diff += 1
|
2012-02-18 16:51:18 +00:00
|
|
|
return diff
|
|
|
|
|
2012-11-20 23:08:53 +00:00
|
|
|
def compare_grids(actual, expected, threshold=0, alpha=True):
|
|
|
|
global errors
|
|
|
|
global passed
|
|
|
|
im1 = json.loads(open(actual).read())
|
2014-10-01 00:41:31 +00:00
|
|
|
im2 = json.loads(open(expected).read())
|
2012-11-20 23:08:53 +00:00
|
|
|
# TODO - real diffing
|
2014-10-01 00:41:31 +00:00
|
|
|
if not im1['data'] == im2['data']:
|
2013-03-25 02:56:14 +00:00
|
|
|
return 99999999
|
2014-10-01 00:41:31 +00:00
|
|
|
if not im1['keys'] == im2['keys']:
|
|
|
|
return 99999999
|
|
|
|
grid1 = im1['grid']
|
|
|
|
grid2 = im2['grid']
|
|
|
|
# dimensions must be exact
|
|
|
|
width1 = len(grid1[0])
|
|
|
|
width2 = len(grid2[0])
|
|
|
|
if not width1 == width2:
|
|
|
|
return 99999999
|
|
|
|
height1 = len(grid1)
|
|
|
|
height2 = len(grid2)
|
|
|
|
if not height1 == height2:
|
|
|
|
return 99999999
|
|
|
|
diff = 0;
|
|
|
|
for y in range(0,height1-1):
|
|
|
|
row1 = grid1[y]
|
|
|
|
row2 = grid2[y]
|
|
|
|
width = min(len(row1),len(row2))
|
|
|
|
for w in range(0,width):
|
|
|
|
if row1[w] != row2[w]:
|
|
|
|
diff += 1
|
|
|
|
return diff
|