Thuban/UI/baserenderer.py

# Copyright (c) 2001, 2002, 2003, 2004 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.
"""

from __future__ import generators

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

import sys
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


#
#       Renderer Extensions
#
# The renderer extensions provide a way to render layer types defined in
# Thuban extensions. The renderer extensions are stored as a list with
# (layer_class, draw_function) pairs. If the renderer has to draw a
# non-builtin layer type, i.e. a layer that is not a subclass of Layer
# or RasterLayer, it iterates through that list, tests whether the layer
# to be drawn is an instance of layer_class and if so calls
# draw_function with the renderer and the layer as arguments. Since
# drawing is done incrementally, the draw_function should return an
# iterable. The easiest way is to simply implement the draw_function as
# a generator and to yield in suitable places, or to return the empty
# tuple.
#
# New renderer extensions should be added with add_renderer_extension().
# If necessary the extensions list can be reset with
# init_renderer_extensions().

_renderer_extensions = []

def add_renderer_extension(layer_class, function):
    """Add a renderer extension for the layer class layer_class

    When an instance of layer_class is to be drawn by the renderer the
    renderer will call function with the renderer and the layer_class
    instance as arguments. Since drawing is done incrementally, the
    function should return an iterable. The easiest way is to simply
    implement the draw_function as a generator and to yield True in
    suitable places, or to return the empty tuple if it's not possible
    to do the rendering incrementally.
    """
    _renderer_extensions.append((layer_class, function))

def init_renderer_extensions():
    """(Re)initialize the list of renderer extensions

    Calling this function outside of the test suite is probably not
    useful.
    """
    del _renderer_extensions[:]


#
#       Base Renderer
#

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, map, scale, offset, region = None,
                 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

        region -- The region to draw as a (x, y, width, height) tuple in
                  the map's coordinate system. Default is None meaning
                  to draw everything.

        resolution -- the assumed resolution of the DC. Used to convert
                absolute lengths like font sizes to DC coordinates. The
                default is 72.0. If given, this parameter must be
                provided as a keyword argument.

        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. If given, this
                parameter must be provided as a keyword argument.
        """
        # resolution in pixel/inch
        self.dc = dc
        self.map = map
        self.scale = scale
        self.offset = offset
        self.region = region
        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):
        """Render the map onto the DC.

        Both map and DC are the ones the renderer was instantiated with.

        This method is just a front-end for render_map_incrementally
        which does all rendering in one go. It also calls the dc's
        BeginDrawing and EndDrawing methods before and after calling
        render_map_incrementally.
        """

        self.dc.BeginDrawing()
        try:
            for cont in self.render_map_incrementally():
                pass
        finally:
            self.dc.EndDrawing()

    def render_map_incrementally(self):
        """Render the map incrementally.

        Return an iterator whose next method should be called until it
        returns False. After returning False it will raise StopIteration
        so that you could also use it in a for loop (implementation
        detail: this method is implemented as a generator).

        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.
        """
        # Whether the raster layer has already been drawn. See below for
        # the optimization this is used for
        seenRaster = True

        #
        # 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 self.map.Layers():
                if isinstance(layer, RasterLayer) and layer.Visible():
                    seenRaster = False
                    break

        for layer in self.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):
                    if seenRaster:
                        for i in self.draw_shape_layer_incrementally(layer):
                            yield True
                elif isinstance(layer, RasterLayer) \
                    and Thuban.Model.resource.has_gdal_support():
                    self.draw_raster_layer(layer)
                    seenRaster = True
                    yield True
                else:
                    # look it up in the renderer extensions
                    for cls, func in _renderer_extensions:
                        if isinstance(layer, cls):
                            for i in func(self, layer):
                                yield True
                            break
                    else:
                        # No renderer found. Print a message about it
                        print >>sys.stderr, ("Drawing layer %r not supported"
                                             % layer)
            yield True

        self.draw_label_layer(self.map.LabelLayer())
        yield False

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

        This method is a generator which yields True after every 500
        shapes.
        """
        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()

        if lc.GetNumGroups() == 0:
            # There's only the default group, so we can pretend that
            # there is no field to classifiy on which makes things
            # faster since we don't need the attribute information at
            # all.
            field = None

        # 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.
        #

        # Count the shapes drawn so that we can yield every few hundred
        # shapes
        count = 0

        # Cache the tools (pens and brushes) for the classification
        # groups. This is a mapping from the group's ids to the a tuple
        # (pen, brush)
        tool_cache = {}

        for shape in self.layer_shapes(layer):
            count += 1
            if field is None:
                group = defaultGroup
            else:
                value = table.ReadValue(shape.ShapeID(), field)
                group = lc.FindGroup(value)

            if not group.IsVisible():
                continue

            try:
                pen, brush = tool_cache[id(group)]
            except KeyError:
                pen, brush = tool_cache[id(group)] \
                             = self.tools_for_property(group.GetProperties())

            if useraw:
                data = shape.RawData()
            else:
                data = shape.Points()
            draw_func(draw_func_param, data, pen, brush)
            if count % 500 == 0:
                yield True

    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 = int(round(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, "BMP")

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

        The raster image data is a string holding the data in the format
        indicated by the format parameter. The image is assumed to be
        exactly the size of the dc and to cover it completely.

        The format parameter is a string with the name of the format.
        The following format names should be used:

          'BMP' -- Windows Bitmap
          'JPEG' -- Jpeg

        The default format is 'bmp'.

        This method has to be implemented by derived classes. The
        implementation in the derived class should try to support at
        least the formats specified above and may support more.
        """
        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 = int(round(x * scale + offx))
            y = int(round(-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	# Copyright (c) 2001, 2002, 2003, 2004 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	from __future__ import generators
18
19	__version__ = "$Revision$"
20	# $Source$
21	# $Id$
22
23	import sys
24	import traceback
25
26	from Thuban.Model.layer import Layer, RasterLayer
27	from Thuban.Model.data import SHAPETYPE_ARC, SHAPETYPE_POINT
28	from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
29	ALIGN_LEFT, ALIGN_RIGHT
30
31	import Thuban.Model.resource
32
33	if Thuban.Model.resource.has_gdal_support():
34	from gdalwarp import ProjectRasterFile
35
36
37	#
38	# Renderer Extensions
39	#
40	# The renderer extensions provide a way to render layer types defined in
41	# Thuban extensions. The renderer extensions are stored as a list with
42	# (layer_class, draw_function) pairs. If the renderer has to draw a
43	# non-builtin layer type, i.e. a layer that is not a subclass of Layer
44	# or RasterLayer, it iterates through that list, tests whether the layer
45	# to be drawn is an instance of layer_class and if so calls
46	# draw_function with the renderer and the layer as arguments. Since
47	# drawing is done incrementally, the draw_function should return an
48	# iterable. The easiest way is to simply implement the draw_function as
49	# a generator and to yield in suitable places, or to return the empty
50	# tuple.
51	#
52	# New renderer extensions should be added with add_renderer_extension().
53	# If necessary the extensions list can be reset with
54	# init_renderer_extensions().
55
56	_renderer_extensions = []
57
58	def add_renderer_extension(layer_class, function):
59	"""Add a renderer extension for the layer class layer_class
60
61	When an instance of layer_class is to be drawn by the renderer the
62	renderer will call function with the renderer and the layer_class
63	instance as arguments. Since drawing is done incrementally, the
64	function should return an iterable. The easiest way is to simply
65	implement the draw_function as a generator and to yield True in
66	suitable places, or to return the empty tuple if it's not possible
67	to do the rendering incrementally.
68	"""
69	_renderer_extensions.append((layer_class, function))
70
71	def init_renderer_extensions():
72	"""(Re)initialize the list of renderer extensions
73
74	Calling this function outside of the test suite is probably not
75	useful.
76	"""
77	del _renderer_extensions[:]
78
79
80	#
81	# Base Renderer
82	#
83
84	class BaseRenderer:
85
86	"""Basic Renderer Infrastructure for Thuban Maps
87
88	This class can't be used directly to render because it doesn't know
89	anything about real DCs such as how to create pens or brushes. That
90	functionality has to be provided by derived classes. The reason for
91	this is that it makes the BaseRenderer completely independend of wx
92	and thus it's quite easy to write test cases for it.
93	"""
94	# If true the render honors the visibility flag of the layers
95	honor_visibility = 1
96
97	# Transparent brushes and pens. Derived classes should define these
98	# as appropriate.
99	TRANSPARENT_PEN = None
100	TRANSPARENT_BRUSH = None
101
102	def __init__(self, dc, map, scale, offset, region = None,
103	resolution = 72.0, honor_visibility = None):
104	"""Inititalize the renderer.
105
106	dc -- the device context to render on.
107
108	scale, offset -- the scale factor and translation to convert
109	between projected coordinates and the DC coordinates
110
111	region -- The region to draw as a (x, y, width, height) tuple in
112	the map's coordinate system. Default is None meaning
113	to draw everything.
114
115	resolution -- the assumed resolution of the DC. Used to convert
116	absolute lengths like font sizes to DC coordinates. The
117	default is 72.0. If given, this parameter must be
118	provided as a keyword argument.
119
120	honor_visibility -- boolean. If true, honor the visibility flag
121	of the layers, otherwise draw all layers. If None (the
122	default), use the renderer's default. If given, this
123	parameter must be provided as a keyword argument.
124	"""
125	# resolution in pixel/inch
126	self.dc = dc
127	self.map = map
128	self.scale = scale
129	self.offset = offset
130	self.region = region
131	if honor_visibility is not None:
132	self.honor_visibility = honor_visibility
133	# store the resolution in pixel/point because it's more useful
134	# later.
135	self.resolution = resolution / 72.0
136
137	def tools_for_property(self, prop):
138	"""Return a suitable pen and brush for the property
139
140	This method must be implemented in derived classes. The return
141	value should be a tuple (pen, brush).
142	"""
143	raise NotImplementedError
144
145	def render_map(self):
146	"""Render the map onto the DC.
147
148	Both map and DC are the ones the renderer was instantiated with.
149
150	This method is just a front-end for render_map_incrementally
151	which does all rendering in one go. It also calls the dc's
152	BeginDrawing and EndDrawing methods before and after calling
153	render_map_incrementally.
154	"""
155
156	self.dc.BeginDrawing()
157	try:
158	for cont in self.render_map_incrementally():
159	pass
160	finally:
161	self.dc.EndDrawing()
162
163	def render_map_incrementally(self):
164	"""Render the map incrementally.
165
166	Return an iterator whose next method should be called until it
167	returns False. After returning False it will raise StopIteration
168	so that you could also use it in a for loop (implementation
169	detail: this method is implemented as a generator).
170
171	Iterate through all layers and draw them. Layers containing
172	vector data are drawn with the draw_shape_layer method, raster
173	layers are drawn with draw_raster_layer. The label layer is
174	drawn last with draw_label_layer.
175
176	During execution of this method, the map is bound to self.map so
177	that methods especially in derived classes have access to the
178	map if necessary.
179	"""
180	# Whether the raster layer has already been drawn. See below for
181	# the optimization this is used for
182	seenRaster = True
183
184	#
185	# This is only a good optimization if there is only one
186	# raster layer and the image covers the entire window (as
187	# it currently does). We note if there is a raster layer
188	# and only begin drawing layers once we have drawn it.
189	# That way we avoid drawing layers that won't be seen.
190	#
191	if Thuban.Model.resource.has_gdal_support():
192	for layer in self.map.Layers():
193	if isinstance(layer, RasterLayer) and layer.Visible():
194	seenRaster = False
195	break
196
197	for layer in self.map.Layers():
198	# if honor_visibility is true, only draw visible layers,
199	# otherwise draw all layers
200	if not self.honor_visibility or layer.Visible():
201	if isinstance(layer, Layer):
202	if seenRaster:
203	for i in self.draw_shape_layer_incrementally(layer):
204	yield True
205	elif isinstance(layer, RasterLayer) \
206	and Thuban.Model.resource.has_gdal_support():
207	self.draw_raster_layer(layer)
208	seenRaster = True
209	yield True
210	else:
211	# look it up in the renderer extensions
212	for cls, func in _renderer_extensions:
213	if isinstance(layer, cls):
214	for i in func(self, layer):
215	yield True
216	break
217	else:
218	# No renderer found. Print a message about it
219	print >>sys.stderr, ("Drawing layer %r not supported"
220	% layer)
221	yield True
222
223	self.draw_label_layer(self.map.LabelLayer())
224	yield False
225
226	def draw_shape_layer_incrementally(self, layer):
227	"""Draw the shape layer layer onto the map incrementally.
228
229	This method is a generator which yields True after every 500
230	shapes.
231	"""
232	scale = self.scale
233	offx, offy = self.offset
234
235	map_proj = self.map.projection
236	layer_proj = layer.projection
237
238	brush = self.TRANSPARENT_BRUSH
239	pen = self.TRANSPARENT_PEN
240
241	old_prop = None
242	old_group = None
243	lc = layer.GetClassification()
244	field = layer.GetClassificationColumn()
245	defaultGroup = lc.GetDefaultGroup()
246	table = layer.ShapeStore().Table()
247
248	if lc.GetNumGroups() == 0:
249	# There's only the default group, so we can pretend that
250	# there is no field to classifiy on which makes things
251	# faster since we don't need the attribute information at
252	# all.
253	field = None
254
255	# Determine which render function to use.
256	useraw, draw_func, draw_func_param = self.low_level_renderer(layer)
257
258	#
259	# Iterate through all shapes that have to be drawn.
260	#
261
262	# Count the shapes drawn so that we can yield every few hundred
263	# shapes
264	count = 0
265
266	# Cache the tools (pens and brushes) for the classification
267	# groups. This is a mapping from the group's ids to the a tuple
268	# (pen, brush)
269	tool_cache = {}
270
271	for shape in self.layer_shapes(layer):
272	count += 1
273	if field is None:
274	group = defaultGroup
275	else:
276	value = table.ReadValue(shape.ShapeID(), field)
277	group = lc.FindGroup(value)
278
279	if not group.IsVisible():
280	continue
281
282	try:
283	pen, brush = tool_cache[id(group)]
284	except KeyError:
285	pen, brush = tool_cache[id(group)] \
286	= self.tools_for_property(group.GetProperties())
287
288	if useraw:
289	data = shape.RawData()
290	else:
291	data = shape.Points()
292	draw_func(draw_func_param, data, pen, brush)
293	if count % 500 == 0:
294	yield True
295
296	def layer_shapes(self, layer):
297	"""Return an iterable over the shapes to be drawn from the given layer.
298
299	The default implementation simply returns all ids in the layer.
300	Override in derived classes to be more precise.
301	"""
302	return layer.ShapeStore().AllShapes()
303
304	def low_level_renderer(self, layer):
305	"""Return the low-level renderer for the layer for draw_shape_layer
306
307	The low level renderer to be returned by this method is a tuple
308	(useraw, func, param) where useraw is a boolean indicating
309	whether the function uses the raw shape data, func is a callable
310	object and param is passed as the first parameter to func. The
311	draw_shape_layer method will call func like this:
312
313	func(param, shapedata, pen, brush)
314
315	where shapedata is the return value of the RawData method of the
316	shape object if useraw is true or the return value of the Points
317	method if it's false. pen and brush are the pen and brush to use
318	to draw the shape on the dc.
319
320	The default implementation returns one of
321	self.draw_polygon_shape, self.draw_arc_shape or
322	self.draw_point_shape as func and layer as param. None of the
323	method use the raw shape data. Derived classes can override this
324	method to return more efficient low level renderers.
325	"""
326	shapetype = layer.ShapeType()
327	if shapetype == SHAPETYPE_POINT:
328	func = self.draw_point_shape
329	elif shapetype == SHAPETYPE_ARC:
330	func = self.draw_arc_shape
331	else:
332	func = self.draw_polygon_shape
333	return False, func, layer
334
335	def make_point(self, x, y):
336	"""Convert (x, y) to a point object.
337
338	Derived classes must override this method.
339	"""
340	raise NotImplementedError
341
342	def projected_points(self, layer, points):
343	"""Return the projected coordinates of the points taken from layer.
344
345	Transform all the points in the list of lists of coordinate
346	pairs in points.
347
348	The transformation applies the inverse of the layer's projection
349	if any, then the map's projection if any and finally applies
350	self.scale and self.offset.
351
352	The returned list has the same structure as the one returned the
353	shape's Points method.
354	"""
355	proj = self.map.GetProjection()
356	if proj is not None:
357	forward = proj.Forward
358	else:
359	forward = None
360	proj = layer.GetProjection()
361	if proj is not None:
362	inverse = proj.Inverse
363	else:
364	inverse = None
365	result = []
366	scale = self.scale
367	offx, offy = self.offset
368	make_point = self.make_point
369	for part in points:
370	result.append([])
371	for x, y in part:
372	if inverse:
373	x, y = inverse(x, y)
374	if forward:
375	x, y = forward(x, y)
376	result[-1].append(make_point(x * scale + offx,
377	-y * scale + offy))
378	return result
379
380	def draw_polygon_shape(self, layer, points, pen, brush):
381	"""Draw a polygon shape from layer with the given brush and pen
382
383	The shape is given by points argument which is a the return
384	value of the shape's Points() method. The coordinates in the
385	DC's coordinate system are determined with
386	self.projected_points.
387	"""
388	points = self.projected_points(layer, points)
389
390	if brush is not self.TRANSPARENT_BRUSH:
391	polygon = []
392	for part in points:
393	polygon.extend(part)
394
395	insert_index = len(polygon)
396	for part in points[:-1]:
397	polygon.insert(insert_index, part[0])
398
399	self.dc.SetBrush(brush)
400	self.dc.SetPen(self.TRANSPARENT_PEN)
401	self.dc.DrawPolygon(polygon)
402
403	if pen is not self.TRANSPARENT_PEN:
404	# At last draw the boundarys of the simple polygons
405	self.dc.SetBrush(self.TRANSPARENT_BRUSH)
406	self.dc.SetPen(pen)
407	for part in points:
408	self.dc.DrawLines(part)
409
410	def draw_arc_shape(self, layer, points, pen, brush):
411	"""Draw an arc shape from layer with the given brush and pen
412
413	The shape is given by points argument which is a the return
414	value of the shape's Points() method. The coordinates in the
415	DC's coordinate system are determined with
416	self.projected_points.
417	"""
418	points = self.projected_points(layer, points)
419	self.dc.SetBrush(brush)
420	self.dc.SetPen(pen)
421	for part in points:
422	self.dc.DrawLines(part)
423
424	def draw_point_shape(self, layer, points, pen, brush):
425	"""Draw a point shape from layer with the given brush and pen
426
427	The shape is given by points argument which is a the return
428	value of the shape's Points() method. The coordinates in the
429	DC's coordinate system are determined with
430	self.projected_points.
431
432	The point is drawn as a circle centered on the point.
433	"""
434	points = self.projected_points(layer, points)
435	if not points:
436	return
437
438	radius = int(round(self.resolution * 5))
439	self.dc.SetBrush(brush)
440	self.dc.SetPen(pen)
441	for part in points:
442	for p in part:
443	self.dc.DrawEllipse(p.x - radius, p.y - radius,
444	2 * radius, 2 * radius)
445
446	def draw_raster_layer(self, layer):
447	"""Draw the raster layer
448
449	This implementation does the projection and scaling of the data
450	as required by the layer's and map's projections and the scale
451	and offset of the renderer and then hands the transformed data
452	to self.draw_raster_data() which has to be implemented in
453	derived classes.
454	"""
455	offx, offy = self.offset
456	width, height = self.dc.GetSizeTuple()
457
458	in_proj = ""
459	proj = layer.GetProjection()
460	if proj is not None:
461	for p in proj.GetAllParameters():
462	in_proj += "+" + p + " "
463
464	out_proj = ""
465	proj = self.map.GetProjection()
466	if proj is not None:
467	for p in proj.GetAllParameters():
468	out_proj += "+" + p + " "
469
470	xmin = (0 - offx) / self.scale
471	ymin = (offy - height) / self.scale
472	xmax = (width - offx) / self.scale
473	ymax = (offy - 0) / self.scale
474
475	try:
476	data = ProjectRasterFile(layer.GetImageFilename(),
477	in_proj, out_proj,
478	(xmin, ymin, xmax, ymax), "",
479	(width, height))
480	except (IOError, AttributeError, ValueError):
481	# Why does this catch AttributeError and ValueError?
482	# FIXME: The exception should be communicated to the user
483	# better.
484	traceback.print_exc()
485	else:
486	self.draw_raster_data(data, "BMP")
487
488	def draw_raster_data(self, data, format="BMP"):
489	"""Draw the raster image in data onto the DC
490
491	The raster image data is a string holding the data in the format
492	indicated by the format parameter. The image is assumed to be
493	exactly the size of the dc and to cover it completely.
494
495	The format parameter is a string with the name of the format.
496	The following format names should be used:
497
498	'BMP' -- Windows Bitmap
499	'JPEG' -- Jpeg
500
501	The default format is 'bmp'.
502
503	This method has to be implemented by derived classes. The
504	implementation in the derived class should try to support at
505	least the formats specified above and may support more.
506	"""
507	raise NotImplementedError
508
509	def label_font(self):
510	"""Return the font object for the label layer"""
511	raise NotImplementedError
512
513	def draw_label_layer(self, layer):
514	"""Draw the label layer
515
516	All labels are draw in the font returned by self.label_font().
517	"""
518	scale = self.scale
519	offx, offy = self.offset
520
521	self.dc.SetFont(self.label_font())
522
523	map_proj = self.map.projection
524	if map_proj is not None:
525	forward = map_proj.Forward
526	else:
527	forward = None
528
529	for label in layer.Labels():
530	x = label.x
531	y = label.y
532	text = label.text
533	if forward:
534	x, y = forward(x, y)
535	x = int(round(x * scale + offx))
536	y = int(round(-y * scale + offy))
537	width, height = self.dc.GetTextExtent(text)
538	if label.halign == ALIGN_LEFT:
539	# nothing to be done
540	pass
541	elif label.halign == ALIGN_RIGHT:
542	x = x - width
543	elif label.halign == ALIGN_CENTER:
544	x = x - width/2
545	if label.valign == ALIGN_TOP:
546	# nothing to be done
547	pass
548	elif label.valign == ALIGN_BOTTOM:
549	y = y - height
550	elif label.valign == ALIGN_CENTER:
551	y = y - height/2
552	self.dc.DrawText(text, x, y)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision