Thuban/UI/baserenderer.py

# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
# Jonathan Coles <[email protected]>
# Frank Koormann <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""Basic rendering logic for Thuban maps

The code in this module is completely independend of wx so that it can
be tested reasonably easily and it could make it easier to write non-wx
renderers.
"""

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

import traceback

from Thuban.Model.layer import Layer, RasterLayer
from Thuban.Model.data import SHAPETYPE_ARC, SHAPETYPE_POINT
from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
     ALIGN_LEFT, ALIGN_RIGHT

import Thuban.Model.resource

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


class BaseRenderer:

    """Basic Renderer Infrastructure for Thuban Maps

    This class can't be used directly to render because it doesn't know
    anything about real DCs such as how to create pens or brushes. That
    functionality has to be provided by derived classes. The reason for
    this is that it makes the BaseRenderer completely independend of wx
    and thus it's quite easy to write test cases for it.
    """
    # If true the render honors the visibility flag of the layers
    honor_visibility = 1

    # Transparent brushes and pens. Derived classes should define these
    # as appropriate.
    TRANSPARENT_PEN = None
    TRANSPARENT_BRUSH = None

    def __init__(self, dc, scale, offset, resolution = 72.0,
                 honor_visibility = None):
        """Inititalize the renderer.

        dc -- the device context to render on.

        scale, offset -- the scale factor and translation to convert
                between projected coordinates and the DC coordinates

        resolution -- the assumed resolution of the DC. Used to convert
                absolute lengths like font sizes to DC coordinates. The
                defauult is 72.0

        honor_visibility -- boolean. If true, honor the visibility flag
                of the layers, otherwise draw all layers. If None (the
                default), use the renderer's default.
        """
        # resolution in pixel/inch

        self.dc = dc
        self.scale = scale
        self.offset = offset
        if honor_visibility is not None:
            self.honor_visibility = honor_visibility
        # store the resolution in pixel/point because it's more useful
        # later.
        self.resolution = resolution / 72.0

    def tools_for_property(self, prop):
        """Return a suitable pen and brush for the property

        This method must be implemented in derived classes. The return
        value should be a tuple (pen, brush).
        """
        raise NotImplementedError

    def render_map(self, map):
        """Render the map onto the DC the renderer was instantiated with

        Iterate through all layers and draw them. Layers containing
        vector data are drawn with the draw_shape_layer method, raster
        layers are drawn with draw_raster_layer. The label layer is
        drawn last with draw_label_layer.

        During execution of this method, the map is bound to self.map so
        that methods especially in derived classes have access to the
        map if necessary.
        """
        # Some method have to have access to the map so we store it in
        # self.map.
        self.map = map

        # Whether the raster layer has already been drawn. See below for
        # the optimization this is used for
        seenRaster = True

        self.dc.BeginDrawing()

        try:
            #
            # This is only a good optimization if there is only one
            # raster layer and the image covers the entire window (as
            # it currently does). We note if there is a raster layer
            # and only begin drawing layers once we have drawn it.
            # That way we avoid drawing layers that won't be seen.
            #
            if Thuban.Model.resource.has_gdal_support():
                for layer in map.Layers():
                    if isinstance(layer, RasterLayer) and layer.Visible():
                        seenRaster = False
                        break

            for layer in map.Layers():
                # if honor_visibility is true, only draw visible layers,
                # otherwise draw all layers
                if not self.honor_visibility or layer.Visible():
                    if isinstance(layer, Layer) and seenRaster:
                        self.draw_shape_layer(layer)
                    elif isinstance(layer, RasterLayer) \
                        and Thuban.Model.resource.has_gdal_support():
                        self.draw_raster_layer(layer)
                        seenRaster = True

            self.draw_label_layer(map.LabelLayer())
        finally:
            self.dc.EndDrawing()

    def draw_shape_layer(self, layer):
        """Draw the shape layer layer onto the map.

        Automatically called by render_map. Iterate through all shapes
        as indicated by self.layer_shapes() and draw them, using
        low-level renderers returned by self.low_level_renderer().
        """
        scale = self.scale
        offx, offy = self.offset

        map_proj = self.map.projection
        layer_proj = layer.projection

        brush = self.TRANSPARENT_BRUSH
        pen   = self.TRANSPARENT_PEN

        old_prop = None
        old_group = None
        lc = layer.GetClassification()
        field = layer.GetClassificationColumn()
        defaultGroup = lc.GetDefaultGroup()
        table = layer.ShapeStore().Table()

        # Determine which render function to use.
        useraw, draw_func, draw_func_param = self.low_level_renderer(layer)

        # Iterate through all shapes that have to be drawn.
        for shape in self.layer_shapes(layer):

            if field is None:
                group = defaultGroup
            else:
                record = table.ReadRowAsDict(shape.ShapeID())
                assert record is not None
                group = lc.FindGroup(record[field])

            if not group.IsVisible():
                continue

            # don't recreate new objects if they are the same as before
            if group is not old_group:
                old_group = group

                prop = group.GetProperties()

                if prop != old_prop:
                    pen, brush = self.tools_for_property(prop)

            if useraw:
                data = shape.RawData()
            else:
                data = shape.Points()
            draw_func(draw_func_param, data, pen, brush)

    def layer_shapes(self, layer):
        """Return an iterable over the shapes to be drawn from the given layer.

        The default implementation simply returns all ids in the layer.
        Override in derived classes to be more precise.
        """
        return layer.ShapeStore().AllShapes()

    def low_level_renderer(self, layer):
        """Return the low-level renderer for the layer for draw_shape_layer

        The low level renderer to be returned by this method is a tuple
        (useraw, func, param) where useraw is a boolean indicating
        whether the function uses the raw shape data, func is a callable
        object and param is passed as the first parameter to func. The
        draw_shape_layer method will call func like this:

            func(param, shapedata, pen, brush)

        where shapedata is the return value of the RawData method of the
        shape object if useraw is true or the return value of the Points
        method if it's false. pen and brush are the pen and brush to use
        to draw the shape on the dc.

        The default implementation returns one of
        self.draw_polygon_shape, self.draw_arc_shape or
        self.draw_point_shape as func and layer as param. None of the
        method use the raw shape data. Derived classes can override this
        method to return more efficient low level renderers.
        """
        shapetype = layer.ShapeType()
        if shapetype == SHAPETYPE_POINT:
            func = self.draw_point_shape
        elif shapetype == SHAPETYPE_ARC:
            func = self.draw_arc_shape
        else:
            func = self.draw_polygon_shape
        return False, func, layer

    def make_point(self, x, y):
        """Convert (x, y) to a point object.

        Derived classes must override this method.
        """
        raise NotImplementedError

    def projected_points(self, layer, points):
        """Return the projected coordinates of the points taken from layer.

        Transform all the points in the list of lists of coordinate
        pairs in points.

        The transformation applies the inverse of the layer's projection
        if any, then the map's projection if any and finally applies
        self.scale and self.offset.

        The returned list has the same structure as the one returned the
        shape's Points method.
        """
        proj = self.map.GetProjection()
        if proj is not None:
            forward = proj.Forward
        else:
            forward = None
        proj = layer.GetProjection()
        if proj is not None:
            inverse = proj.Inverse
        else:
            inverse = None
        result = []
        scale = self.scale
        offx, offy = self.offset
        make_point = self.make_point
        for part in points:
            result.append([])
            for x, y in part:
                if inverse:
                    x, y = inverse(x, y)
                if forward:
                    x, y = forward(x, y)
                result[-1].append(make_point(x * scale + offx,
                                             -y * scale + offy))
        return result

    def draw_polygon_shape(self, layer, points, pen, brush):
        """Draw a polygon shape from layer with the given brush and pen

        The shape is given by points argument which is a the return
        value of the shape's Points() method. The coordinates in the
        DC's coordinate system are determined with
        self.projected_points.
        """
        points = self.projected_points(layer, points)

        if brush is not self.TRANSPARENT_BRUSH:
            polygon = []
            for part in points:
                polygon.extend(part)

            insert_index = len(polygon)
            for part in points[:-1]:
                polygon.insert(insert_index, part[0])

            self.dc.SetBrush(brush)
            self.dc.SetPen(self.TRANSPARENT_PEN)
            self.dc.DrawPolygon(polygon)

        if pen is not self.TRANSPARENT_PEN:
            # At last draw the boundarys of the simple polygons
            self.dc.SetBrush(self.TRANSPARENT_BRUSH)
            self.dc.SetPen(pen)
            for part in points:
                self.dc.DrawLines(part)

    def draw_arc_shape(self, layer, points, pen, brush):
        """Draw an arc shape from layer with the given brush and pen

        The shape is given by points argument which is a the return
        value of the shape's Points() method. The coordinates in the
        DC's coordinate system are determined with
        self.projected_points.
        """
        points = self.projected_points(layer, points)
        self.dc.SetBrush(brush)
        self.dc.SetPen(pen)
        for part in points:
            self.dc.DrawLines(part)

    def draw_point_shape(self, layer, points, pen, brush):
        """Draw a point shape from layer with the given brush and pen

        The shape is given by points argument which is a the return
        value of the shape's Points() method. The coordinates in the
        DC's coordinate system are determined with
        self.projected_points.

        The point is drawn as a circle centered on the point.
        """
        points = self.projected_points(layer, points)
        if not points:
            return

        radius = self.resolution * 5
        self.dc.SetBrush(brush)
        self.dc.SetPen(pen)
        for part in points:
            for p in part:
                self.dc.DrawEllipse(p.x - radius, p.y - radius,
                                    2 * radius, 2 * radius)

    def draw_raster_layer(self, layer):
        """Draw the raster layer

        This implementation does the projection and scaling of the data
        as required by the layer's and map's projections and the scale
        and offset of the renderer and then hands the transformed data
        to self.draw_raster_data() which has to be implemented in
        derived classes.
        """
        offx, offy = self.offset
        width, height = self.dc.GetSizeTuple()

        in_proj = ""
        proj = layer.GetProjection()
        if proj is not None:
            for p in proj.GetAllParameters():
                in_proj += "+" + p + " "

        out_proj = ""
        proj = self.map.GetProjection()
        if proj is not None:
            for p in proj.GetAllParameters():
                out_proj += "+" + p + " "

        xmin = (0 - offx) / self.scale
        ymin = (offy - height) / self.scale
        xmax = (width - offx) / self.scale
        ymax = (offy - 0) / self.scale

        try:
            data = ProjectRasterFile(layer.GetImageFilename(),
                                     in_proj, out_proj,
                                     (xmin, ymin, xmax, ymax), "",
                                     (width, height))
        except (IOError, AttributeError, ValueError):
            # Why does this catch AttributeError and ValueError?
            # FIXME: The exception should be communicated to the user
            # better.
            traceback.print_exc()
        else:
            self.draw_raster_data(data)

    def draw_raster_data(self, data):
        """Draw the raster image in data onto the DC

        The raster image data is a string holding the data in BMP
        format. The data is exactly the size of the dc and covers it
        completely.

        This method has to be implemented by derived classes.
        """
        raise NotImplementedError

    def label_font(self):
        """Return the font object for the label layer"""
        raise NotImplementedError

    def draw_label_layer(self, layer):
        """Draw the label layer

        All labels are draw in the font returned by self.label_font().
        """
        scale = self.scale
        offx, offy = self.offset

        self.dc.SetFont(self.label_font())

        map_proj = self.map.projection
        if map_proj is not None:
            forward = map_proj.Forward
        else:
            forward = None

        for label in layer.Labels():
            x = label.x
            y = label.y
            text = label.text
            if forward:
                x, y = forward(x, y)
            x = x * scale + offx
            y = -y * scale + offy
            width, height = self.dc.GetTextExtent(text)
            if label.halign == ALIGN_LEFT:
                # nothing to be done
                pass
            elif label.halign == ALIGN_RIGHT:
                x = x - width
            elif label.halign == ALIGN_CENTER:
                x = x - width/2
            if label.valign == ALIGN_TOP:
                # nothing to be done
                pass
            elif label.valign == ALIGN_BOTTOM:
                y = y - height
            elif label.valign == ALIGN_CENTER:
                y = y - height/2
            self.dc.DrawText(text, x, y)
1	bh	1554	# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2			# Authors:
3			# Bernhard Herzog <[email protected]>
4			# Jonathan Coles <[email protected]>
5			# Frank Koormann <[email protected]>
6			#
7			# This program is free software under the GPL (>=v2)
8			# Read the file COPYING coming with Thuban for details.
9
10			"""Basic rendering logic for Thuban maps
11
12			The code in this module is completely independend of wx so that it can
13			be tested reasonably easily and it could make it easier to write non-wx
14			renderers.
15			"""
16
17			__version__ = "$Revision$"
18			# $Source$
19			# $Id$
20
21			import traceback
22
23			from Thuban.Model.layer import Layer, RasterLayer
24			from Thuban.Model.data import SHAPETYPE_ARC, SHAPETYPE_POINT
25			from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
26			ALIGN_LEFT, ALIGN_RIGHT
27
28			import Thuban.Model.resource
29
30			if Thuban.Model.resource.has_gdal_support():
31			from gdalwarp import ProjectRasterFile
32
33
34			class BaseRenderer:
35
36			"""Basic Renderer Infrastructure for Thuban Maps
37
38			This class can't be used directly to render because it doesn't know
39			anything about real DCs such as how to create pens or brushes. That
40			functionality has to be provided by derived classes. The reason for
41			this is that it makes the BaseRenderer completely independend of wx
42			and thus it's quite easy to write test cases for it.
43			"""
44			# If true the render honors the visibility flag of the layers
45			honor_visibility = 1
46
47			# Transparent brushes and pens. Derived classes should define these
48			# as appropriate.
49			TRANSPARENT_PEN = None
50			TRANSPARENT_BRUSH = None
51
52			def __init__(self, dc, scale, offset, resolution = 72.0,
53			honor_visibility = None):
54			"""Inititalize the renderer.
55
56			dc -- the device context to render on.
57
58			scale, offset -- the scale factor and translation to convert
59			between projected coordinates and the DC coordinates
60
61			resolution -- the assumed resolution of the DC. Used to convert
62			absolute lengths like font sizes to DC coordinates. The
63			defauult is 72.0
64
65			honor_visibility -- boolean. If true, honor the visibility flag
66			of the layers, otherwise draw all layers. If None (the
67			default), use the renderer's default.
68			"""
69			# resolution in pixel/inch
70
71			self.dc = dc
72			self.scale = scale
73			self.offset = offset
74			if honor_visibility is not None:
75			self.honor_visibility = honor_visibility
76			# store the resolution in pixel/point because it's more useful
77			# later.
78			self.resolution = resolution / 72.0
79
80			def tools_for_property(self, prop):
81			"""Return a suitable pen and brush for the property
82
83			This method must be implemented in derived classes. The return
84			value should be a tuple (pen, brush).
85			"""
86			raise NotImplementedError
87
88			def render_map(self, map):
89			"""Render the map onto the DC the renderer was instantiated with
90
91			Iterate through all layers and draw them. Layers containing
92			vector data are drawn with the draw_shape_layer method, raster
93			layers are drawn with draw_raster_layer. The label layer is
94			drawn last with draw_label_layer.
95
96			During execution of this method, the map is bound to self.map so
97			that methods especially in derived classes have access to the
98			map if necessary.
99			"""
100			# Some method have to have access to the map so we store it in
101			# self.map.
102			self.map = map
103
104			# Whether the raster layer has already been drawn. See below for
105			# the optimization this is used for
106			seenRaster = True
107
108			self.dc.BeginDrawing()
109
110			try:
111			#
112			# This is only a good optimization if there is only one
113			# raster layer and the image covers the entire window (as
114			# it currently does). We note if there is a raster layer
115			# and only begin drawing layers once we have drawn it.
116			# That way we avoid drawing layers that won't be seen.
117			#
118			if Thuban.Model.resource.has_gdal_support():
119			for layer in map.Layers():
120			if isinstance(layer, RasterLayer) and layer.Visible():
121			seenRaster = False
122			break
123
124			for layer in map.Layers():
125			# if honor_visibility is true, only draw visible layers,
126			# otherwise draw all layers
127			if not self.honor_visibility or layer.Visible():
128			if isinstance(layer, Layer) and seenRaster:
129			self.draw_shape_layer(layer)
130			elif isinstance(layer, RasterLayer) \
131			and Thuban.Model.resource.has_gdal_support():
132			self.draw_raster_layer(layer)
133			seenRaster = True
134
135			self.draw_label_layer(map.LabelLayer())
136			finally:
137			self.dc.EndDrawing()
138
139			def draw_shape_layer(self, layer):
140			"""Draw the shape layer layer onto the map.
141
142			Automatically called by render_map. Iterate through all shapes
143	bh	1593	as indicated by self.layer_shapes() and draw them, using
144			low-level renderers returned by self.low_level_renderer().
145	bh	1554	"""
146			scale = self.scale
147			offx, offy = self.offset
148
149			map_proj = self.map.projection
150			layer_proj = layer.projection
151
152			brush = self.TRANSPARENT_BRUSH
153			pen = self.TRANSPARENT_PEN
154
155			old_prop = None
156			old_group = None
157			lc = layer.GetClassification()
158			field = layer.GetClassificationColumn()
159			defaultGroup = lc.GetDefaultGroup()
160			table = layer.ShapeStore().Table()
161
162			# Determine which render function to use.
163	bh	1591	useraw, draw_func, draw_func_param = self.low_level_renderer(layer)
164	bh	1554
165			# Iterate through all shapes that have to be drawn.
166	bh	1593	for shape in self.layer_shapes(layer):
167	bh	1554
168			if field is None:
169			group = defaultGroup
170			else:
171	bh	1593	record = table.ReadRowAsDict(shape.ShapeID())
172	bh	1554	assert record is not None
173			group = lc.FindGroup(record[field])
174
175			if not group.IsVisible():
176			continue
177
178			# don't recreate new objects if they are the same as before
179			if group is not old_group:
180			old_group = group
181
182			prop = group.GetProperties()
183
184			if prop != old_prop:
185			pen, brush = self.tools_for_property(prop)
186
187	bh	1591	if useraw:
188			data = shape.RawData()
189			else:
190			data = shape.Points()
191			draw_func(draw_func_param, data, pen, brush)
192	bh	1554
193	bh	1593	def layer_shapes(self, layer):
194			"""Return an iterable over the shapes to be drawn from the given layer.
195	bh	1554
196			The default implementation simply returns all ids in the layer.
197			Override in derived classes to be more precise.
198			"""
199	bh	1593	return layer.ShapeStore().AllShapes()
200	bh	1554
201			def low_level_renderer(self, layer):
202			"""Return the low-level renderer for the layer for draw_shape_layer
203
204			The low level renderer to be returned by this method is a tuple
205	bh	1591	(useraw, func, param) where useraw is a boolean indicating
206			whether the function uses the raw shape data, func is a callable
207			object and param is passed as the first parameter to func. The
208			draw_shape_layer method will call func like this:
209	bh	1554
210	bh	1591	func(param, shapedata, pen, brush)
211	bh	1554
212	bh	1591	where shapedata is the return value of the RawData method of the
213			shape object if useraw is true or the return value of the Points
214			method if it's false. pen and brush are the pen and brush to use
215			to draw the shape on the dc.
216	bh	1554
217			The default implementation returns one of
218			self.draw_polygon_shape, self.draw_arc_shape or
219	bh	1591	self.draw_point_shape as func and layer as param. None of the
220			method use the raw shape data. Derived classes can override this
221			method to return more efficient low level renderers.
222	bh	1554	"""
223			shapetype = layer.ShapeType()
224			if shapetype == SHAPETYPE_POINT:
225			func = self.draw_point_shape
226			elif shapetype == SHAPETYPE_ARC:
227			func = self.draw_arc_shape
228			else:
229			func = self.draw_polygon_shape
230	bh	1591	return False, func, layer
231	bh	1554
232			def make_point(self, x, y):
233			"""Convert (x, y) to a point object.
234
235			Derived classes must override this method.
236			"""
237			raise NotImplementedError
238
239	bh	1591	def projected_points(self, layer, points):
240			"""Return the projected coordinates of the points taken from layer.
241	bh	1554
242	bh	1591	Transform all the points in the list of lists of coordinate
243			pairs in points.
244	bh	1554
245			The transformation applies the inverse of the layer's projection
246			if any, then the map's projection if any and finally applies
247			self.scale and self.offset.
248
249			The returned list has the same structure as the one returned the
250			shape's Points method.
251			"""
252			proj = self.map.GetProjection()
253			if proj is not None:
254			forward = proj.Forward
255			else:
256			forward = None
257			proj = layer.GetProjection()
258			if proj is not None:
259			inverse = proj.Inverse
260			else:
261			inverse = None
262	bh	1591	result = []
263	bh	1554	scale = self.scale
264			offx, offy = self.offset
265			make_point = self.make_point
266	bh	1591	for part in points:
267			result.append([])
268	bh	1554	for x, y in part:
269			if inverse:
270			x, y = inverse(x, y)
271			if forward:
272			x, y = forward(x, y)
273	bh	1591	result[-1].append(make_point(x * scale + offx,
274	bh	1554	-y * scale + offy))
275	bh	1591	return result
276	bh	1554
277	bh	1591	def draw_polygon_shape(self, layer, points, pen, brush):
278			"""Draw a polygon shape from layer with the given brush and pen
279	bh	1554
280	bh	1591	The shape is given by points argument which is a the return
281			value of the shape's Points() method. The coordinates in the
282			DC's coordinate system are determined with
283	bh	1554	self.projected_points.
284			"""
285	bh	1591	points = self.projected_points(layer, points)
286	bh	1554
287			if brush is not self.TRANSPARENT_BRUSH:
288			polygon = []
289			for part in points:
290			polygon.extend(part)
291
292			insert_index = len(polygon)
293			for part in points[:-1]:
294			polygon.insert(insert_index, part[0])
295
296			self.dc.SetBrush(brush)
297			self.dc.SetPen(self.TRANSPARENT_PEN)
298			self.dc.DrawPolygon(polygon)
299
300			if pen is not self.TRANSPARENT_PEN:
301			# At last draw the boundarys of the simple polygons
302			self.dc.SetBrush(self.TRANSPARENT_BRUSH)
303			self.dc.SetPen(pen)
304			for part in points:
305			self.dc.DrawLines(part)
306
307	bh	1591	def draw_arc_shape(self, layer, points, pen, brush):
308			"""Draw an arc shape from layer with the given brush and pen
309	bh	1554
310	bh	1591	The shape is given by points argument which is a the return
311			value of the shape's Points() method. The coordinates in the
312			DC's coordinate system are determined with
313	bh	1554	self.projected_points.
314			"""
315	bh	1591	points = self.projected_points(layer, points)
316	bh	1554	self.dc.SetBrush(brush)
317			self.dc.SetPen(pen)
318			for part in points:
319			self.dc.DrawLines(part)
320
321	bh	1591	def draw_point_shape(self, layer, points, pen, brush):
322			"""Draw a point shape from layer with the given brush and pen
323	bh	1554
324	bh	1591	The shape is given by points argument which is a the return
325			value of the shape's Points() method. The coordinates in the
326			DC's coordinate system are determined with
327	bh	1554	self.projected_points.
328
329			The point is drawn as a circle centered on the point.
330			"""
331	bh	1591	points = self.projected_points(layer, points)
332	bh	1554	if not points:
333			return
334
335			radius = self.resolution * 5
336			self.dc.SetBrush(brush)
337			self.dc.SetPen(pen)
338			for part in points:
339			for p in part:
340			self.dc.DrawEllipse(p.x - radius, p.y - radius,
341			2 * radius, 2 * radius)
342
343			def draw_raster_layer(self, layer):
344			"""Draw the raster layer
345
346			This implementation does the projection and scaling of the data
347			as required by the layer's and map's projections and the scale
348			and offset of the renderer and then hands the transformed data
349			to self.draw_raster_data() which has to be implemented in
350			derived classes.
351			"""
352			offx, offy = self.offset
353			width, height = self.dc.GetSizeTuple()
354
355			in_proj = ""
356			proj = layer.GetProjection()
357			if proj is not None:
358			for p in proj.GetAllParameters():
359			in_proj += "+" + p + " "
360
361			out_proj = ""
362			proj = self.map.GetProjection()
363			if proj is not None:
364			for p in proj.GetAllParameters():
365			out_proj += "+" + p + " "
366
367			xmin = (0 - offx) / self.scale
368			ymin = (offy - height) / self.scale
369			xmax = (width - offx) / self.scale
370			ymax = (offy - 0) / self.scale
371
372			try:
373			data = ProjectRasterFile(layer.GetImageFilename(),
374			in_proj, out_proj,
375			(xmin, ymin, xmax, ymax), "",
376			(width, height))
377			except (IOError, AttributeError, ValueError):
378			# Why does this catch AttributeError and ValueError?
379			# FIXME: The exception should be communicated to the user
380			# better.
381			traceback.print_exc()
382			else:
383			self.draw_raster_data(data)
384
385			def draw_raster_data(self, data):
386			"""Draw the raster image in data onto the DC
387
388			The raster image data is a string holding the data in BMP
389			format. The data is exactly the size of the dc and covers it
390			completely.
391
392			This method has to be implemented by derived classes.
393			"""
394			raise NotImplementedError
395
396			def label_font(self):
397			"""Return the font object for the label layer"""
398			raise NotImplementedError
399
400			def draw_label_layer(self, layer):
401			"""Draw the label layer
402
403			All labels are draw in the font returned by self.label_font().
404			"""
405			scale = self.scale
406			offx, offy = self.offset
407
408			self.dc.SetFont(self.label_font())
409
410			map_proj = self.map.projection
411			if map_proj is not None:
412			forward = map_proj.Forward
413			else:
414			forward = None
415
416			for label in layer.Labels():
417			x = label.x
418			y = label.y
419			text = label.text
420			if forward:
421			x, y = forward(x, y)
422			x = x * scale + offx
423			y = -y * scale + offy
424			width, height = self.dc.GetTextExtent(text)
425			if label.halign == ALIGN_LEFT:
426			# nothing to be done
427			pass
428			elif label.halign == ALIGN_RIGHT:
429			x = x - width
430			elif label.halign == ALIGN_CENTER:
431			x = x - width/2
432			if label.valign == ALIGN_TOP:
433			# nothing to be done
434			pass
435			elif label.valign == ALIGN_BOTTOM:
436			y = y - height
437			elif label.valign == ALIGN_CENTER:
438			y = y - height/2
439			self.dc.DrawText(text, x, y)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision