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 BaseLayer, 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, \
     add_renderer_extension, init_renderer_extensions

if Thuban.Model.resource.has_gdal_support():
    from gdalwarp import ProjectRasterFile

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, x, y, data, format='BMP'):
        self.raster_data = data
        self.raster_format = format

    def projected_raster_layer(self, layer, srcProj, dstProj, extents,
                               resolution, dimensions, options):

        if not Thuban.Model.resource.has_gdal_support():
            raise support.SkipTest("No gdal support")

        #print srcProj, dstProj,extents, resolution, dimensions, options

        return ProjectRasterFile(layer.GetImageFilename(), 
                                 srcProj, dstProj,
                                 extents, resolution, dimensions, 
                                 options)
 
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_projected_raster_layer(self):
        if not Thuban.Model.resource.has_gdal_support():
            raise support.SkipTest("No gdal support")

        layer = RasterLayer("raster layer",
                            os.path.join("..", "Data", "iceland",
                                         "island.tif"))

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

        # The reference data as a base64 coded RAW image
        raw_data = binascii.a2b_base64(
            'UmbmUmbmUmbmUmbmUmbmAtYCJooCAtICAq4CJooCArICAuICArICAuYCAs4COn4CO'
            'n4CAq4CAuICFpICUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmAuYCAqICAqoCAqoCFp'
            'ICJooCIo4CCpoCQnoGOn4CDpYCOn4CUmbmUmbmNo6aEpYCLoYCAqICGpICFpICUmb'
            'mAt4CUmbmNo6aAtICArYCAqoCKoYCMoICTnYKOn4CFpICUmbmUmbmUmbmUmbmAp4C'
            'NoICArYCAr4CCpoCAqYCCpoCEpYCHo4CFpICHo4CGpICFpICKoYCTnYKMoICAp4CU'
            'mbmUmbmUmbmUmbmUmbmUmbmAtYCAroCArYCCpoCAtYCAroCAtICAsYCUmbmAt4CAq'
            'YCAroCMoICAs4CAs4CAtYCAt4CAqYCUmbmUmbmUmbmUmbmAtoCAtYCAq4CAtoCBp4'
            'CAroCAqoCAq4CAr4CDpYCGpICAt4CAsICDpYCArICCpoCHo4CAs4CAuICUmbmUmbm'
            'UmbmUmbmUmbmUmbmAuICAqICFpYCAq4CDpoCAqYCFpICAqYCUmbmNo6aAsYCCpoCD'
            'pYCAqICAtoCUmbmAt4CAqoCCpoCAroCHo4CAsYCAq4CAsICAs4CAp4CUmbmAtYCAq'
            'YCIooCHo4CAsICAr4CAqICEpYCAs4CAqICArICDpYCEpYCEpYCAr4CUmbmEpYCAs4'
            'CAtICAs4CAqYCUmbmAtoCAp4CCpoCDpYCAq4CArICAqoCAqYCAqYCAtYCAtoCDpYC'
            'At4CUmbmUmbmUmbmUmbmAt4CAsoCAsoCAp4CAp4CCpoCAsoCAt4CNo6aUmbmUmbmU'
            'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmAt4CAtYCCpoCAqICAroCAr4CUmbmUm'
            'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
            'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
            'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmU'
            'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUm'
            'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
            'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
            'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmU'
            'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUm'
            'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
            'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
            'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm\n')

        raw_mask = binascii.a2b_base64(
            '//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P/'
            '/8P//8P//8P//8P//8P\n')

        raw_mask_inverted = binascii.a2b_base64(
            'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
            'AAAAAAAAAAAAAAAAAAA\n')

        raw_alpha = binascii.a2b_base64(
            '/////////////////////////////////////////////////////////////'
            '/////////////////////////////////////////////////////////////'
            '/////////////////////////////////////////////////////////////'
            '/////////////////////////////////////////////////////////////'
            '/////////////////////////////////////////////////////////////'
            '/////////////////////////////////////////////////////////////'
            '/////////////////////////////////////////////////////////////'
            '/////////////////////////////////////////////////////////////'
            '/////////////////////////////////////////////w==\n')

        for opts, data in [[1,   (raw_data, raw_mask,          None)],
                           [1|4, (raw_data, raw_mask_inverted, None)],
                           [2,   (raw_data, None,              raw_alpha)]]:

            img_data = renderer.projected_raster_layer(layer, "", "", 
                            (-24, 65, -23, 66), [0, 0], (20, 20), opts)
            self.assertEquals(img_data, data)

    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"))
        layer.SetMaskType(layer.MASK_NONE)

        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[2][0])
        #while hexed:
            #print repr(hexed[:65])
            #hexed = hexed[65:]

        # The reference data as a base64 coded RAW image
        raw_data = binascii.a2b_base64(
            'UmbmUmbmUmbmUmbmUmbmAtYCJooCAtICAq4CJooCArICAuICArICAuYCAs4COn4CO'
            'n4CAq4CAuICFpICUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmAuYCAqICAqoCAqoCFp'
            'ICJooCIo4CCpoCQnoGOn4CDpYCOn4CUmbmUmbmNo6aEpYCLoYCAqICGpICFpICUmb'
            'mAt4CUmbmNo6aAtICArYCAqoCKoYCMoICTnYKOn4CFpICUmbmUmbmUmbmUmbmAp4C'
            'NoICArYCAr4CCpoCAqYCCpoCEpYCHo4CFpICHo4CGpICFpICKoYCTnYKMoICAp4CU'
            'mbmUmbmUmbmUmbmUmbmUmbmAtYCAroCArYCCpoCAtYCAroCAtICAsYCUmbmAt4CAq'
            'YCAroCMoICAs4CAs4CAtYCAt4CAqYCUmbmUmbmUmbmUmbmAtoCAtYCAq4CAtoCBp4'
            'CAroCAqoCAq4CAr4CDpYCGpICAt4CAsICDpYCArICCpoCHo4CAs4CAuICUmbmUmbm'
            'UmbmUmbmUmbmUmbmAuICAqICFpYCAq4CDpoCAqYCFpICAqYCUmbmNo6aAsYCCpoCD'
            'pYCAqICAtoCUmbmAt4CAqoCCpoCAroCHo4CAsYCAq4CAsICAs4CAp4CUmbmAtYCAq'
            'YCIooCHo4CAsICAr4CAqICEpYCAs4CAqICArICDpYCEpYCEpYCAr4CUmbmEpYCAs4'
            'CAtICAs4CAqYCUmbmAtoCAp4CCpoCDpYCAq4CArICAqoCAqYCAqYCAtYCAtoCDpYC'
            'At4CUmbmUmbmUmbmUmbmAt4CAsoCAsoCAp4CAp4CCpoCAsoCAt4CNo6aUmbmUmbmU'
            'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmAt4CAtYCCpoCAqICAroCAr4CUmbmUm'
            'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
            'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
            'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmU'
            'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUm'
            'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
            'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
            'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmU'
            'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUm'
            'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
            'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
            'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm\n')

        self.assertEquals(renderer.raster_data, 
                          (20,20,(raw_data, None, None)))

        self.assertEquals(renderer.raster_format, "RAW")

        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',)])


    def test_renderer_extension(self):
        """Test renderer with a renderer extension"""
        class MyLayer(BaseLayer):
            pass

        calls = []
        def my_renderer(renderer, layer):
            calls.append((renderer, layer))
            return ()

        add_renderer_extension(MyLayer, my_renderer)

        try:
            map = Map("test_renderer_extension")
            layer = MyLayer("my layer")
            map.AddLayer(layer)
            self.to_destroy.append(map)

            dc = MockDC()
            renderer = SimpleRenderer(dc, map, 2, (10, 10))
            renderer.render_map()
        finally:
            init_renderer_extensions()

        self.assertEquals(calls, [(renderer, layer)])


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	bh	1928	from Thuban.Model.layer import BaseLayer, Layer, RasterLayer
26	bh	1552	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	1928	from Thuban.UI.baserenderer import BaseRenderer, \
33			add_renderer_extension, init_renderer_extensions
34	bh	1552
35	jonathan	2571	if Thuban.Model.resource.has_gdal_support():
36			from gdalwarp import ProjectRasterFile
37	bh	1552
38			class MockDC:
39
40			def __init__(self, size = None):
41			self.calls = []
42			self.size = size
43
44			def GetSizeTuple(self):
45			return self.size
46
47			def __getattr__(self, attr):
48			def method(*args):
49			self.calls.append((attr,) + args)
50			return method
51
52			class P:
53
54			"""A simple point"""
55
56			def __init__(self, x, y):
57			self.x = x
58			self.y = y
59
60			def __eq__(self, other):
61			return self.x == other.x and self.y == other.y
62
63			def __ne__(self, other):
64			return self.x != other.x and self.y != other.y
65
66			def __repr__(self):
67			return "P(%r, %r)" % (self.x, self.y)
68
69
70			class SimpleRenderer(BaseRenderer):
71
72			TRANSPARENT_PEN = ("pen", Transparent)
73			TRANSPARENT_BRUSH = ("brush", Transparent)
74
75			def make_point(self, x, y):
76			return P(x, y)
77
78			def tools_for_property(self, prop):
79			fill = prop.GetFill()
80			brush = ("brush", fill)
81
82			stroke = prop.GetLineColor()
83			stroke_width = prop.GetLineWidth()
84			if stroke is Transparent:
85			pen = ("pen", Transparent)
86			else:
87			pen = ("pen", stroke, stroke_width)
88
89			return pen, brush
90
91			def label_font(self):
92			return "label font"
93
94	jonathan	2551	def draw_raster_data(self, x, y, data, format='BMP'):
95	bh	1552	self.raster_data = data
96	bh	1928	self.raster_format = format
97	bh	1552
98	jonathan	2571	def projected_raster_layer(self, layer, srcProj, dstProj, extents,
99			resolution, dimensions, options):
100	bh	1557
101	jonathan	2571	if not Thuban.Model.resource.has_gdal_support():
102			raise support.SkipTest("No gdal support")
103
104			#print srcProj, dstProj,extents, resolution, dimensions, options
105
106			return ProjectRasterFile(layer.GetImageFilename(),
107			srcProj, dstProj,
108			extents, resolution, dimensions,
109			options)
110
111	bh	1552	class MockProjection:
112
113			"""Objects that look like projections but simply apply non-uniform scalings
114			"""
115
116			def __init__(self, xscale, yscale):
117			self.xscale = float(xscale)
118			self.yscale = float(yscale)
119
120			def Forward(self, x, y):
121			return (x * self.xscale, y * self.yscale)
122
123			def Inverse(self, x, y):
124			return (x / self.xscale, y / self.yscale)
125
126
127			class TestBaseRenderer(unittest.TestCase):
128
129			def setUp(self):
130			"""Set self.to_destroy to an empty list
131
132			Test should put all objects whose Destroy should be called atunittest.main
133			the end into this list so that they're destroyed in tearDown
134			"""
135			self.to_destroy = []
136
137			def tearDown(self):
138			for obj in self.to_destroy:
139			obj.Destroy()
140
141			def test_arc_no_projection(self):
142			"""Test BaseRenderer with arc layer and no projections"""
143			table = MemoryTable([("type", FIELDTYPE_STRING),
144			("value", FIELDTYPE_DOUBLE),
145			("code", FIELDTYPE_INT)],
146			[("UNKNOWN", 0.0, 0)])
147			shapes = [[[(0, 0), (10, 10)]]]
148			store = SimpleShapeStore(SHAPETYPE_ARC, shapes, table)
149
150			map = Map("TestBaseRenderer")
151			self.to_destroy.append(map)
152			layer = Layer("arc layer", store)
153			map.AddLayer(layer)
154
155			dc = MockDC()
156	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
157	bh	1552
158	bh	1867	renderer.render_map()
159	bh	1552
160			self.assertEquals(dc.calls,
161			[('BeginDrawing',),
162			('SetBrush', ('brush', Transparent)),
163			('SetPen', ('pen', Color(0, 0, 0), 1)),
164			('DrawLines', [P(10, 10), P(30, -10)]),
165			('SetFont', "label font"),
166			('EndDrawing',)])
167
168			def test_polygon_no_projection(self):
169			"""Test BaseRenderer with polygon layer and no projections"""
170			table = MemoryTable([("type", FIELDTYPE_STRING),
171			("value", FIELDTYPE_DOUBLE),
172			("code", FIELDTYPE_INT)],
173			[("UNKNOWN", 0.0, 0)])
174			shapes = [[[(0, 0), (10, 10), (10, 0), (0, 0)]]]
175			store = SimpleShapeStore(SHAPETYPE_POLYGON, shapes, table)
176
177			map = Map("TestBaseRenderer")
178			layer = Layer("polygon layer", store)
179			prop = layer.GetClassification().GetDefaultGroup().GetProperties()
180			prop.SetFill(Color(1, 1, 1))
181
182			map.AddLayer(layer)
183			self.to_destroy.append(map)
184
185			dc = MockDC()
186	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
187	bh	1552
188	bh	1867	renderer.render_map()
189	bh	1552
190			self.assertEquals(dc.calls,
191			[('BeginDrawing',),
192			('SetBrush', ('brush', Color(1, 1, 1))),
193			('SetPen', ('pen', Transparent)),
194			('DrawPolygon', [P(10, 10), P(30, -10), P(30, 10),
195			P(10, 10)]),
196			('SetBrush', ('brush', Transparent)),
197			('SetPen', ('pen', Color(0, 0, 0), 1)),
198			('DrawLines', [P(10, 10), P(30, -10), P(30, 10),
199			P(10, 10)]),
200			('SetFont', "label font"),
201			('EndDrawing',)])
202
203			def test_complex_polygon(self):
204			"""Test BaseRenderer with complex polygon and no projections"""
205			# A square inside a sqare. This has to be drawn with at least a
206			# draw polygon call and two draw lines calls.
207			shapes = [[[(0, 0), (0, 10), (10, 10), (10, 0), (0, 0)],
208			[(2, 2), (8, 2), (8, 8), (2, 8), (2, 2)]]]
209
210			table = MemoryTable([("type", FIELDTYPE_STRING),
211			("value", FIELDTYPE_DOUBLE),
212			("code", FIELDTYPE_INT)],
213			[("UNKNOWN", 0.0, 0)])
214			store = SimpleShapeStore(SHAPETYPE_POLYGON, shapes, table)
215
216			map = Map("TestBaseRenderer")
217			layer = Layer("polygon layer", store)
218			prop = layer.GetClassification().GetDefaultGroup().GetProperties()
219			prop.SetFill(Color(1, 1, 1))
220
221			map.AddLayer(layer)
222			self.to_destroy.append(map)
223
224			dc = MockDC()
225	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
226	bh	1552
227	bh	1867	renderer.render_map()
228	bh	1552
229			self.assertEquals(dc.calls,
230			[('BeginDrawing',),
231			('SetBrush', ('brush', Color(1, 1, 1))),
232			('SetPen', ('pen', Transparent)),
233			('DrawPolygon',
234			[P(10, 10), P(10, -10), P(30, -10), P(30, 10),
235			P(10, 10),
236			P(14, 6), P(26, 6), P(26, -6), P(14, -6),
237			P(14, 6),
238			P(10, 10)]),
239			('SetBrush', ('brush', Transparent)),
240			('SetPen', ('pen', Color(0, 0, 0), 1)),
241			('DrawLines', [P(10, 10), P(10, -10), P(30, -10),
242			P(30, 10), P(10, 10)]),
243			('DrawLines', [P(14, 6), P(26, 6), P(26, -6),
244			P(14, -6), P(14, 6)]),
245			('SetFont', "label font"),
246			('EndDrawing',)])
247
248			def test_point_no_projection(self):
249			"""Test BaseRenderer with point layer and no projections"""
250			table = MemoryTable([("type", FIELDTYPE_STRING),
251			("value", FIELDTYPE_DOUBLE),
252			("code", FIELDTYPE_INT)],
253			[("UNKNOWN", 0.0, 0),
254			("UNKNOWN", 0.0, 1)])
255			shapes = [[[(0, 0)]], [[(10, 10)]]]
256			store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)
257
258			map = Map("TestBaseRenderer")
259			layer = Layer("point layer", store)
260			map.AddLayer(layer)
261			self.to_destroy.append(map)
262
263			dc = MockDC()
264	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
265	bh	1552
266	bh	1867	renderer.render_map()
267	bh	1552
268			self.assertEquals(dc.calls,
269			[('BeginDrawing',),
270			('SetBrush', ('brush', Transparent)),
271			('SetPen', ('pen', Color(0, 0, 0), 1)),
272			('DrawEllipse', 5, 5, 10, 10),
273			('SetBrush', ('brush', Transparent)),
274			('SetPen', ('pen', Color(0, 0, 0), 1)),
275			('DrawEllipse', 25, -15, 10, 10),
276			('SetFont', "label font"),
277			('EndDrawing',)])
278
279	jonathan	2571	def test_projected_raster_layer(self):
280			if not Thuban.Model.resource.has_gdal_support():
281			raise support.SkipTest("No gdal support")
282
283			layer = RasterLayer("raster layer",
284			os.path.join("..", "Data", "iceland",
285			"island.tif"))
286
287			dc = MockDC(size = (20, 20))
288			renderer = SimpleRenderer(dc, map, 34, (800, 2250))
289
290			# The reference data as a base64 coded RAW image
291			raw_data = binascii.a2b_base64(
292			'UmbmUmbmUmbmUmbmUmbmAtYCJooCAtICAq4CJooCArICAuICArICAuYCAs4COn4CO'
293			'n4CAq4CAuICFpICUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmAuYCAqICAqoCAqoCFp'
294			'ICJooCIo4CCpoCQnoGOn4CDpYCOn4CUmbmUmbmNo6aEpYCLoYCAqICGpICFpICUmb'
295			'mAt4CUmbmNo6aAtICArYCAqoCKoYCMoICTnYKOn4CFpICUmbmUmbmUmbmUmbmAp4C'
296			'NoICArYCAr4CCpoCAqYCCpoCEpYCHo4CFpICHo4CGpICFpICKoYCTnYKMoICAp4CU'
297			'mbmUmbmUmbmUmbmUmbmUmbmAtYCAroCArYCCpoCAtYCAroCAtICAsYCUmbmAt4CAq'
298			'YCAroCMoICAs4CAs4CAtYCAt4CAqYCUmbmUmbmUmbmUmbmAtoCAtYCAq4CAtoCBp4'
299			'CAroCAqoCAq4CAr4CDpYCGpICAt4CAsICDpYCArICCpoCHo4CAs4CAuICUmbmUmbm'
300			'UmbmUmbmUmbmUmbmAuICAqICFpYCAq4CDpoCAqYCFpICAqYCUmbmNo6aAsYCCpoCD'
301			'pYCAqICAtoCUmbmAt4CAqoCCpoCAroCHo4CAsYCAq4CAsICAs4CAp4CUmbmAtYCAq'
302			'YCIooCHo4CAsICAr4CAqICEpYCAs4CAqICArICDpYCEpYCEpYCAr4CUmbmEpYCAs4'
303			'CAtICAs4CAqYCUmbmAtoCAp4CCpoCDpYCAq4CArICAqoCAqYCAqYCAtYCAtoCDpYC'
304			'At4CUmbmUmbmUmbmUmbmAt4CAsoCAsoCAp4CAp4CCpoCAsoCAt4CNo6aUmbmUmbmU'
305			'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmAt4CAtYCCpoCAqICAroCAr4CUmbmUm'
306			'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
307			'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
308			'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmU'
309			'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUm'
310			'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
311			'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
312			'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmU'
313			'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUm'
314			'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
315			'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
316			'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm\n')
317
318			raw_mask = binascii.a2b_base64(
319			'//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P//8P/'
320			'/8P//8P//8P//8P//8P\n')
321
322			raw_mask_inverted = binascii.a2b_base64(
323			'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
324			'AAAAAAAAAAAAAAAAAAA\n')
325
326			raw_alpha = binascii.a2b_base64(
327			'/////////////////////////////////////////////////////////////'
328			'/////////////////////////////////////////////////////////////'
329			'/////////////////////////////////////////////////////////////'
330			'/////////////////////////////////////////////////////////////'
331			'/////////////////////////////////////////////////////////////'
332			'/////////////////////////////////////////////////////////////'
333			'/////////////////////////////////////////////////////////////'
334			'/////////////////////////////////////////////////////////////'
335			'/////////////////////////////////////////////w==\n')
336
337			for opts, data in [[1, (raw_data, raw_mask, None)],
338			[1\|4, (raw_data, raw_mask_inverted, None)],
339			[2, (raw_data, None, raw_alpha)]]:
340
341			img_data = renderer.projected_raster_layer(layer, "", "",
342			(-24, 65, -23, 66), [0, 0], (20, 20), opts)
343			self.assertEquals(img_data, data)
344
345	bh	1552	def test_raster_no_projection(self):
346			"""Test BaseRenderer with raster layer and no projections
347
348			This test is very simple minded and perhaps can easily fail due
349			to round-off errors. It simply compares the complete BMP file
350			returned by gdalwarp.ProjectRasterFile to a BMP file data.
351			"""
352	bh	1555	if not Thuban.Model.resource.has_gdal_support():
353			raise support.SkipTest("No gdal support")
354
355	bh	1552	map = Map("TestBaseRenderer")
356
357			layer = RasterLayer("raster layer",
358			os.path.join("..", "Data", "iceland",
359			"island.tif"))
360	jonathan	2571	layer.SetMaskType(layer.MASK_NONE)
361
362	bh	1552	map.AddLayer(layer)
363			self.to_destroy.append(map)
364
365			dc = MockDC(size = (20, 20))
366	bh	1867	renderer = SimpleRenderer(dc, map, 34, (800, 2250))
367	bh	1552
368	bh	1867	renderer.render_map()
369	bh	1552
370			# The following commented out code block can be used to generate
371			# the base64 coded reference image data
372	jonathan	2562	#hexed = binascii.b2a_base64(renderer.raster_data[2][0])
373	bh	1552	#while hexed:
374	jonathan	2537	#print repr(hexed[:65])
375			#hexed = hexed[65:]
376	bh	1552
377	jonathan	2552	# The reference data as a base64 coded RAW image
378	bh	1552	raw_data = binascii.a2b_base64(
379	jonathan	2537	'UmbmUmbmUmbmUmbmUmbmAtYCJooCAtICAq4CJooCArICAuICArICAuYCAs4COn4CO'
380			'n4CAq4CAuICFpICUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmAuYCAqICAqoCAqoCFp'
381			'ICJooCIo4CCpoCQnoGOn4CDpYCOn4CUmbmUmbmNo6aEpYCLoYCAqICGpICFpICUmb'
382			'mAt4CUmbmNo6aAtICArYCAqoCKoYCMoICTnYKOn4CFpICUmbmUmbmUmbmUmbmAp4C'
383			'NoICArYCAr4CCpoCAqYCCpoCEpYCHo4CFpICHo4CGpICFpICKoYCTnYKMoICAp4CU'
384			'mbmUmbmUmbmUmbmUmbmUmbmAtYCAroCArYCCpoCAtYCAroCAtICAsYCUmbmAt4CAq'
385			'YCAroCMoICAs4CAs4CAtYCAt4CAqYCUmbmUmbmUmbmUmbmAtoCAtYCAq4CAtoCBp4'
386			'CAroCAqoCAq4CAr4CDpYCGpICAt4CAsICDpYCArICCpoCHo4CAs4CAuICUmbmUmbm'
387			'UmbmUmbmUmbmUmbmAuICAqICFpYCAq4CDpoCAqYCFpICAqYCUmbmNo6aAsYCCpoCD'
388			'pYCAqICAtoCUmbmAt4CAqoCCpoCAroCHo4CAsYCAq4CAsICAs4CAp4CUmbmAtYCAq'
389			'YCIooCHo4CAsICAr4CAqICEpYCAs4CAqICArICDpYCEpYCEpYCAr4CUmbmEpYCAs4'
390			'CAtICAs4CAqYCUmbmAtoCAp4CCpoCDpYCAq4CArICAqoCAqYCAqYCAtYCAtoCDpYC'
391			'At4CUmbmUmbmUmbmUmbmAt4CAsoCAsoCAp4CAp4CCpoCAsoCAt4CNo6aUmbmUmbmU'
392			'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmAt4CAtYCCpoCAqICAroCAr4CUmbmUm'
393			'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
394			'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
395			'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmU'
396			'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUm'
397			'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
398			'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
399			'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmU'
400			'mbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUm'
401			'bmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmb'
402			'mUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm'
403			'UmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbmUmbm\n')
404	jonathan	2552
405	jonathan	2562	self.assertEquals(renderer.raster_data,
406	jonathan	2571	(20,20,(raw_data, None, None)))
407	jonathan	2562
408	jonathan	2537	self.assertEquals(renderer.raster_format, "RAW")
409	bh	1552
410			self.assertEquals(dc.calls,
411			[('BeginDrawing',),
412			('SetFont', "label font"),
413			('EndDrawing',)])
414
415			def test_point_map_projection(self):
416			"""Test BaseRenderer with point layer and map projection"""
417			table = MemoryTable([("type", FIELDTYPE_STRING),
418			("value", FIELDTYPE_DOUBLE),
419			("code", FIELDTYPE_INT)],
420			[("UNKNOWN", 0.0, 0)])
421			shapes = [[[(10, 10)]]]
422			store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)
423
424			map = Map("TestBaseRenderer")
425			map.SetProjection(MockProjection(-3, 3))
426			layer = Layer("point layer", store)
427			map.AddLayer(layer)
428			self.to_destroy.append(map)
429
430			dc = MockDC()
431	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
432	bh	1552
433	bh	1867	renderer.render_map()
434	bh	1552
435			self.assertEquals(dc.calls,
436			[('BeginDrawing',),
437			('SetBrush', ('brush', Transparent)),
438			('SetPen', ('pen', Color(0, 0, 0), 1)),
439			('DrawEllipse', -55, -55, 10, 10),
440			('SetFont', "label font"),
441			('EndDrawing',)])
442
443			def test_point_layer_projection(self):
444			"""Test BaseRenderer with point layer and layer projection"""
445			table = MemoryTable([("type", FIELDTYPE_STRING),
446			("value", FIELDTYPE_DOUBLE),
447			("code", FIELDTYPE_INT)],
448			[("UNKNOWN", 0.0, 0)])
449			shapes = [[[(9, 9)]]]
450			store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)
451
452			map = Map("TestBaseRenderer")
453			layer = Layer("point layer", store)
454			layer.SetProjection(MockProjection(3, -3))
455			map.AddLayer(layer)
456			self.to_destroy.append(map)
457
458			dc = MockDC()
459	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
460	bh	1552
461	bh	1867	renderer.render_map()
462	bh	1552
463			self.assertEquals(dc.calls,
464			[('BeginDrawing',),
465			('SetBrush', ('brush', Transparent)),
466			('SetPen', ('pen', Color(0, 0, 0), 1)),
467			('DrawEllipse', 11, 11, 10, 10),
468			('SetFont', "label font"),
469			('EndDrawing',)])
470
471			def test_point_layer_and_map_projection(self):
472			"""Test BaseRenderer with point layer and layer and map projection"""
473			table = MemoryTable([("type", FIELDTYPE_STRING),
474			("value", FIELDTYPE_DOUBLE),
475			("code", FIELDTYPE_INT)],
476			[("UNKNOWN", 0.0, 0)])
477			shapes = [[[(9, 9)]]]
478			store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)
479
480			map = Map("TestBaseRenderer")
481			map.SetProjection(MockProjection(-3, 3))
482			layer = Layer("point layer", store)
483			layer.SetProjection(MockProjection(3, -3))
484			map.AddLayer(layer)
485			self.to_destroy.append(map)
486
487			dc = MockDC()
488	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
489	bh	1552
490	bh	1867	renderer.render_map()
491	bh	1552
492			self.assertEquals(dc.calls,
493			[('BeginDrawing',),
494			('SetBrush', ('brush', Transparent)),
495			('SetPen', ('pen', Color(0, 0, 0), 1)),
496			('DrawEllipse', -13, 23, 10, 10),
497			('SetFont', "label font"),
498			('EndDrawing',)])
499
500
501	bh	1591	def test_point_with_classification(self):
502			"""Test BaseRenderer with point layer and classification"""
503			table = MemoryTable([("type", FIELDTYPE_STRING),
504			("value", FIELDTYPE_DOUBLE),
505			("code", FIELDTYPE_INT)],
506			[("UNKNOWN", 0.0, 0),
507			("UNKNOWN", 0.0, 1)])
508			shapes = [[[(0, 0)]], [[(10, 10)]]]
509			store = SimpleShapeStore(SHAPETYPE_POINT, shapes, table)
510	bh	1552
511	bh	1591	map = Map("TestBaseRenderer")
512			layer = Layer("point layer", store)
513			group = ClassGroupSingleton(1)
514			group.GetProperties().SetFill(Color(0, 0, 1))
515			layer.GetClassification().AppendGroup(group)
516			layer.SetClassificationColumn("code")
517
518			map.AddLayer(layer)
519			self.to_destroy.append(map)
520
521			dc = MockDC()
522	bh	1867	renderer = SimpleRenderer(dc, map, 2, (10, 10))
523	bh	1591
524	bh	1867	renderer.render_map()
525	bh	1591
526			self.assertEquals(dc.calls,
527			[('BeginDrawing',),
528			('SetBrush', ('brush', Transparent)),
529			('SetPen', ('pen', Color(0, 0, 0), 1)),
530			('DrawEllipse', 5, 5, 10, 10),
531			('SetBrush', ('brush', Color(0, 0, 1))),
532			('SetPen', ('pen', Color(0, 0, 0), 1)),
533			('DrawEllipse', 25, -15, 10, 10),
534			('SetFont', "label font"),
535			('EndDrawing',)])
536
537
538	bh	1928	def test_renderer_extension(self):
539			"""Test renderer with a renderer extension"""
540			class MyLayer(BaseLayer):
541			pass
542
543			calls = []
544			def my_renderer(renderer, layer):
545			calls.append((renderer, layer))
546			return ()
547
548			add_renderer_extension(MyLayer, my_renderer)
549
550			try:
551			map = Map("test_renderer_extension")
552			layer = MyLayer("my layer")
553			map.AddLayer(layer)
554			self.to_destroy.append(map)
555
556			dc = MockDC()
557			renderer = SimpleRenderer(dc, map, 2, (10, 10))
558			renderer.render_map()
559			finally:
560			init_renderer_extensions()
561
562			self.assertEquals(calls, [(renderer, layer)])
563
564
565	bh	1552	if __name__ == "__main__":
566			support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision