sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of github.com:mapnik/mapnik

Browse source
This commit is contained in:
Dane Springmeyer 2013-03-25 11:20:49 -07:00
commit 37aa4efea9
6 changed files with 159 additions and 146 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
include/mapnik/vertex_converters.hpp
View file

@ -266,7 +266,8 @@ struct converter_traits<T,mapnik::offset_transform_tag>
static void setup(geometry_type & geom, Args const& args)
{
typename boost::mpl::at<Args,boost::mpl::int_<2> >::type sym = boost::fusion::at_c<2>(args);
geom.set_offset(sym.offset());
double scale_factor = boost::fusion::at_c<6>(args);
geom.set_offset(sym.offset()*scale_factor);
}
};

2
src/agg/process_point_symbolizer.cpp
View file

@ -72,7 +72,7 @@ void agg_renderer<T>::process(point_symbolizer const& sym,
evaluate_transform(tr, feature, sym.get_image_transform());
agg::trans_affine_translation recenter(-center.x, -center.y);
agg::trans_affine recenter_tr = recenter * tr;
box2d<double> label_ext = bbox * recenter_tr;
box2d<double> label_ext = bbox * recenter_tr * agg::trans_affine_scaling(scale_factor_);
for (unsigned i=0; i<feature.num_geometries(); ++i)
{

1
src/cairo_renderer.cpp
View file

@ -697,6 +697,7 @@ void cairo_renderer_base::process(point_symbolizer const& sym,
box2d<double> label_ext (-dx, -dy, dx, dy);
label_ext *= tr;
label_ext *= agg::trans_affine_translation(x,y);
label_ext *= agg::trans_affine_scaling(scale_factor_);
if (sym.get_allow_overlap() ||
detector_->has_placement(label_ext))
{

2
src/grid/process_point_symbolizer.cpp
View file

@ -74,7 +74,7 @@ void grid_renderer<T>::process(point_symbolizer const& sym,
agg::trans_affine_translation recenter(-center.x, -center.y);
agg::trans_affine recenter_tr = recenter * tr;
box2d<double> label_ext = bbox * recenter_tr;
box2d<double> label_ext = bbox * recenter_tr * agg::trans_affine_scaling(scale_factor_) ;
for (unsigned i=0; i<feature.num_geometries(); ++i)
{

51
tests/visual_tests/compare.py
View file

@ -10,9 +10,6 @@ except ImportError:
COMPUTE_THRESHOLD = 16
errors = []
passed = 0
# returns true if pixels are not identical
def compare_pixels(pixel1, pixel2, alpha=True):
if pixel1 == pixel2:
@ -34,33 +31,22 @@ def compare_pixels(pixel1, pixel2, alpha=True):
return True
return False
def fail(actual,expected,message):
global errors
errors.append((message, actual, expected))
# compare two images and return number of different pixels
def compare(actual, expected, threshold=0, alpha=True):
global errors
global passed
def compare(actual, expected, alpha=True):
im1 = mapnik.Image.open(actual)
try:
im2 = mapnik.Image.open(expected)
except RuntimeError:
errors.append((None, actual, expected))
return -1
return 99999990
diff = 0
pixels = im1.width() * im1.height()
delta_pixels = (im2.width() * im2.height()) - pixels
if delta_pixels != 0:
errors.append((delta_pixels, actual, expected))
return delta_pixels
for x in range(0,im1.width(),2):
for y in range(0,im1.height(),2):
if compare_pixels(im1.get_pixel(x,y),im2.get_pixel(x,y),alpha=alpha):
diff += 1
if diff > threshold: # accept one pixel different
errors.append((diff, actual, expected))
passed += 1
return diff
def compare_grids(actual, expected, threshold=0, alpha=True):
@ -70,38 +56,9 @@ def compare_grids(actual, expected, threshold=0, alpha=True):
try:
im2 = json.loads(open(expected).read())
except RuntimeError:
errors.append((None, actual, expected))
return -1
return 9999990
equal = (im1 == im2)
# TODO - real diffing
if not equal:
errors.append((9999, actual, expected))
return 9999
passed += 1
return 99999999
return 0
def summary(generate=False):
global errors
global passed
if len(errors) != 0:
msg = "\nVisual text rendering: %s failed / %s passed" % (len(errors),passed)
print msg
for idx,error in enumerate(errors):
if error[0] is None:
if generate:
actual = open(error[1],'r').read()
open(error[2],'wb').write(actual)
print str(idx+1) + ") Generating reference image: '%s'" % error[2]
continue
else:
print str(idx+1) + ")Could not verify %s: No reference image found!" % error[1]
elif isinstance(error[0],int):
print str(idx+1) + ") \x1b[34m%s different pixels\x1b[0m:\n\t%s (\x1b[31mactual\x1b[0m)\n\t%s (\x1b[32mexpected\x1b[0m)" % error
elif isinstance(error[0],str):
print str(idx+1) + ") \x1b[31mfailure to run test:\x1b[0m %s" % error[0]
sys.exit(1)
else:
msg = '\nAll %s visual tests passed: \x1b[1;32m✓ \x1b[0m' % passed
print msg
sys.exit(0)

246
tests/visual_tests/test.py
View file

@ -6,7 +6,7 @@ mapnik.logger.set_severity(mapnik.severity_type.None)
import sys
import os.path
from compare import compare, compare_grids, summary, fail
from compare import compare, compare_grids
try:
import json
@ -17,7 +17,10 @@ visual_output_dir = "/tmp/mapnik-visual-images"
defaults = {
'sizes': [(500, 100)],
'scales':[1.0,2.0]
'scales':[1.0,2.0],
'agg': True,
'cairo': False,
'grid': False,
}
sizes_many_in_big_range = [(800, 100), (600, 100), (400, 100),
@ -95,108 +98,156 @@ files = [
#{'name': "tiff-opaque-edge-raster", 'sizes':[(256,256)]},
]
def report(diff,threshold,quiet=False):
if diff > threshold:
if quiet:
class Reporting:
DIFF = 1
NOT_FOUND = 2
OTHER = 3
REPLACE = 4
def __init__(self, quiet, generate = False, overwrite_failures = False):
self.quiet = quiet
self.passed = 0
self.failed = 0
self.generate = generate
self.overwrite_failures = overwrite_failures
self.errors = [ #(type, actual, expected, diff, message)
]
def result_fail(self, actual, expected, diff):
self.failed += 1
if self.quiet:
sys.stderr.write('\x1b[31m.\x1b[0m')
else:
print '\x1b[31m✘\x1b[0m (\x1b[34m%u different pixels\x1b[0m)' % diff
else:
if quiet:
if self.generate:
self.errors.append((self.REPLACE, actual, expected, diff, None))
contents = open(actual, 'r').read()
open(expected, 'wb').write(contents)
else:
self.errors.append((self.DIFF, actual, expected, diff, None))
def result_pass(self, actual, expected, diff):
self.passed += 1
if self.quiet:
sys.stderr.write('\x1b[32m.\x1b[0m')
else:
print '\x1b[32m✓\x1b[0m'
def render(config, width, height, bbox, scale_factor, quiet=False, overwrite_failures=False):
def not_found(self, actual, expected):
self.failed += 1
self.errors.append((self.NOT_FOUND, actual, expected, 0, None))
if self.quiet:
sys.stderr.write('\x1b[33m.\x1b[0m')
else:
print '\x1b[33m?\x1b[0m (\x1b[34mReference file not found\x1b[0m)'
if self.generate:
contents = open(actual, 'r').read()
open(expected, 'wb').write(contents)
def other_error(self, expected, message):
self.failed += 1
self.errors.append((self.OTHER, None, expected, 0, message))
if self.quiet:
sys.stderr.write('\x1b[31m.\x1b[0m')
else:
print '\x1b[31m✘\x1b[0m (\x1b[34m%s\x1b[0m)' % message
def summary(self, generate=False):
if len(self.errors) == 0:
print '\nAll %s visual tests passed: \x1b[1;32m✓ \x1b[0m' % self.passed
return 0
print "\nVisual rendering: %s failed / %s passed" % (len(self.errors), self.passed)
for idx, error in enumerate(self.errors):
if error[0] == self.OTHER:
print str(idx+1) + ") \x1b[31mfailure to run test:\x1b[0m %s" % error[3]
elif error[0] == self.NOT_FOUND:
if self.generate:
print str(idx+1) + ") Generating reference image: '%s'" % error[2]
else:
print str(idx+1) + ")Could not verify %s: No reference image found!" % error[1]
continue
elif error[0] == self.DIFF:
print str(idx+1) + ") \x1b[34m%s different pixels\x1b[0m:\n\t%s (\x1b[31mactual\x1b[0m)\n\t%s (\x1b[32mexpected\x1b[0m)" % (error[3], error[1], error[2])
elif error[0] == self.REPLACE:
print str(idx+1) + ") \x1b[31mreplaced reference with new version:\x1b[0m %s" % error[2]
return 1
def render_cairo(m, output, scale_factor):
mapnik.render_to_file(m, output, 'ARGB32', scale_factor)
# open and re-save as png8 to save space
new_im = mapnik.Image.open(output)
new_im.save(output, 'png8:m=h')
def render_grid(m, output, scale_factor):
grid = mapnik.Grid(m.width, m.height)
mapnik.render_layer(m, grid, layer=0)
utf1 = grid.encode('utf', resolution=4)
open(output,'wb').write(json.dumps(utf1, indent=1))
renderers = [
{ 'name': 'agg',
'render': lambda m, output, scale_factor: mapnik.render_to_file(m, output, 'png8:m=h', scale_factor),
'compare': lambda actual, reference: compare(actual, reference, alpha=True),
'threshold': 0,
'filetype': 'png',
'dir': 'images'
},
{ 'name': 'cairo',
'render': render_cairo,
'compare': lambda actual, reference: compare(actual, reference, alpha=False),
'threshold': 0,
'filetype': 'png',
'dir': 'images'
},
{ 'name': 'grid',
'render': render_grid,
'compare': lambda actual, reference: compare_grids(actual, reference, alpha=False),
'threshold': 0,
'filetype': 'json',
'dir': 'grids'
}
]
def render(config, width, height, bbox, scale_factor, reporting):
filename = config['name']
m = mapnik.Map(width, height)
postfix = "%s-%d-%d-%s" % (filename,width,height,scale_factor)
postfix = "%s-%d-%d-%s" % (filename, width, height, scale_factor)
try:
mapnik.load_map(m, os.path.join(dirname, "styles", "%s.xml" % filename), False)
if bbox is not None:
m.zoom_to_box(bbox)
else:
m.zoom_all()
except Exception, e:
reporting.other_error(filename, repr(e))
return m
## AGG rendering
if config.get('agg',True):
expected_agg = os.path.join(dirname, "images", postfix + '-agg-reference.png')
actual_agg = os.path.join(visual_output_dir, '%s-agg.png' % postfix)
try:
mapnik.load_map(m, os.path.join(dirname, "styles", "%s.xml" % filename), False)
if bbox is not None:
m.zoom_to_box(bbox)
else:
m.zoom_all()
except Exception, e:
sys.stderr.write(e.message + '\n')
fail(actual_agg,expected_agg,str(e.message))
return m
if not quiet:
print "\"%s\" with agg..." % (postfix),
try:
mapnik.render_to_file(m, actual_agg, 'png8:m=h', scale_factor)
if not os.path.exists(expected_agg):
# generate it on the fly
fail(actual_agg,expected_agg,None)
else:
threshold = 0
diff = compare(actual_agg, expected_agg, threshold=0, alpha=True)
if overwrite_failures and diff > threshold:
fail(actual_agg,expected_agg,None)
for renderer in renderers:
# TODO - grid renderer does not support scale_factor yet via python
if renderer['name'] == 'grid' and scale_factor != 1.0:
continue
if config.get(renderer['name'], True):
expected = os.path.join(dirname, renderer['dir'], '%s-%s-reference.%s' %
(postfix, renderer['name'], renderer['filetype']))
actual = os.path.join(visual_output_dir, '%s-%s.%s' %
(postfix, renderer['name'], renderer['filetype']))
if not quiet:
print "\"%s\" with %s..." % (postfix, renderer['name']),
try:
renderer['render'](m, actual, scale_factor)
if not os.path.exists(expected):
reporting.not_found(actual, expected)
else:
report(diff,threshold,quiet)
except Exception, e:
sys.stderr.write(e.message + '\n')
fail(actual_agg,expected_agg,str(e.message))
### TODO - set up tests to compare agg and cairo png output
### Cairo rendering
if config.get('cairo',True):
expected_cairo = os.path.join(dirname, "images", postfix + '-cairo-reference.png')
actual_cairo = os.path.join(visual_output_dir, '%s-cairo.png' % postfix)
if not quiet:
print "\"%s\" with cairo..." % (postfix),
try:
mapnik.render_to_file(m, actual_cairo,'ARGB32', scale_factor)
# open and re-save as png8 to save space
new_im = mapnik.Image.open(actual_cairo)
new_im.save(actual_cairo,'png8:m=h')
if not os.path.exists(expected_cairo):
# generate it on the fly
fail(actual_cairo,expected_cairo,None)
else:
# cairo and agg differ in alpha for reasons unknown, so don't test it for now
threshold = 0
diff = compare(actual_cairo, expected_cairo, threshold=threshold, alpha=False)
if overwrite_failures and diff > threshold:
fail(actual_cairo,expected_cairo,None)
else:
report(diff,threshold,quiet)
except Exception, e:
sys.stderr.write(e.message + '\n')
fail(actual_cairo,expected_cairo,str(e.message))
## Grid rendering
# TODO - grid renderer does not support scale_factor yet via python
if scale_factor == 1.0 and config.get('grid',True):
expected_grid = os.path.join(dirname, "grids", postfix + '-grid-reference.json')
actual_grid = os.path.join(visual_output_dir, '%s-grid.json' % postfix)
if not quiet:
print "\"%s\" with grid..." % (postfix),
try:
grid = mapnik.Grid(m.width,m.height)
mapnik.render_layer(m,grid,layer=0)
utf1 = grid.encode('utf',resolution=4)
open(actual_grid,'wb').write(json.dumps(utf1,indent=1))
if not os.path.exists(expected_grid):
# generate it on the fly
fail(actual_grid,expected_grid,None)
else:
threshold = 0
diff = compare_grids(actual_grid, expected_grid, threshold=threshold, alpha=False)
if overwrite_failures and diff > threshold:
fail(actual_grid,expected_grid,None)
else:
report(diff,threshold,quiet)
except Exception, e:
sys.stderr.write(e.message + '\n')
fail(actual_grid,expected_grid,str(e.message))
diff = renderer['compare'](actual, expected)
if diff > renderer['threshold']:
reporting.result_fail(actual, expected, diff)
else:
reporting.result_pass(actual, expected, diff)
except Exception, e:
reporting.other_error(expected, repr(e))
return m
if __name__ == "__main__":
@ -222,7 +273,9 @@ if __name__ == "__main__":
if not os.path.exists(visual_output_dir):
os.makedirs(visual_output_dir)
if 'osm' in mapnik.DatasourceCache.plugin_names():
reporting = Reporting(quiet, overwrite_failures)
for f in files:
config = dict(defaults)
config.update(f)
@ -233,8 +286,9 @@ if __name__ == "__main__":
size[1],
config.get('bbox'),
scale_factor,
quiet=quiet,
overwrite_failures=overwrite_failures)
reporting)
mapnik.save_map(m, os.path.join(dirname, 'xml_output', "%s-out.xml" % config['name']))
summary(generate=True)
sys.exit(reporting.summary(generate=True))
else:
print "OSM plugin required"