#!/usr/bin/env python

# -*- coding: utf-8 -*-

import os

from nose.tools import eq_

import mapnik

from .utilities import execution_path, run_all

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('.'))

if mapnik.has_png():

tmp_dir = '/tmp/mapnik-png/'

if not os.path.exists(tmp_dir):

os.makedirs(tmp_dir)

opts = [

'png32',

'png32:t=0',

'png8:m=o',

'png8:m=o:c=1',

'png8:m=o:t=0',

'png8:m=o:c=1:t=0',

'png8:m=o:t=1',

'png8:m=o:t=2',

'png8:m=h',

'png8:m=h:c=1',

'png8:m=h:t=0',

'png8:m=h:c=1:t=0',

'png8:m=h:t=1',

'png8:m=h:t=2'

]

# Todo - use itertools.product

#z_opts = range(1,9+1)

#t_opts = range(0,2+1)

def gen_filepath(name, format):

return os.path.join('images/support/encoding-opts',

name + '-' + format.replace(":", "+") + '.png')

generate = os.environ.get('UPDATE')

def test_expected_encodings():

# blank image

im = mapnik.Image(256, 256)

for opt in opts:

expected = gen_filepath('solid', opt)

actual = os.path.join(tmp_dir, os.path.basename(expected))

if generate or not os.path.exists(expected):

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

im.save(expected, opt)

else:

im.save(actual, opt)

eq_(mapnik.Image.open(actual).tostring('png32'),

mapnik.Image.open(expected).tostring('png32'),

'%s (actual) not == to %s (expected)' % (actual, expected))

# solid image

im.fill(mapnik.Color('green'))

for opt in opts:

expected = gen_filepath('blank', opt)

actual = os.path.join(tmp_dir, os.path.basename(expected))

if generate or not os.path.exists(expected):

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

im.save(expected, opt)

else:

im.save(actual, opt)

eq_(mapnik.Image.open(actual).tostring('png32'),

mapnik.Image.open(expected).tostring('png32'),

'%s (actual) not == to %s (expected)' % (actual, expected))

# aerial

im = mapnik.Image.open('./images/support/transparency/aerial_rgba.png')

for opt in opts:

expected = gen_filepath('aerial_rgba', opt)

actual = os.path.join(tmp_dir, os.path.basename(expected))

if generate or not os.path.exists(expected):

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

im.save(expected, opt)

else:

im.save(actual, opt)

eq_(mapnik.Image.open(actual).tostring('png32'),

mapnik.Image.open(expected).tostring('png32'),

'%s (actual) not == to %s (expected)' % (actual, expected))

def test_transparency_levels():

# create partial transparency image

im = mapnik.Image(256, 256)

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

c2 = mapnik.Color('rgba(255,255,0,.2)')

c3 = mapnik.Color('rgb(0,255,255)')

for y in range(0, int(im.height() / 2)):

for x in range(0, int(im.width() / 2)):

im.set_pixel(x, y, c2)

for y in range(int(im.height() / 2), im.height()):

for x in range(int(im.width() / 2), im.width()):

im.set_pixel(x, y, c3)

t0 = tmp_dir + 'white0.png'

t2 = tmp_dir + 'white2.png'

t1 = tmp_dir + 'white1.png'

# octree

format = 'png8:m=o:t=0'

im.save(t0, format)

im_in = mapnik.Image.open(t0)

t0_len = len(im_in.tostring(format))

eq_(t0_len, len(mapnik.Image.open(

'images/support/transparency/white0.png').tostring(format)))

format = 'png8:m=o:t=1'

im.save(t1, format)

im_in = mapnik.Image.open(t1)

t1_len = len(im_in.tostring(format))

eq_(len(im.tostring(format)), len(mapnik.Image.open(

'images/support/transparency/white1.png').tostring(format)))

format = 'png8:m=o:t=2'

im.save(t2, format)

im_in = mapnik.Image.open(t2)

t2_len = len(im_in.tostring(format))

eq_(len(im.tostring(format)), len(mapnik.Image.open(

'images/support/transparency/white2.png').tostring(format)))

eq_(t0_len < t1_len < t2_len, True)

# hextree

format = 'png8:m=h:t=0'

im.save(t0, format)

im_in = mapnik.Image.open(t0)

t0_len = len(im_in.tostring(format))

eq_(t0_len, len(mapnik.Image.open(

'images/support/transparency/white0.png').tostring(format)))

format = 'png8:m=h:t=1'

im.save(t1, format)

im_in = mapnik.Image.open(t1)

t1_len = len(im_in.tostring(format))

eq_(len(im.tostring(format)), len(mapnik.Image.open(

'images/support/transparency/white1.png').tostring(format)))

format = 'png8:m=h:t=2'

im.save(t2, format)

im_in = mapnik.Image.open(t2)

t2_len = len(im_in.tostring(format))

eq_(len(im.tostring(format)), len(mapnik.Image.open(

'images/support/transparency/white2.png').tostring(format)))

eq_(t0_len < t1_len < t2_len, True)

def test_transparency_levels_aerial():

im = mapnik.Image.open('../data/images/12_654_1580.png')

im_in = mapnik.Image.open(

'./images/support/transparency/aerial_rgba.png')

eq_(len(im.tostring('png8')), len(im_in.tostring('png8')))

eq_(len(im.tostring('png32')), len(im_in.tostring('png32')))

im_in = mapnik.Image.open(

'./images/support/transparency/aerial_rgb.png')

eq_(len(im.tostring('png32')), len(im_in.tostring('png32')))

eq_(len(im.tostring('png32:t=0')), len(im_in.tostring('png32:t=0')))

eq_(len(im.tostring('png32:t=0')) == len(im_in.tostring('png32')), False)

eq_(len(im.tostring('png8')), len(im_in.tostring('png8')))

eq_(len(im.tostring('png8:t=0')), len(im_in.tostring('png8:t=0')))

# unlike png32 paletted images without alpha will look the same even if

# no alpha is forced

eq_(len(im.tostring('png8:t=0')) == len(im_in.tostring('png8')), True)

eq_(len(im.tostring('png8:t=0:m=o')) ==

len(im_in.tostring('png8:m=o')), True)

def test_9_colors_hextree():

expected = './images/support/encoding-opts/png8-9cols.png'

im = mapnik.Image.open(expected)

t0 = tmp_dir + 'png-encoding-9-colors.result-hextree.png'

im.save(t0, 'png8:m=h')

eq_(mapnik.Image.open(t0).tostring(),

mapnik.Image.open(expected).tostring(),

'%s (actual) not == to %s (expected)' % (t0, expected))

def test_9_colors_octree():

expected = './images/support/encoding-opts/png8-9cols.png'

im = mapnik.Image.open(expected)

t0 = tmp_dir + 'png-encoding-9-colors.result-octree.png'

im.save(t0, 'png8:m=o')

eq_(mapnik.Image.open(t0).tostring(),

mapnik.Image.open(expected).tostring(),

'%s (actual) not == to %s (expected)' % (t0, expected))

def test_17_colors_hextree():

expected = './images/support/encoding-opts/png8-17cols.png'

im = mapnik.Image.open(expected)

t0 = tmp_dir + 'png-encoding-17-colors.result-hextree.png'

im.save(t0, 'png8:m=h')

eq_(mapnik.Image.open(t0).tostring(),

mapnik.Image.open(expected).tostring(),

'%s (actual) not == to %s (expected)' % (t0, expected))

def test_17_colors_octree():

expected = './images/support/encoding-opts/png8-17cols.png'

im = mapnik.Image.open(expected)

t0 = tmp_dir + 'png-encoding-17-colors.result-octree.png'

im.save(t0, 'png8:m=o')

eq_(mapnik.Image.open(t0).tostring(),

mapnik.Image.open(expected).tostring(),

'%s (actual) not == to %s (expected)' % (t0, expected))

def test_2px_regression_hextree():

im = mapnik.Image.open('./images/support/encoding-opts/png8-2px.A.png')

expected = './images/support/encoding-opts/png8-2px.png'

t0 = tmp_dir + 'png-encoding-2px.result-hextree.png'

im.save(t0, 'png8:m=h')

eq_(mapnik.Image.open(t0).tostring(),

mapnik.Image.open(expected).tostring(),

'%s (actual) not == to %s (expected)' % (t0, expected))

def test_2px_regression_octree():

im = mapnik.Image.open('./images/support/encoding-opts/png8-2px.A.png')

expected = './images/support/encoding-opts/png8-2px.png'

t0 = tmp_dir + 'png-encoding-2px.result-octree.png'

im.save(t0, 'png8:m=o')

eq_(mapnik.Image.open(t0).tostring(),

mapnik.Image.open(expected).tostring(),

'%s (actual) not == to %s (expected)' % (t0, expected))

if __name__ == "__main__":

setup()

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