WIP-pyshapelib-bramz/test/test_baserenderer.py

# Copyright (C) 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Test Thuban.Model.baserenderer"""

__version__ = "$Revision$"
# $Source$
# $Id$

import os
import binascii
import unittest

from mockgeo import SimpleShapeStore
import support
support.initthuban()

from Thuban.Model.color import Transparent, Color
from Thuban.Model.data import SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT
from Thuban.Model.map import Map
from Thuban.Model.layer import Layer, RasterLayer
from Thuban.Model.table import MemoryTable, \
     FIELDTYPE_DOUBLE, FIELDTYPE_INT, FIELDTYPE_STRING
from Thuban.Model.classification import ClassGroupSingleton
import Thuban.Model.resource


from Thuban.UI.baserenderer import BaseRenderer


class MockDC:

    def __init__(self, size = None):
        self.calls = []
        self.size = size

    def GetSizeTuple(self):
        return self.size

    def __getattr__(self, attr):
        def method(*args):
            self.calls.append((attr,) + args)
        return method

class P:

    """A simple point"""

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    def __ne__(self, other):
        return self.x != other.x and self.y != other.y

    def __repr__(self):
        return "P(%r, %r)" % (self.x, self.y)


class SimpleRenderer(BaseRenderer):

    TRANSPARENT_PEN = ("pen", Transparent)
    TRANSPARENT_BRUSH = ("brush", Transparent)

    def make_point(self, x, y):
        return P(x, y)

    def tools_for_property(self, prop):
        fill = prop.GetFill()
        brush = ("brush", fill)

        stroke = prop.GetLineColor()
        stroke_width = prop.GetLineWidth()
        if stroke is Transparent:
            pen = ("pen", Transparent)
        else:
            pen = ("pen", stroke, stroke_width)

        return pen, brush

    def label_font(self):
        return "label font"

    def draw_raster_data(self, data):
        self.raster_data = data


class MockProjection:

    """Objects that look like projections but simply apply non-uniform scalings
    """

    def __init__(self, xscale, yscale):
        self.xscale = float(xscale)
        self.yscale = float(yscale)

    def Forward(self, x, y):
        return (x * self.xscale, y * self.yscale)

    def Inverse(self, x, y):
        return (x / self.xscale, y / self.yscale)


class TestBaseRenderer(unittest.TestCase):

    def setUp(self):
        """Set self.to_destroy to an empty list

        Test should put all objects whose Destroy should be called atunittest.main
        the end into this list so that they're destroyed in tearDown
        """
        self.to_destroy = []

    def tearDown(self):
        for obj in self.to_destroy:
            obj.Destroy()

    def test_arc_no_projection(self):
        """Test BaseRenderer with arc layer and no projections"""
        table = MemoryTable([("type", FIELDTYPE_STRING),
                             ("value", FIELDTYPE_DOUBLE),
                             ("code", FIELDTYPE_INT)],
                            [("UNKNOWN", 0.0, 0)])
        shapes = [[[(0, 0), (10, 10)]]]
        store = SimpleShapeStore(SHAPETYPE_ARC, shapes, table)

        map = Map("TestBaseRenderer")
        self.to_destroy.append(map)
        layer = Layer("arc layer", store)
        map.AddLayer(layer)

        dc = MockDC()
        renderer = SimpleRenderer(dc, map, 2, (10, 10))

        renderer.render_map()

        self.assertEquals(dc.calls,
                          [('BeginDrawing',),
                           ('SetBrush', ('brush', Transparent)),
                           ('SetPen', ('pen', Color(0, 0, 0), 1)),
                           ('DrawLines', [P(10, 10), P(30, -10)]),
                           ('SetFont', "label font"),
                           ('EndDrawing',)])

    def test_polygon_no_projection(self):
        """Test BaseRenderer with polygon layer and no projections"""
        table = MemoryTable([("type", FIELDTYPE_STRING),
                             ("value", FIELDTYPE_DOUBLE),
                             ("code", FIELDTYPE_INT)],
                            [("UNKNOWN", 0.0, 0)])
        shapes = [[[(0, 0), (10, 10), (10, 0), (0, 0)]]]
        store = SimpleShapeStore(SHAPETYPE_POLYGON, shapes, table)

        map = Map("TestBaseRenderer")
        layer = Layer("polygon layer", store)
        prop = layer.GetClassification().GetDefaultGroup().GetProperties()
        prop.SetFill(Color(1, 1, 1))

        map.AddLayer(layer)
        self.to_destroy.append(map)

        dc = MockDC()
        renderer = SimpleRenderer(dc, map, 2, (10, 10))

        renderer.render_map()

        self.assertEquals(dc.calls,
                          [('BeginDrawing',),
                           ('SetBrush', ('brush', Color(1, 1, 1))),
                           ('SetPen', ('pen', Transparent)),
                           ('DrawPolygon', [P(10, 10), P(30, -10), P(30, 10),
                                            P(10, 10)]),
                           ('SetBrush', ('brush', Transparent)),
                           ('SetPen', ('pen', Color(0, 0, 0), 1)),
                           ('DrawLines', [P(10, 10), P(30, -10), P(30, 10),
                                          P(10, 10)]),
                           ('SetFont', "label font"),
                           ('EndDrawing',)])

    def test_complex_polygon(self):
        """Test BaseRenderer with complex polygon and no projections"""
        # A square inside a sqare. This has to be drawn with at least a
        # draw polygon call and two draw lines calls.
        shapes = [[[(0, 0), (0, 10), (10, 10), (10, 0), (0, 0)],
                   [(2, 2), (8, 2), (8, 8), (2, 8), (2, 2)]]]

        table = MemoryTable([("type", FIELDTYPE_STRING),
                             ("value", FIELDTYPE_DOUBLE),
                             ("code", FIELDTYPE_INT)],
                            [("UNKNOWN", 0.0, 0)])
        store = SimpleShapeStore(SHAPETYPE_POLYGON, shapes, table)

        map = Map("TestBaseRenderer")
        layer = Layer("polygon layer", store)
        prop = layer.GetClassification().GetDefaultGroup().GetProperties()
        prop.SetFill(Color(1, 1, 1))

        map.AddLayer(layer)
        self.to_destroy.append(map)

        dc = MockDC()
        renderer = SimpleRenderer(dc, map, 2, (10, 10))

        renderer.render_map()

        self.assertEquals(dc.calls,
                          [('BeginDrawing',),
                           ('SetBrush', ('brush', Color(1, 1, 1))),
                           ('SetPen', ('pen', Transparent)),
                           ('DrawPolygon',
                            [P(10, 10), P(10, -10), P(30, -10), P(30, 10),
                             P(10, 10),
                             P(14, 6), P(26, 6), P(26, -6), P(14, -6),
                             P(14, 6),
                             P(10, 10)]),
                           ('SetBrush', ('brush', Transparent)),
                           ('SetPen', ('pen', Color(0, 0, 0), 1)),
                           ('DrawLines', [P(10, 10), P(10, -10), P(30, -10),
                                          P(30, 10), P(10, 10)]),
                           ('DrawLines', [P(14, 6), P(26, 6), P(26, -6),
                                          P(14, -6), P(14, 6)]),
                           ('SetFont', "label font"),
                           ('EndDrawing',)])

    def test_point_no_projection(self):
        """Test BaseRenderer with point layer and no projections"""
        table = MemoryTable([("type", FIELDTYPE_STRING),
                             ("value", FIELDTYPE_DOUBLE),
                             ("code", FIELDTYPE_INT)],
                            [("UNKNOWN", 0.0, 0),
                             ("UNKNOWN", 0.0, 1)])
        shapes = [[[(0, 0)]], [[(10, 10)]]]
        store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)

        map = Map("TestBaseRenderer")
        layer = Layer("point layer", store)
        map.AddLayer(layer)
        self.to_destroy.append(map)

        dc = MockDC()
        renderer = SimpleRenderer(dc, map, 2, (10, 10))

        renderer.render_map()

        self.assertEquals(dc.calls,
                          [('BeginDrawing',),
                           ('SetBrush', ('brush', Transparent)),
                           ('SetPen', ('pen', Color(0, 0, 0), 1)),
                           ('DrawEllipse', 5, 5, 10, 10),
                           ('SetBrush', ('brush', Transparent)),
                           ('SetPen', ('pen', Color(0, 0, 0), 1)),
                           ('DrawEllipse', 25, -15, 10, 10),
                           ('SetFont', "label font"),
                           ('EndDrawing',)])

    def test_raster_no_projection(self):
        """Test BaseRenderer with raster layer and no projections

        This test is very simple minded and perhaps can easily fail due
        to round-off errors. It simply compares the complete BMP file
        returned by gdalwarp.ProjectRasterFile to a BMP file data.
        """
        if not Thuban.Model.resource.has_gdal_support():
            raise support.SkipTest("No gdal support")

        map = Map("TestBaseRenderer")

        layer = RasterLayer("raster layer",
                            os.path.join("..", "Data", "iceland",
                                         "island.tif"))
        map.AddLayer(layer)
        self.to_destroy.append(map)

        dc = MockDC(size = (20, 20))
        renderer = SimpleRenderer(dc, map, 34, (800, 2250))

        renderer.render_map()

        # The following commented out code block can be used to generate
        # the base64 coded reference image data
        #hexed = binascii.b2a_base64(renderer.raster_data)
        #while hexed:
        #    print repr(hexed[:65])
        #    hexed = hexed[65:]

        # The reference data as a base64 coded BMP image
        raw_data = binascii.a2b_base64(
            'Qk3GBQAAAAAAADYEAAAoAAAAFAAAABQAAAABAAgAAAAAAJABAAAAAAAAAAAAAAABA'
            'AAAAAAAApYOAALGAgAGfjoAHmZyACZ2egAujo4AArICAE66GgACngIA5mZSAJqONg'
            'ACzgIAAoIyABZqZgAO4uYAAtICAAKqAgAScloAAtYCADKepgAS2t4AAooiAALaAgA'
            'CtgIAHsbOAAp2TgACogIAFtbaACqOigAidnoAAuICADKaogACfjoAAr4CAAKSFgAm'
            'fnoAAo4eABrS1gAibnoAHsbKAAp6SgACmg4AGs7SACLCxgAqioIAAoYqAAZ6RgACm'
            'goAKrK6AALmAgAC3gIAApIaABZqagACngYAAo4iAAKmAgAivsYAJoJ6AALCAgACyg'
            'IAAq4CAAKWEgAOclYALpqeAAK6AgACgjYAEm5eAAKKKgAGekIAHmp6ABpmcgAChi4'
            'ALpaaACJyegAClhYAEnJeAAZ+QgAqhoIADnZSAB5mdgACiiYAJnp6ACqGegAqrrYA'
            'GmpuAB5megACkh4ALqqyAA52VgAulpYAAoI6AAZ+PgASbmIALpKWAA7m5gAWbmYAG'
            'mpyAC6SjgAqioYADnZOAA7q6gAianoALqauABpqagAqgnoAEnJWAAp6RgAWbmIACu'
            '7uACqGfgAqiooAMqauAAby8gAmusIAMp6qAC6WngAyoqoABvb2AC6SkgAS3uIAJra'
            '+AB7KzgAynqIALq62ADKirgAC+voAGsrSABLi4gAG8vYADubqAC6qtgAuprIABvb6'
            'ACLCygAW2t4AKra+AAru8gAS4uYACuruAAry8gAG+voAAEBAAFhkZABAQEAABp6fA'
            'EBACAAAgPwAAPu/AJE9CgBACAAALj1BAEAICAAGPAAAQAgAAAY8+gBACL8AJTxXAA'
            'gIQAAAPEAAAAgIAAY8QABACAgAAGQAAABAAAAALpoAAEBAAAAALgAAAEAABkAGAEA'
            'IQAD2AEAAvwAIAJAu2ABAQEAALmQ5AEBAQAAAnp8AAEAIAAD4+gAAv78An5rDAEBA'
            'QAAuhAcAQEBAAAb8AABAvwAAAGQKAABAAABpLksAQEAIAC4ACwBAAAAAAPkGAAC/Q'
            'AD2APoAvwC/AJ0umgBAQEAAAGRkAABAQAAGnp8AQEAIAPcA/AC/AL8A7D0GAEAIQA'
            'D4hAAAv0AAAAD8QAAAvwgA92T6AL9AvwDsLlcAQEBAAC4AQABAAAgA+EAAAL8IAAA'
            '8AAAACAAAAJ8uVgBAQEAAAGQ5AABAQAAAnpcAAEBAAPYAQAC/AAgAnQsGAEAAQAAA'
            'hG0AAEBAAB38PQAIv0AA9mT6AL9AvwAJLmwAZUBAAB0AQAAIAAgAHUAAAAgIAAAAA'
            'AAAAAAAAACzbAAAQEAA//k5AH+/QAAGb5cAQEBAAACy5AAAQAgAAIpAAABACAAAAA'
            'AAAAAAAAkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQk'
            'JCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJ'
            'CQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJC'
            'QkJCQkJCQkJCQkJCQkJCQkJCQkyEi8aQCEJCQkJCQkJCQkJCQkJCTI7OwgILzsyCg'
            'kJCQkJCQkJCQkJCzcJFggvADwGEDc3EhYAMgkJCQkJEjcVJDohGj0LGgYAPT0hCT0'
            'LDyI3CQoBLwAaFgkyEC9AJAE8OgsIMjoABi8kCx4JCQkJCQkeGko8KTcLCxIyNwkJ'
            'CQkWEjwWNUAQPCEAMwgJCQkJCQkSQBcvEkAPAQkyN0AMCQkJCQhBFyEvNy89JCIkM'
            'yItGQwJCQo9RxozIgkyCQoPFxAtDBkgIgkJCQkJCQkJMRoQECJQNi9EIAAgCQkJCQ'
            'kSUA88UAYeBjELICA8HiI=\n')
        self.assertEquals(renderer.raster_data, raw_data)

        self.assertEquals(dc.calls,
                          [('BeginDrawing',),
                           ('SetFont', "label font"),
                           ('EndDrawing',)])

    def test_point_map_projection(self):
        """Test BaseRenderer with point layer and map projection"""
        table = MemoryTable([("type", FIELDTYPE_STRING),
                             ("value", FIELDTYPE_DOUBLE),
                             ("code", FIELDTYPE_INT)],
                            [("UNKNOWN", 0.0, 0)])
        shapes = [[[(10, 10)]]]
        store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)

        map = Map("TestBaseRenderer")
        map.SetProjection(MockProjection(-3, 3))
        layer = Layer("point layer", store)
        map.AddLayer(layer)
        self.to_destroy.append(map)

        dc = MockDC()
        renderer = SimpleRenderer(dc, map, 2, (10, 10))

        renderer.render_map()

        self.assertEquals(dc.calls,
                          [('BeginDrawing',),
                           ('SetBrush', ('brush', Transparent)),
                           ('SetPen', ('pen', Color(0, 0, 0), 1)),
                           ('DrawEllipse', -55, -55, 10, 10),
                           ('SetFont', "label font"),
                           ('EndDrawing',)])

    def test_point_layer_projection(self):
        """Test BaseRenderer with point layer and layer projection"""
        table = MemoryTable([("type", FIELDTYPE_STRING),
                             ("value", FIELDTYPE_DOUBLE),
                             ("code", FIELDTYPE_INT)],
                            [("UNKNOWN", 0.0, 0)])
        shapes = [[[(9, 9)]]]
        store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)

        map = Map("TestBaseRenderer")
        layer = Layer("point layer", store)
        layer.SetProjection(MockProjection(3, -3))
        map.AddLayer(layer)
        self.to_destroy.append(map)

        dc = MockDC()
        renderer = SimpleRenderer(dc, map, 2, (10, 10))

        renderer.render_map()

        self.assertEquals(dc.calls,
                          [('BeginDrawing',),
                           ('SetBrush', ('brush', Transparent)),
                           ('SetPen', ('pen', Color(0, 0, 0), 1)),
                           ('DrawEllipse', 11, 11, 10, 10),
                           ('SetFont', "label font"),
                           ('EndDrawing',)])

    def test_point_layer_and_map_projection(self):
        """Test BaseRenderer with point layer and layer and map projection"""
        table = MemoryTable([("type", FIELDTYPE_STRING),
                             ("value", FIELDTYPE_DOUBLE),
                             ("code", FIELDTYPE_INT)],
                            [("UNKNOWN", 0.0, 0)])
        shapes = [[[(9, 9)]]]
        store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)

        map = Map("TestBaseRenderer")
        map.SetProjection(MockProjection(-3, 3))
        layer = Layer("point layer", store)
        layer.SetProjection(MockProjection(3, -3))
        map.AddLayer(layer)
        self.to_destroy.append(map)

        dc = MockDC()
        renderer = SimpleRenderer(dc, map, 2, (10, 10))

        renderer.render_map()

        self.assertEquals(dc.calls,
                          [('BeginDrawing',),
                           ('SetBrush', ('brush', Transparent)),
                           ('SetPen', ('pen', Color(0, 0, 0), 1)),
                           ('DrawEllipse', -13, 23, 10, 10),
                           ('SetFont', "label font"),
                           ('EndDrawing',)])


    def test_point_with_classification(self):
        """Test BaseRenderer with point layer and classification"""
        table = MemoryTable([("type", FIELDTYPE_STRING),
                             ("value", FIELDTYPE_DOUBLE),
                             ("code", FIELDTYPE_INT)],
                            [("UNKNOWN", 0.0, 0),
                             ("UNKNOWN", 0.0, 1)])
        shapes = [[[(0, 0)]], [[(10, 10)]]]
        store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)

        map = Map("TestBaseRenderer")
        layer = Layer("point layer", store)
        group = ClassGroupSingleton(1)
        group.GetProperties().SetFill(Color(0, 0, 1))
        layer.GetClassification().AppendGroup(group)
        layer.SetClassificationColumn("code")

        map.AddLayer(layer)
        self.to_destroy.append(map)

        dc = MockDC()
        renderer = SimpleRenderer(dc, map, 2, (10, 10))

        renderer.render_map()

        self.assertEquals(dc.calls,
                          [('BeginDrawing',),
                           ('SetBrush', ('brush', Transparent)),
                           ('SetPen', ('pen', Color(0, 0, 0), 1)),
                           ('DrawEllipse', 5, 5, 10, 10),
                           ('SetBrush', ('brush', Color(0, 0, 1))),
                           ('SetPen', ('pen', Color(0, 0, 0), 1)),
                           ('DrawEllipse', 25, -15, 10, 10),
                           ('SetFont', "label font"),
                           ('EndDrawing',)])


if __name__ == "__main__":
    support.run_tests()
1	bh	1552	# Copyright (C) 2003 by Intevation GmbH
2			# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with the software for details.
7
8			"""Test Thuban.Model.baserenderer"""
9
10			__version__ = "$Revision$"
11			# $Source$
12			# $Id$
13
14			import os
15			import binascii
16			import unittest
17
18	bh	1585	from mockgeo import SimpleShapeStore
19	bh	1552	import support
20			support.initthuban()
21
22			from Thuban.Model.color import Transparent, Color
23	bh	1557	from Thuban.Model.data import SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT
24	bh	1552	from Thuban.Model.map import Map
25			from Thuban.Model.layer import Layer, RasterLayer
26			from Thuban.Model.table import MemoryTable, \
27			FIELDTYPE_DOUBLE, FIELDTYPE_INT, FIELDTYPE_STRING
28	bh	1585	from Thuban.Model.classification import ClassGroupSingleton
29	bh	1555	import Thuban.Model.resource
30	bh	1552
31	bh	1585
32	bh	1552	from Thuban.UI.baserenderer import BaseRenderer
33
34
35			class MockDC:
36
37			def __init__(self, size = None):
38			self.calls = []
39			self.size = size
40
41			def GetSizeTuple(self):
42			return self.size
43
44			def __getattr__(self, attr):
45			def method(*args):
46			self.calls.append((attr,) + args)
47			return method
48
49			class P:
50
51			"""A simple point"""
52
53			def __init__(self, x, y):
54			self.x = x
55			self.y = y
56
57			def __eq__(self, other):
58			return self.x == other.x and self.y == other.y
59
60			def __ne__(self, other):
61			return self.x != other.x and self.y != other.y
62
63			def __repr__(self):
64			return "P(%r, %r)" % (self.x, self.y)
65
66
67			class SimpleRenderer(BaseRenderer):
68
69			TRANSPARENT_PEN = ("pen", Transparent)
70			TRANSPARENT_BRUSH = ("brush", Transparent)
71
72			def make_point(self, x, y):
73			return P(x, y)
74
75			def tools_for_property(self, prop):
76			fill = prop.GetFill()
77			brush = ("brush", fill)
78
79			stroke = prop.GetLineColor()
80			stroke_width = prop.GetLineWidth()
81			if stroke is Transparent:
82			pen = ("pen", Transparent)
83			else:
84			pen = ("pen", stroke, stroke_width)
85
86			return pen, brush
87
88			def label_font(self):
89			return "label font"
90
91			def draw_raster_data(self, data):
92			self.raster_data = data
93
94	bh	1557
95	bh	1552	class MockProjection:
96
97			"""Objects that look like projections but simply apply non-uniform scalings
98			"""
99
100			def __init__(self, xscale, yscale):
101			self.xscale = float(xscale)
102			self.yscale = float(yscale)
103
104			def Forward(self, x, y):
105			return (x * self.xscale, y * self.yscale)
106
107			def Inverse(self, x, y):
108			return (x / self.xscale, y / self.yscale)
109
110
111			class TestBaseRenderer(unittest.TestCase):
112
113			def setUp(self):
114			"""Set self.to_destroy to an empty list
115
116			Test should put all objects whose Destroy should be called atunittest.main
117			the end into this list so that they're destroyed in tearDown
118			"""
119			self.to_destroy = []
120
121			def tearDown(self):
122			for obj in self.to_destroy:
123			obj.Destroy()
124
125			def test_arc_no_projection(self):
126			"""Test BaseRenderer with arc layer and no projections"""
127			table = MemoryTable([("type", FIELDTYPE_STRING),
128			("value", FIELDTYPE_DOUBLE),
129			("code", FIELDTYPE_INT)],
130			[("UNKNOWN", 0.0, 0)])
131			shapes = [[[(0, 0), (10, 10)]]]
132			store = SimpleShapeStore(SHAPETYPE_ARC, shapes, table)
133
134			map = Map("TestBaseRenderer")
135			self.to_destroy.append(map)
136			layer = Layer("arc layer", store)
137			map.AddLayer(layer)
138
139			dc = MockDC()
140	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
141	bh	1552
142	bh	1867	renderer.render_map()
143	bh	1552
144			self.assertEquals(dc.calls,
145			[('BeginDrawing',),
146			('SetBrush', ('brush', Transparent)),
147			('SetPen', ('pen', Color(0, 0, 0), 1)),
148			('DrawLines', [P(10, 10), P(30, -10)]),
149			('SetFont', "label font"),
150			('EndDrawing',)])
151
152			def test_polygon_no_projection(self):
153			"""Test BaseRenderer with polygon layer and no projections"""
154			table = MemoryTable([("type", FIELDTYPE_STRING),
155			("value", FIELDTYPE_DOUBLE),
156			("code", FIELDTYPE_INT)],
157			[("UNKNOWN", 0.0, 0)])
158			shapes = [[[(0, 0), (10, 10), (10, 0), (0, 0)]]]
159			store = SimpleShapeStore(SHAPETYPE_POLYGON, shapes, table)
160
161			map = Map("TestBaseRenderer")
162			layer = Layer("polygon layer", store)
163			prop = layer.GetClassification().GetDefaultGroup().GetProperties()
164			prop.SetFill(Color(1, 1, 1))
165
166			map.AddLayer(layer)
167			self.to_destroy.append(map)
168
169			dc = MockDC()
170	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
171	bh	1552
172	bh	1867	renderer.render_map()
173	bh	1552
174			self.assertEquals(dc.calls,
175			[('BeginDrawing',),
176			('SetBrush', ('brush', Color(1, 1, 1))),
177			('SetPen', ('pen', Transparent)),
178			('DrawPolygon', [P(10, 10), P(30, -10), P(30, 10),
179			P(10, 10)]),
180			('SetBrush', ('brush', Transparent)),
181			('SetPen', ('pen', Color(0, 0, 0), 1)),
182			('DrawLines', [P(10, 10), P(30, -10), P(30, 10),
183			P(10, 10)]),
184			('SetFont', "label font"),
185			('EndDrawing',)])
186
187			def test_complex_polygon(self):
188			"""Test BaseRenderer with complex polygon and no projections"""
189			# A square inside a sqare. This has to be drawn with at least a
190			# draw polygon call and two draw lines calls.
191			shapes = [[[(0, 0), (0, 10), (10, 10), (10, 0), (0, 0)],
192			[(2, 2), (8, 2), (8, 8), (2, 8), (2, 2)]]]
193
194			table = MemoryTable([("type", FIELDTYPE_STRING),
195			("value", FIELDTYPE_DOUBLE),
196			("code", FIELDTYPE_INT)],
197			[("UNKNOWN", 0.0, 0)])
198			store = SimpleShapeStore(SHAPETYPE_POLYGON, shapes, table)
199
200			map = Map("TestBaseRenderer")
201			layer = Layer("polygon layer", store)
202			prop = layer.GetClassification().GetDefaultGroup().GetProperties()
203			prop.SetFill(Color(1, 1, 1))
204
205			map.AddLayer(layer)
206			self.to_destroy.append(map)
207
208			dc = MockDC()
209	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
210	bh	1552
211	bh	1867	renderer.render_map()
212	bh	1552
213			self.assertEquals(dc.calls,
214			[('BeginDrawing',),
215			('SetBrush', ('brush', Color(1, 1, 1))),
216			('SetPen', ('pen', Transparent)),
217			('DrawPolygon',
218			[P(10, 10), P(10, -10), P(30, -10), P(30, 10),
219			P(10, 10),
220			P(14, 6), P(26, 6), P(26, -6), P(14, -6),
221			P(14, 6),
222			P(10, 10)]),
223			('SetBrush', ('brush', Transparent)),
224			('SetPen', ('pen', Color(0, 0, 0), 1)),
225			('DrawLines', [P(10, 10), P(10, -10), P(30, -10),
226			P(30, 10), P(10, 10)]),
227			('DrawLines', [P(14, 6), P(26, 6), P(26, -6),
228			P(14, -6), P(14, 6)]),
229			('SetFont', "label font"),
230			('EndDrawing',)])
231
232			def test_point_no_projection(self):
233			"""Test BaseRenderer with point layer and no projections"""
234			table = MemoryTable([("type", FIELDTYPE_STRING),
235			("value", FIELDTYPE_DOUBLE),
236			("code", FIELDTYPE_INT)],
237			[("UNKNOWN", 0.0, 0),
238			("UNKNOWN", 0.0, 1)])
239			shapes = [[[(0, 0)]], [[(10, 10)]]]
240			store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)
241
242			map = Map("TestBaseRenderer")
243			layer = Layer("point layer", store)
244			map.AddLayer(layer)
245			self.to_destroy.append(map)
246
247			dc = MockDC()
248	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
249	bh	1552
250	bh	1867	renderer.render_map()
251	bh	1552
252			self.assertEquals(dc.calls,
253			[('BeginDrawing',),
254			('SetBrush', ('brush', Transparent)),
255			('SetPen', ('pen', Color(0, 0, 0), 1)),
256			('DrawEllipse', 5, 5, 10, 10),
257			('SetBrush', ('brush', Transparent)),
258			('SetPen', ('pen', Color(0, 0, 0), 1)),
259			('DrawEllipse', 25, -15, 10, 10),
260			('SetFont', "label font"),
261			('EndDrawing',)])
262
263			def test_raster_no_projection(self):
264			"""Test BaseRenderer with raster layer and no projections
265
266			This test is very simple minded and perhaps can easily fail due
267			to round-off errors. It simply compares the complete BMP file
268			returned by gdalwarp.ProjectRasterFile to a BMP file data.
269			"""
270	bh	1555	if not Thuban.Model.resource.has_gdal_support():
271			raise support.SkipTest("No gdal support")
272
273	bh	1552	map = Map("TestBaseRenderer")
274
275			layer = RasterLayer("raster layer",
276			os.path.join("..", "Data", "iceland",
277			"island.tif"))
278			map.AddLayer(layer)
279			self.to_destroy.append(map)
280
281			dc = MockDC(size = (20, 20))
282	bh	1867	renderer = SimpleRenderer(dc, map, 34, (800, 2250))
283	bh	1552
284	bh	1867	renderer.render_map()
285	bh	1552
286			# The following commented out code block can be used to generate
287			# the base64 coded reference image data
288			#hexed = binascii.b2a_base64(renderer.raster_data)
289			#while hexed:
290			# print repr(hexed[:65])
291			# hexed = hexed[65:]
292
293			# The reference data as a base64 coded BMP image
294			raw_data = binascii.a2b_base64(
295			'Qk3GBQAAAAAAADYEAAAoAAAAFAAAABQAAAABAAgAAAAAAJABAAAAAAAAAAAAAAABA'
296			'AAAAAAAApYOAALGAgAGfjoAHmZyACZ2egAujo4AArICAE66GgACngIA5mZSAJqONg'
297			'ACzgIAAoIyABZqZgAO4uYAAtICAAKqAgAScloAAtYCADKepgAS2t4AAooiAALaAgA'
298			'CtgIAHsbOAAp2TgACogIAFtbaACqOigAidnoAAuICADKaogACfjoAAr4CAAKSFgAm'
299			'fnoAAo4eABrS1gAibnoAHsbKAAp6SgACmg4AGs7SACLCxgAqioIAAoYqAAZ6RgACm'
300			'goAKrK6AALmAgAC3gIAApIaABZqagACngYAAo4iAAKmAgAivsYAJoJ6AALCAgACyg'
301			'IAAq4CAAKWEgAOclYALpqeAAK6AgACgjYAEm5eAAKKKgAGekIAHmp6ABpmcgAChi4'
302			'ALpaaACJyegAClhYAEnJeAAZ+QgAqhoIADnZSAB5mdgACiiYAJnp6ACqGegAqrrYA'
303			'GmpuAB5megACkh4ALqqyAA52VgAulpYAAoI6AAZ+PgASbmIALpKWAA7m5gAWbmYAG'
304			'mpyAC6SjgAqioYADnZOAA7q6gAianoALqauABpqagAqgnoAEnJWAAp6RgAWbmIACu'
305			'7uACqGfgAqiooAMqauAAby8gAmusIAMp6qAC6WngAyoqoABvb2AC6SkgAS3uIAJra'
306			'+AB7KzgAynqIALq62ADKirgAC+voAGsrSABLi4gAG8vYADubqAC6qtgAuprIABvb6'
307			'ACLCygAW2t4AKra+AAru8gAS4uYACuruAAry8gAG+voAAEBAAFhkZABAQEAABp6fA'
308			'EBACAAAgPwAAPu/AJE9CgBACAAALj1BAEAICAAGPAAAQAgAAAY8+gBACL8AJTxXAA'
309			'gIQAAAPEAAAAgIAAY8QABACAgAAGQAAABAAAAALpoAAEBAAAAALgAAAEAABkAGAEA'
310			'IQAD2AEAAvwAIAJAu2ABAQEAALmQ5AEBAQAAAnp8AAEAIAAD4+gAAv78An5rDAEBA'
311			'QAAuhAcAQEBAAAb8AABAvwAAAGQKAABAAABpLksAQEAIAC4ACwBAAAAAAPkGAAC/Q'
312			'AD2APoAvwC/AJ0umgBAQEAAAGRkAABAQAAGnp8AQEAIAPcA/AC/AL8A7D0GAEAIQA'
313			'D4hAAAv0AAAAD8QAAAvwgA92T6AL9AvwDsLlcAQEBAAC4AQABAAAgA+EAAAL8IAAA'
314			'8AAAACAAAAJ8uVgBAQEAAAGQ5AABAQAAAnpcAAEBAAPYAQAC/AAgAnQsGAEAAQAAA'
315			'hG0AAEBAAB38PQAIv0AA9mT6AL9AvwAJLmwAZUBAAB0AQAAIAAgAHUAAAAgIAAAAA'
316			'AAAAAAAAACzbAAAQEAA//k5AH+/QAAGb5cAQEBAAACy5AAAQAgAAIpAAABACAAAAA'
317			'AAAAAAAAkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQk'
318			'JCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJ'
319			'CQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJC'
320			'QkJCQkJCQkJCQkJCQkJCQkJCQkyEi8aQCEJCQkJCQkJCQkJCQkJCTI7OwgILzsyCg'
321			'kJCQkJCQkJCQkJCzcJFggvADwGEDc3EhYAMgkJCQkJEjcVJDohGj0LGgYAPT0hCT0'
322			'LDyI3CQoBLwAaFgkyEC9AJAE8OgsIMjoABi8kCx4JCQkJCQkeGko8KTcLCxIyNwkJ'
323			'CQkWEjwWNUAQPCEAMwgJCQkJCQkSQBcvEkAPAQkyN0AMCQkJCQhBFyEvNy89JCIkM'
324			'yItGQwJCQo9RxozIgkyCQoPFxAtDBkgIgkJCQkJCQkJMRoQECJQNi9EIAAgCQkJCQ'
325			'kSUA88UAYeBjELICA8HiI=\n')
326			self.assertEquals(renderer.raster_data, raw_data)
327
328			self.assertEquals(dc.calls,
329			[('BeginDrawing',),
330			('SetFont', "label font"),
331			('EndDrawing',)])
332
333			def test_point_map_projection(self):
334			"""Test BaseRenderer with point layer and map projection"""
335			table = MemoryTable([("type", FIELDTYPE_STRING),
336			("value", FIELDTYPE_DOUBLE),
337			("code", FIELDTYPE_INT)],
338			[("UNKNOWN", 0.0, 0)])
339			shapes = [[[(10, 10)]]]
340			store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)
341
342			map = Map("TestBaseRenderer")
343			map.SetProjection(MockProjection(-3, 3))
344			layer = Layer("point layer", store)
345			map.AddLayer(layer)
346			self.to_destroy.append(map)
347
348			dc = MockDC()
349	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
350	bh	1552
351	bh	1867	renderer.render_map()
352	bh	1552
353			self.assertEquals(dc.calls,
354			[('BeginDrawing',),
355			('SetBrush', ('brush', Transparent)),
356			('SetPen', ('pen', Color(0, 0, 0), 1)),
357			('DrawEllipse', -55, -55, 10, 10),
358			('SetFont', "label font"),
359			('EndDrawing',)])
360
361			def test_point_layer_projection(self):
362			"""Test BaseRenderer with point layer and layer projection"""
363			table = MemoryTable([("type", FIELDTYPE_STRING),
364			("value", FIELDTYPE_DOUBLE),
365			("code", FIELDTYPE_INT)],
366			[("UNKNOWN", 0.0, 0)])
367			shapes = [[[(9, 9)]]]
368			store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)
369
370			map = Map("TestBaseRenderer")
371			layer = Layer("point layer", store)
372			layer.SetProjection(MockProjection(3, -3))
373			map.AddLayer(layer)
374			self.to_destroy.append(map)
375
376			dc = MockDC()
377	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
378	bh	1552
379	bh	1867	renderer.render_map()
380	bh	1552
381			self.assertEquals(dc.calls,
382			[('BeginDrawing',),
383			('SetBrush', ('brush', Transparent)),
384			('SetPen', ('pen', Color(0, 0, 0), 1)),
385			('DrawEllipse', 11, 11, 10, 10),
386			('SetFont', "label font"),
387			('EndDrawing',)])
388
389			def test_point_layer_and_map_projection(self):
390			"""Test BaseRenderer with point layer and layer and map projection"""
391			table = MemoryTable([("type", FIELDTYPE_STRING),
392			("value", FIELDTYPE_DOUBLE),
393			("code", FIELDTYPE_INT)],
394			[("UNKNOWN", 0.0, 0)])
395			shapes = [[[(9, 9)]]]
396			store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)
397
398			map = Map("TestBaseRenderer")
399			map.SetProjection(MockProjection(-3, 3))
400			layer = Layer("point layer", store)
401			layer.SetProjection(MockProjection(3, -3))
402			map.AddLayer(layer)
403			self.to_destroy.append(map)
404
405			dc = MockDC()
406	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
407	bh	1552
408	bh	1867	renderer.render_map()
409	bh	1552
410			self.assertEquals(dc.calls,
411			[('BeginDrawing',),
412			('SetBrush', ('brush', Transparent)),
413			('SetPen', ('pen', Color(0, 0, 0), 1)),
414			('DrawEllipse', -13, 23, 10, 10),
415			('SetFont', "label font"),
416			('EndDrawing',)])
417
418
419	bh	1591	def test_point_with_classification(self):
420			"""Test BaseRenderer with point layer and classification"""
421			table = MemoryTable([("type", FIELDTYPE_STRING),
422			("value", FIELDTYPE_DOUBLE),
423			("code", FIELDTYPE_INT)],
424			[("UNKNOWN", 0.0, 0),
425			("UNKNOWN", 0.0, 1)])
426			shapes = [[[(0, 0)]], [[(10, 10)]]]
427			store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)
428	bh	1552
429	bh	1591	map = Map("TestBaseRenderer")
430			layer = Layer("point layer", store)
431			group = ClassGroupSingleton(1)
432			group.GetProperties().SetFill(Color(0, 0, 1))
433			layer.GetClassification().AppendGroup(group)
434			layer.SetClassificationColumn("code")
435
436			map.AddLayer(layer)
437			self.to_destroy.append(map)
438
439			dc = MockDC()
440	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
441	bh	1591
442	bh	1867	renderer.render_map()
443	bh	1591
444			self.assertEquals(dc.calls,
445			[('BeginDrawing',),
446			('SetBrush', ('brush', Transparent)),
447			('SetPen', ('pen', Color(0, 0, 0), 1)),
448			('DrawEllipse', 5, 5, 10, 10),
449			('SetBrush', ('brush', Color(0, 0, 1))),
450			('SetPen', ('pen', Color(0, 0, 0), 1)),
451			('DrawEllipse', 25, -15, 10, 10),
452			('SetFont', "label font"),
453			('EndDrawing',)])
454
455
456	bh	1552	if __name__ == "__main__":
457			support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision