Thuban/UI/renderer.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.

from __future__ import generators

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

import cStringIO

from Thuban import _

from wxPython.wx import wxPoint, wxRect, wxPen, wxBrush, wxFont, \
    wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
    wxBLACK_PEN, wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL, \
    wxBitmapFromImage, wxImageFromStream, wxBITMAP_TYPE_BMP, wxBITMAP_TYPE_JPEG

from wxproj import draw_polygon_shape, draw_polygon_init

from Thuban.UI.common import Color2wxColour
from Thuban.UI.classifier import ClassDataPreviewer
from Thuban.UI.scalebar import ScaleBar

from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
     SHAPETYPE_POINT, RAW_SHAPEFILE

from Thuban.Model.color import Transparent
import Thuban.Model.resource

from baserenderer import BaseRenderer


# Map the strings used for the format parameter of the draw_raster_data
# method to the appropriate wxWindows constants
raster_format_map = {
    "BMP": wxBITMAP_TYPE_BMP,
    "JPEG": wxBITMAP_TYPE_JPEG,
    }

class MapRenderer(BaseRenderer):

    """Class to render a map onto a wxDC"""

    TRANSPARENT_PEN = wxTRANSPARENT_PEN
    TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH

    make_point = wxPoint

    def tools_for_property(self, prop):
        fill = prop.GetFill()
        if fill is Transparent:
            brush = self.TRANSPARENT_BRUSH
        else:
            brush = wxBrush(Color2wxColour(fill), wxSOLID)

        stroke = prop.GetLineColor()
        if stroke is Transparent:
            pen = self.TRANSPARENT_PEN
        else:
            pen = wxPen(Color2wxColour(stroke), prop.GetLineWidth(), wxSOLID)
        return pen, brush

    def low_level_renderer(self, layer):
        """Override inherited method to provide more efficient renderers

        If the underlying data format is not a shapefile or the layer
        contains points shapes, simply use what the inherited method
        returns.

        Otherwise, i.e. for arc and polygon use the more efficient
        wxproj.draw_polygon_shape and its corresponding parameter
        created with wxproj.draw_polygon_init.
        """
        if (layer.ShapeStore().RawShapeFormat() == RAW_SHAPEFILE
            and layer.ShapeType() in (SHAPETYPE_ARC, SHAPETYPE_POLYGON)):
            offx, offy = self.offset
            return (True, draw_polygon_shape,
                    draw_polygon_init(layer.ShapeStore().Shapefile(),
                                      self.dc, self.map.projection,
                                      layer.projection,
                                      self.scale, -self.scale, offx, offy))
        else:
            return BaseRenderer.low_level_renderer(self, layer)

    def label_font(self):
        return wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)

    def draw_raster_data(self, data, format = 'BMP'):
        stream = cStringIO.StringIO(data)
        image = wxImageFromStream(stream, raster_format_map[format])
        bitmap = wxBitmapFromImage(image)
        self.dc.DrawBitmap(bitmap, 0, 0)


class ScreenRenderer(MapRenderer):

    # On the screen we want to see only visible layers by default
    honor_visibility = 1

    def RenderMap(self, selected_layer, selected_shapes):
        """Render the map.

        Only the given region (a tuple in window coordinates as returned
        by a wxrect's asTuple method) needs to be redrawn. Highlight the
        shapes given by the ids in selected_shapes in the
        selected_layer.
        """
        self.selected_layer = selected_layer
        self.selected_shapes = selected_shapes
        self.render_map()

    def RenderMapIncrementally(self):
        """Render the map.

        Only the given region (a tuple in window coordinates as returned
        by a wxrect's asTuple method) needs to be redrawn. Highlight the
        shapes given by the ids in selected_shapes in the
        selected_layer.
        """
        return self.render_map_incrementally()

    def draw_selection_incrementally(self, layer, selected_shapes):
        pen = wxPen(wxBLACK, 3, wxSOLID)
        brush = wxBrush(wxBLACK, wxCROSS_HATCH)

        shapetype = layer.ShapeType()
        useraw, func, param = self.low_level_renderer(layer)
        args = (pen, brush)
        count = 0
        for index in selected_shapes:
            count += 1
            shape = layer.Shape(index)
            if useraw:
                data = shape.RawData()
            else:
                data = shape.Points()
            func(param, data, *args)
            if count % 500 == 0:
                yield True

    def layer_shapes(self, layer):
        """Return the shapeids covered by the region that has to be redrawn

        Call the layer's ShapesInRegion method to determine the ids so
        that it can use the quadtree.
        """
        # FIXME: the quad-tree should be built from the projected
        # coordinates not the lat-long ones because it's not trivial to
        # determine an appropriate rectangle in lat-long for a given
        # rectangle in projected coordinates which we have to start from
        # here.
        proj = self.map.projection
        if proj is not None:
            inverse = proj.Inverse
        else:
            inverse = None

        scale = self.scale
        offx, offy = self.offset
        xs = []
        ys = []
        x, y, width, height = self.region
        for winx, winy in ((x, y), (x + width, y),
                           (x + width, y + height), (x, y + height)):
            px = (winx - offx) / scale
            py = -(winy - offy) / scale
            if inverse:
                px, py = inverse(px, py)
            xs.append(px)
            ys.append(py)
        left = min(xs)
        right = max(xs)
        top = max(ys)
        bottom = min(ys)

        return layer.ShapesInRegion((left, bottom, right, top))


class ExportRenderer(ScreenRenderer):

    honor_visibility = 1

    def __init__(self, *args, **kw):
        """Initialize the ExportRenderer.

        In addition to all parameters of the the ScreenRender
        constructor, this class requires and additional keyword argument
        destination_region with a tuple (minx, miny, maxx, maxy) giving
        the region in dc coordinates which is to contain the map.
        """
        self.destination_region = kw["destination_region"]
        del kw["destination_region"]
        ScreenRenderer.__init__(self, *args, **kw)

    def RenderMap(self, selected_layer, selected_shapes):
        """Render the map.

        The rendering device has been specified during initialisation.
        The device border distance was set in
        Thuban.UI.viewport.output_transform().

        RenderMap renders a frame set (one page frame, one around
        legend/scalebar and one around the map), the map, the legend and
        the scalebar on the given DC. The map is rendered with the
        region displayed in the canvas view, centered on the area
        available for map display.
        """

        self.selected_layer = selected_layer
        self.selected_shapes = selected_shapes

        # Get some dimensions
        llx, lly, urx, ury = self.region
        mminx, mminy, mmaxx, mmaxy = self.destination_region

        # Manipulate the offset to position the map
        offx, offy = self.offset
        # 1. Shift to corner of map drawing area
        offx = offx + mminx
        offy = offy + mminy

        # 2. Center the map on the map drawing area:
        # region identifies the region on the canvas view:
        # center of map drawing area - half the size of region: rendering origin
        self.shiftx = (mmaxx - mminx)*0.5 - (urx - llx)*0.5
        self.shifty = (mmaxy - mminy)*0.5 - (ury - lly)*0.5

        self.offset = (offx+self.shiftx, offy+self.shifty)

        # Draw the map
        self.dc.BeginDrawing()
        self.dc.DestroyClippingRegion()
        self.dc.SetClippingRegion(mminx+self.shiftx, mminy+self.shifty,
                                  urx, ury)
        self.render_map()
        self.dc.EndDrawing()

        # Draw the rest (frames, legend, scalebar)
        self.dc.BeginDrawing()
        self.dc.DestroyClippingRegion()

        # Force the font for Legend drawing
        font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
        self.dc.SetFont(font)

        self.render_frame()
        self.render_legend()
        self.render_scalebar()
        self.dc.EndDrawing()

    def render_frame(self):
        """Render the frames for map and legend/scalebar."""

        dc = self.dc
        dc.SetPen(wxBLACK_PEN)
        dc.SetBrush(wxTRANSPARENT_BRUSH)

        # Dimension stuff
        width, height = dc.GetSizeTuple()
        mminx, mminy, mmaxx, mmaxy = self.destination_region

        # Page Frame
        dc.DrawRectangle(15,15,width-30, (mmaxy-mminy)+10)

        # Map Frame
        llx, lly, urx, ury = self.region
        dc.DrawRectangle(mminx + self.shiftx, mminy + self.shifty, urx, ury)

        # Legend Frame
        dc.DrawRectangle(mmaxx+10,mminy,(width-20) - (mmaxx+10), mmaxy-mminy)

        dc.DestroyClippingRegion()
        dc.SetClippingRegion(mmaxx+10,mminy,
                             (width-20) - (mmaxx+10), mmaxy-mminy)

    def render_legend(self):
        """Render the legend on the Map."""

        previewer = ClassDataPreviewer()
        dc = self.dc
        dc.SetPen(wxBLACK_PEN)
        dc.SetBrush(wxTRANSPARENT_BRUSH)

        # Dimension stuff
        width, height = dc.GetSizeTuple()
        mminx, mminy, mmaxx, mmaxy = self.destination_region
        textwidth, textheight = dc.GetTextExtent("0")
        iconwidth  = textheight
        iconheight = textheight
        stepy = textheight+3
        dx = 10
        posx = mmaxx + 10 + 5   # 10 pix distance mapframe/legend frame,
                                # 5 pix inside legend frame
        posy = mminy + 5        # 5 pix inside legend frame

        # Render the legend
        dc.SetTextForeground(wxBLACK)
        if self.map.HasLayers():
            layers = self.map.Layers()[:]
            layers.reverse()
            for l in layers:
                if l.Visible():
                    # Render title
                    dc.DrawText(l.Title(), posx, posy)
                    posy+=stepy
                    if l.HasClassification():
                        # Render classification
                        clazz = l.GetClassification()
                        shapeType = l.ShapeType()
                        for g in clazz:
                            if g.IsVisible():
                                previewer.Draw(dc,
                                    wxRect(posx+dx, posy,
                                           iconwidth, iconheight),
                                    g.GetProperties(), shapeType)
                                dc.DrawText(g.GetDisplayText(),
                                            posx+2*dx+iconwidth, posy)
                                posy+=stepy

    def render_scalebar(self):
        """Render the scalebar."""

        scalebar = ScaleBar(self.map)

        # Dimension stuff
        width, height = self.dc.GetSizeTuple()
        mminx, mminy, mmaxx, mmaxy = self.destination_region

        # Render the scalebar
        scalebar.DrawScaleBar(self.scale, self.dc,
                             (mmaxx+10+5, mmaxy-25),
                             ((width-15-5) - (mmaxx+10+5),20)
                            )
        # 10 pix between map and legend frame, 5 pix inside legend frame
        # 25 pix from the legend frame bottom line
        # Width: 15 pix from DC border, 5 pix inside frame, 10, 5 as above
        # Height: 20

class PrinterRenderer(ExportRenderer):

    # Printing as well as Export / Screen display only the visible layer.
    honor_visibility = 1

1	# 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	from __future__ import generators
11
12	__version__ = "$Revision$"
13	# $Source$
14	# $Id$
15
16	import cStringIO
17
18	from Thuban import _
19
20	from wxPython.wx import wxPoint, wxRect, wxPen, wxBrush, wxFont, \
21	wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
22	wxBLACK_PEN, wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL, \
23	wxBitmapFromImage, wxImageFromStream, wxBITMAP_TYPE_BMP, wxBITMAP_TYPE_JPEG
24
25	from wxproj import draw_polygon_shape, draw_polygon_init
26
27	from Thuban.UI.common import Color2wxColour
28	from Thuban.UI.classifier import ClassDataPreviewer
29	from Thuban.UI.scalebar import ScaleBar
30
31	from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
32	SHAPETYPE_POINT, RAW_SHAPEFILE
33
34	from Thuban.Model.color import Transparent
35	import Thuban.Model.resource
36
37	from baserenderer import BaseRenderer
38
39
40	# Map the strings used for the format parameter of the draw_raster_data
41	# method to the appropriate wxWindows constants
42	raster_format_map = {
43	"BMP": wxBITMAP_TYPE_BMP,
44	"JPEG": wxBITMAP_TYPE_JPEG,
45	}
46
47	class MapRenderer(BaseRenderer):
48
49	"""Class to render a map onto a wxDC"""
50
51	TRANSPARENT_PEN = wxTRANSPARENT_PEN
52	TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH
53
54	make_point = wxPoint
55
56	def tools_for_property(self, prop):
57	fill = prop.GetFill()
58	if fill is Transparent:
59	brush = self.TRANSPARENT_BRUSH
60	else:
61	brush = wxBrush(Color2wxColour(fill), wxSOLID)
62
63	stroke = prop.GetLineColor()
64	if stroke is Transparent:
65	pen = self.TRANSPARENT_PEN
66	else:
67	pen = wxPen(Color2wxColour(stroke), prop.GetLineWidth(), wxSOLID)
68	return pen, brush
69
70	def low_level_renderer(self, layer):
71	"""Override inherited method to provide more efficient renderers
72
73	If the underlying data format is not a shapefile or the layer
74	contains points shapes, simply use what the inherited method
75	returns.
76
77	Otherwise, i.e. for arc and polygon use the more efficient
78	wxproj.draw_polygon_shape and its corresponding parameter
79	created with wxproj.draw_polygon_init.
80	"""
81	if (layer.ShapeStore().RawShapeFormat() == RAW_SHAPEFILE
82	and layer.ShapeType() in (SHAPETYPE_ARC, SHAPETYPE_POLYGON)):
83	offx, offy = self.offset
84	return (True, draw_polygon_shape,
85	draw_polygon_init(layer.ShapeStore().Shapefile(),
86	self.dc, self.map.projection,
87	layer.projection,
88	self.scale, -self.scale, offx, offy))
89	else:
90	return BaseRenderer.low_level_renderer(self, layer)
91
92	def label_font(self):
93	return wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
94
95	def draw_raster_data(self, data, format = 'BMP'):
96	stream = cStringIO.StringIO(data)
97	image = wxImageFromStream(stream, raster_format_map[format])
98	bitmap = wxBitmapFromImage(image)
99	self.dc.DrawBitmap(bitmap, 0, 0)
100
101
102	class ScreenRenderer(MapRenderer):
103
104	# On the screen we want to see only visible layers by default
105	honor_visibility = 1
106
107	def RenderMap(self, selected_layer, selected_shapes):
108	"""Render the map.
109
110	Only the given region (a tuple in window coordinates as returned
111	by a wxrect's asTuple method) needs to be redrawn. Highlight the
112	shapes given by the ids in selected_shapes in the
113	selected_layer.
114	"""
115	self.selected_layer = selected_layer
116	self.selected_shapes = selected_shapes
117	self.render_map()
118
119	def RenderMapIncrementally(self):
120	"""Render the map.
121
122	Only the given region (a tuple in window coordinates as returned
123	by a wxrect's asTuple method) needs to be redrawn. Highlight the
124	shapes given by the ids in selected_shapes in the
125	selected_layer.
126	"""
127	return self.render_map_incrementally()
128
129	def draw_selection_incrementally(self, layer, selected_shapes):
130	pen = wxPen(wxBLACK, 3, wxSOLID)
131	brush = wxBrush(wxBLACK, wxCROSS_HATCH)
132
133	shapetype = layer.ShapeType()
134	useraw, func, param = self.low_level_renderer(layer)
135	args = (pen, brush)
136	count = 0
137	for index in selected_shapes:
138	count += 1
139	shape = layer.Shape(index)
140	if useraw:
141	data = shape.RawData()
142	else:
143	data = shape.Points()
144	func(param, data, *args)
145	if count % 500 == 0:
146	yield True
147
148	def layer_shapes(self, layer):
149	"""Return the shapeids covered by the region that has to be redrawn
150
151	Call the layer's ShapesInRegion method to determine the ids so
152	that it can use the quadtree.
153	"""
154	# FIXME: the quad-tree should be built from the projected
155	# coordinates not the lat-long ones because it's not trivial to
156	# determine an appropriate rectangle in lat-long for a given
157	# rectangle in projected coordinates which we have to start from
158	# here.
159	proj = self.map.projection
160	if proj is not None:
161	inverse = proj.Inverse
162	else:
163	inverse = None
164
165	scale = self.scale
166	offx, offy = self.offset
167	xs = []
168	ys = []
169	x, y, width, height = self.region
170	for winx, winy in ((x, y), (x + width, y),
171	(x + width, y + height), (x, y + height)):
172	px = (winx - offx) / scale
173	py = -(winy - offy) / scale
174	if inverse:
175	px, py = inverse(px, py)
176	xs.append(px)
177	ys.append(py)
178	left = min(xs)
179	right = max(xs)
180	top = max(ys)
181	bottom = min(ys)
182
183	return layer.ShapesInRegion((left, bottom, right, top))
184
185
186	class ExportRenderer(ScreenRenderer):
187
188	honor_visibility = 1
189
190	def __init__(self, args, *kw):
191	"""Initialize the ExportRenderer.
192
193	In addition to all parameters of the the ScreenRender
194	constructor, this class requires and additional keyword argument
195	destination_region with a tuple (minx, miny, maxx, maxy) giving
196	the region in dc coordinates which is to contain the map.
197	"""
198	self.destination_region = kw["destination_region"]
199	del kw["destination_region"]
200	ScreenRenderer.__init__(self, args, *kw)
201
202	def RenderMap(self, selected_layer, selected_shapes):
203	"""Render the map.
204
205	The rendering device has been specified during initialisation.
206	The device border distance was set in
207	Thuban.UI.viewport.output_transform().
208
209	RenderMap renders a frame set (one page frame, one around
210	legend/scalebar and one around the map), the map, the legend and
211	the scalebar on the given DC. The map is rendered with the
212	region displayed in the canvas view, centered on the area
213	available for map display.
214	"""
215
216	self.selected_layer = selected_layer
217	self.selected_shapes = selected_shapes
218
219	# Get some dimensions
220	llx, lly, urx, ury = self.region
221	mminx, mminy, mmaxx, mmaxy = self.destination_region
222
223	# Manipulate the offset to position the map
224	offx, offy = self.offset
225	# 1. Shift to corner of map drawing area
226	offx = offx + mminx
227	offy = offy + mminy
228
229	# 2. Center the map on the map drawing area:
230	# region identifies the region on the canvas view:
231	# center of map drawing area - half the size of region: rendering origin
232	self.shiftx = (mmaxx - mminx)0.5 - (urx - llx)0.5
233	self.shifty = (mmaxy - mminy)0.5 - (ury - lly)0.5
234
235	self.offset = (offx+self.shiftx, offy+self.shifty)
236
237	# Draw the map
238	self.dc.BeginDrawing()
239	self.dc.DestroyClippingRegion()
240	self.dc.SetClippingRegion(mminx+self.shiftx, mminy+self.shifty,
241	urx, ury)
242	self.render_map()
243	self.dc.EndDrawing()
244
245	# Draw the rest (frames, legend, scalebar)
246	self.dc.BeginDrawing()
247	self.dc.DestroyClippingRegion()
248
249	# Force the font for Legend drawing
250	font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
251	self.dc.SetFont(font)
252
253	self.render_frame()
254	self.render_legend()
255	self.render_scalebar()
256	self.dc.EndDrawing()
257
258	def render_frame(self):
259	"""Render the frames for map and legend/scalebar."""
260
261	dc = self.dc
262	dc.SetPen(wxBLACK_PEN)
263	dc.SetBrush(wxTRANSPARENT_BRUSH)
264
265	# Dimension stuff
266	width, height = dc.GetSizeTuple()
267	mminx, mminy, mmaxx, mmaxy = self.destination_region
268
269	# Page Frame
270	dc.DrawRectangle(15,15,width-30, (mmaxy-mminy)+10)
271
272	# Map Frame
273	llx, lly, urx, ury = self.region
274	dc.DrawRectangle(mminx + self.shiftx, mminy + self.shifty, urx, ury)
275
276	# Legend Frame
277	dc.DrawRectangle(mmaxx+10,mminy,(width-20) - (mmaxx+10), mmaxy-mminy)
278
279	dc.DestroyClippingRegion()
280	dc.SetClippingRegion(mmaxx+10,mminy,
281	(width-20) - (mmaxx+10), mmaxy-mminy)
282
283	def render_legend(self):
284	"""Render the legend on the Map."""
285
286	previewer = ClassDataPreviewer()
287	dc = self.dc
288	dc.SetPen(wxBLACK_PEN)
289	dc.SetBrush(wxTRANSPARENT_BRUSH)
290
291	# Dimension stuff
292	width, height = dc.GetSizeTuple()
293	mminx, mminy, mmaxx, mmaxy = self.destination_region
294	textwidth, textheight = dc.GetTextExtent("0")
295	iconwidth = textheight
296	iconheight = textheight
297	stepy = textheight+3
298	dx = 10
299	posx = mmaxx + 10 + 5 # 10 pix distance mapframe/legend frame,
300	# 5 pix inside legend frame
301	posy = mminy + 5 # 5 pix inside legend frame
302
303	# Render the legend
304	dc.SetTextForeground(wxBLACK)
305	if self.map.HasLayers():
306	layers = self.map.Layers()[:]
307	layers.reverse()
308	for l in layers:
309	if l.Visible():
310	# Render title
311	dc.DrawText(l.Title(), posx, posy)
312	posy+=stepy
313	if l.HasClassification():
314	# Render classification
315	clazz = l.GetClassification()
316	shapeType = l.ShapeType()
317	for g in clazz:
318	if g.IsVisible():
319	previewer.Draw(dc,
320	wxRect(posx+dx, posy,
321	iconwidth, iconheight),
322	g.GetProperties(), shapeType)
323	dc.DrawText(g.GetDisplayText(),
324	posx+2*dx+iconwidth, posy)
325	posy+=stepy
326
327	def render_scalebar(self):
328	"""Render the scalebar."""
329
330	scalebar = ScaleBar(self.map)
331
332	# Dimension stuff
333	width, height = self.dc.GetSizeTuple()
334	mminx, mminy, mmaxx, mmaxy = self.destination_region
335
336	# Render the scalebar
337	scalebar.DrawScaleBar(self.scale, self.dc,
338	(mmaxx+10+5, mmaxy-25),
339	((width-15-5) - (mmaxx+10+5),20)
340	)
341	# 10 pix between map and legend frame, 5 pix inside legend frame
342	# 25 pix from the legend frame bottom line
343	# Width: 15 pix from DC border, 5 pix inside frame, 10, 5 as above
344	# Height: 20
345
346	class PrinterRenderer(ExportRenderer):
347
348	# Printing as well as Export / Screen display only the visible layer.
349	honor_visibility = 1
350
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision