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

import support
support.initthuban()

from Thuban.Model.color import Transparent, Color
from Thuban.Model.data import Shape, 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.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 SimpleShapeStore:

    def __init__(self, shapetype, shapes, table):
        self.shapetype = shapetype
        self.shapes = shapes
        self.table = table
        assert table.NumRows() == len(shapes)

    def ShapeType(self):
        return self.shapetype

    def Table(self):
        return self.table

    def NumShapes(self):
        return len(self.shapes)

    def Shape(self, index):
        return Shape(self.shapes[index])


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, 2, (10, 10))

        renderer.render_map(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, 2, (10, 10))

        renderer.render_map(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, 2, (10, 10))

        renderer.render_map(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, 2, (10, 10))

        renderer.render_map(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.
        """
        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, 34, (800, 2250))

        renderer.render_map(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, 2, (10, 10))

        renderer.render_map(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, 2, (10, 10))

        renderer.render_map(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, 2, (10, 10))

        renderer.render_map(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',)])


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