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