# encoding: utf8

from __future__ import print_function

import os

from nose.tools import eq_

import mapnik

from .utilities import (execution_path, get_unique_colors, pixel2channels,

run_all, side_by_side_image)

def setup():

# All of the paths used are relative, if we run the tests

# from another directory we need to chdir()

os.chdir(execution_path('.'))

def is_pre(color, alpha):

return (color * 255.0 / alpha) <= 255

def debug_image(image, step=2):

for x in range(0, image.width(), step):

for y in range(0, image.height(), step):

pixel = image.get_pixel(x, y)

red, green, blue, alpha = pixel2channels(pixel)

print(

"rgba(%s,%s,%s,%s) at %s,%s" %

(red, green, blue, alpha, x, y))

def replace_style(m, name, style):

m.remove_style(name)

m.append_style(name, style)

# note: it is impossible to know for all pixel colors

# we can only detect likely cases of non premultiplied colors

def validate_pixels_are_not_premultiplied(image):

over_alpha = False

transparent = True

fully_opaque = True

for x in range(0, image.width(), 2):

for y in range(0, image.height(), 2):

pixel = image.get_pixel(x, y)

red, green, blue, alpha = pixel2channels(pixel)

if alpha > 0:

transparent = False

if alpha < 255:

fully_opaque = False

color_max = max(red, green, blue)

if color_max > alpha:

over_alpha = True

return over_alpha or transparent or fully_opaque

def validate_pixels_are_not_premultiplied2(image):

looks_not_multiplied = False

for x in range(0, image.width(), 2):

for y in range(0, image.height(), 2):

pixel = image.get_pixel(x, y)

red, green, blue, alpha = pixel2channels(pixel)

# each value of the color channels will never be bigger than that

# of the alpha channel.

if alpha > 0:

if red > 0 and red > alpha:

print('red: %s, a: %s' % (red, alpha))

looks_not_multiplied = True

return looks_not_multiplied

def validate_pixels_are_premultiplied(image):

bad_pixels = []

for x in range(0, image.width(), 2):

for y in range(0, image.height(), 2):

pixel = image.get_pixel(x, y)

red, green, blue, alpha = pixel2channels(pixel)

if alpha > 0:

pixel = image.get_pixel(x, y)

is_valid = ((0 <= red <= alpha) and is_pre(red, alpha)) \

and ((0 <= green <= alpha) and is_pre(green, alpha)) \

and ((0 <= blue <= alpha) and is_pre(blue, alpha)) \

and (alpha >= 0 and alpha <= 255)

if not is_valid:

bad_pixels.append(

"rgba(%s,%s,%s,%s) at %s,%s" %

(red, green, blue, alpha, x, y))

num_bad = len(bad_pixels)

return (num_bad == 0, bad_pixels)

def test_compare_images():

b = mapnik.Image.open('./images/support/b.png')

b.premultiply()

num_ops = len(mapnik.CompositeOp.names)

successes = []

fails = []

for name in mapnik.CompositeOp.names:

a = mapnik.Image.open('./images/support/a.png')

a.premultiply()

a.composite(b, getattr(mapnik.CompositeOp, name))

actual = '/tmp/mapnik-comp-op-test-' + name + '.png'

expected = 'images/composited/' + name + '.png'

valid = validate_pixels_are_premultiplied(a)

if not valid[0]:

fails.append(

'%s not validly premultiplied!:\n\t %s pixels (%s)' %

(name, len(

valid[1]), valid[1][0]))

a.demultiply()

if not validate_pixels_are_not_premultiplied(a):

fails.append('%s not validly demultiplied' % (name))

a.save(actual, 'png32')

if not os.path.exists(expected) or os.environ.get('UPDATE'):

print('generating expected test image: %s' % expected)

a.save(expected, 'png32')

expected_im = mapnik.Image.open(expected)

# compare them

if a.tostring('png32') == expected_im.tostring('png32'):

successes.append(name)

else:

fails.append(

'failed comparing actual (%s) and expected(%s)' %

(actual, 'tests/python_tests/' + expected))

fail_im = side_by_side_image(expected_im, a)

fail_im.save(

'/tmp/mapnik-comp-op-test-' +

name +

'.fail.png',

'png32')

eq_(len(successes), num_ops, '\n' + '\n'.join(fails))

b.demultiply()

# b will be slightly modified by pre and then de multiplication rounding errors

# TODO - write test to ensure the image is 99% the same.

#expected_b = mapnik.Image.open('./images/support/b.png')

# b.save('/tmp/mapnik-comp-op-test-original-mask.png')

#eq_(b.tostring('png32'),expected_b.tostring('png32'), '/tmp/mapnik-comp-op-test-original-mask.png is no longer equivalent to original mask: ./images/support/b.png')

def test_pre_multiply_status():

b = mapnik.Image.open('./images/support/b.png')

# not premultiplied yet, should appear that way

result = validate_pixels_are_not_premultiplied(b)

eq_(result, True)

# not yet premultiplied therefore should return false

result = validate_pixels_are_premultiplied(b)

eq_(result[0], False)

# now actually premultiply the pixels

b.premultiply()

# now checking if premultiplied should succeed

result = validate_pixels_are_premultiplied(b)

eq_(result[0], True)

# should now not appear to look not premultiplied

result = validate_pixels_are_not_premultiplied(b)

eq_(result, False)

# now actually demultiply the pixels

b.demultiply()

# should now appear demultiplied

result = validate_pixels_are_not_premultiplied(b)

eq_(result, True)

def test_pre_multiply_status_of_map1():

m = mapnik.Map(256, 256)

im = mapnik.Image(m.width, m.height)

eq_(validate_pixels_are_not_premultiplied(im), True)

mapnik.render(m, im)

eq_(validate_pixels_are_not_premultiplied(im), True)

def test_pre_multiply_status_of_map2():

m = mapnik.Map(256, 256)

m.background = mapnik.Color(1, 1, 1, 255)

im = mapnik.Image(m.width, m.height)

eq_(validate_pixels_are_not_premultiplied(im), True)

mapnik.render(m, im)

eq_(validate_pixels_are_not_premultiplied(im), True)

if 'shape' in mapnik.DatasourceCache.plugin_names():

def test_style_level_comp_op():

m = mapnik.Map(256, 256)

mapnik.load_map(m, '../data/good_maps/style_level_comp_op.xml')

m.zoom_all()

successes = []

fails = []

for name in mapnik.CompositeOp.names:

# find_style returns a copy of the style object

style_markers = m.find_style("markers")

style_markers.comp_op = getattr(mapnik.CompositeOp, name)

# replace the original style with the modified one

replace_style(m, "markers", style_markers)

im = mapnik.Image(m.width, m.height)

mapnik.render(m, im)

actual = '/tmp/mapnik-style-comp-op-' + name + '.png'

expected = 'images/style-comp-op/' + name + '.png'

im.save(actual, 'png32')

if not os.path.exists(expected) or os.environ.get('UPDATE'):

print('generating expected test image: %s' % expected)

im.save(expected, 'png32')

expected_im = mapnik.Image.open(expected)

# compare them

if im.tostring('png32') == expected_im.tostring('png32'):

successes.append(name)

else:

fails.append(

'failed comparing actual (%s) and expected(%s)' %

(actual, 'tests/python_tests/' + expected))

fail_im = side_by_side_image(expected_im, im)

fail_im.save(

'/tmp/mapnik-style-comp-op-' +

name +

'.fail.png',

'png32')

eq_(len(fails), 0, '\n' + '\n'.join(fails))

def test_style_level_opacity():

m = mapnik.Map(512, 512)

mapnik.load_map(

m, '../data/good_maps/style_level_opacity_and_blur.xml')

m.zoom_all()

im = mapnik.Image(512, 512)

mapnik.render(m, im)

actual = '/tmp/mapnik-style-level-opacity.png'

expected = 'images/support/mapnik-style-level-opacity.png'

im.save(actual, 'png32')

expected_im = mapnik.Image.open(expected)

eq_(im.tostring('png32'),

expected_im.tostring('png32'),

'failed comparing actual (%s) and expected (%s)' % (actual,

'tests/python_tests/' + expected))

def test_rounding_and_color_expectations():

m = mapnik.Map(1, 1)

m.background = mapnik.Color('rgba(255,255,255,.4999999)')

im = mapnik.Image(m.width, m.height)

mapnik.render(m, im)

eq_(get_unique_colors(im), ['rgba(255,255,255,127)'])

m = mapnik.Map(1, 1)

m.background = mapnik.Color('rgba(255,255,255,.5)')

im = mapnik.Image(m.width, m.height)

mapnik.render(m, im)

eq_(get_unique_colors(im), ['rgba(255,255,255,128)'])

im_file = mapnik.Image.open('../data/images/stripes_pattern.png')

eq_(get_unique_colors(im_file), ['rgba(0,0,0,0)', 'rgba(74,74,74,255)'])

# should have no effect

im_file.premultiply()

eq_(get_unique_colors(im_file), ['rgba(0,0,0,0)', 'rgba(74,74,74,255)'])

im_file.apply_opacity(.5)

# should have effect now that image has transparency

im_file.premultiply()

eq_(get_unique_colors(im_file), ['rgba(0,0,0,0)', 'rgba(37,37,37,127)'])

# should restore to original nonpremultiplied colors

im_file.demultiply()

eq_(get_unique_colors(im_file), ['rgba(0,0,0,0)', 'rgba(74,74,74,127)'])

def test_background_image_and_background_color():

m = mapnik.Map(8, 8)

m.background = mapnik.Color('rgba(255,255,255,.5)')

m.background_image = '../data/images/stripes_pattern.png'

im = mapnik.Image(m.width, m.height)

mapnik.render(m, im)

eq_(get_unique_colors(im), ['rgba(255,255,255,128)', 'rgba(74,74,74,255)'])

def test_background_image_with_alpha_and_background_color():

m = mapnik.Map(10, 10)

m.background = mapnik.Color('rgba(255,255,255,.5)')

m.background_image = '../data/images/yellow_half_trans.png'

im = mapnik.Image(m.width, m.height)

mapnik.render(m, im)

eq_(get_unique_colors(im), ['rgba(255,255,85,191)'])

def test_background_image_with_alpha_and_background_color_against_composited_control():

m = mapnik.Map(10, 10)

m.background = mapnik.Color('rgba(255,255,255,.5)')

m.background_image = '../data/images/yellow_half_trans.png'

im = mapnik.Image(m.width, m.height)

mapnik.render(m, im)

# create and composite the expected result

im1 = mapnik.Image(10, 10)

im1.fill(mapnik.Color('rgba(255,255,255,.5)'))

im1.premultiply()

im2 = mapnik.Image(10, 10)

im2.fill(mapnik.Color('rgba(255,255,0,.5)'))

im2.premultiply()

im1.composite(im2)

im1.demultiply()

# compare image rendered (compositing in `agg_renderer<T>::setup`)

# vs image composited via python bindings

#raise Todo("looks like we need to investigate PNG color rounding when saving")

# eq_(get_unique_colors(im),get_unique_colors(im1))

if __name__ == "__main__":

setup()

exit(run_all(eval(x) for x in dir() if x.startswith("test_")))