WIP-pyshapelib-bramz/test/test_baserenderer.py

# Copyright (C) 2003, 2005, 2006 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
# Bernhard Reiter <[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 locale

import localessupport
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', opacity=1.0):
        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

        Tests should put all objects whose Destroy should be called at
        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_projected_raster_decimalcommalocale(self):
        if not Thuban.Model.resource.has_gdal_support():
            raise support.SkipTest("No gdal support")

        def _do_project_island():
            """Project island.tif and return result."""
            layer = RasterLayer("raster layer",
                                os.path.join("..", "Data", "iceland",
                                             "island.tif"))

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

            projection = "+proj=latlong +to_meter=0.017453 +ellps=clrk66"
            new_projection = "+proj=utm +zone=27 +ellps=clrk66"

            return renderer.projected_raster_layer(layer, \
                            projection, new_projection, \
                            (322003.1320390497, 6964094.1718668584, 876022.1891829354, 7460469.6276894147), [0, 0], (10,5), 1)

        oldlocale = localessupport.setdecimalcommalocale()
        img_data2 = _do_project_island()
        locale.setlocale(locale.LC_NUMERIC, oldlocale)

        img_data1 = _do_project_island()

        self.assertEquals(img_data1, img_data2)

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