Thuban/UI/renderer.py

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

__version__ = "$Revision$"

from wxPython.wx import wxPoint, wxColour, wxPen, wxBrush, wxFont, \
     wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
     wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL

from wxproj import draw_polygon_shape

from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
     SHAPETYPE_POINT
from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
     ALIGN_LEFT, ALIGN_RIGHT, ALIGN_BASELINE


class MapRenderer:

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

    honor_visibility = 1

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

        dc -- the wxPython DC 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

        honor_visibility -- boolean. If true, honor the visibility flag
                of the layers, otherwise draw all layers. If None, 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 render_map(self, map):
        self.map = map
        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():
                self.draw_shape_layer(layer)
        self.draw_label_layer(map.LabelLayer())

    def draw_shape_layer(self, layer):
        scale = self.scale
        offx, offy = self.offset

        fill = layer.fill
        if fill is None:
            brush = wxTRANSPARENT_BRUSH
        else:
            color = wxColour(fill.red * 255,
                             fill.green * 255,
                             fill.blue * 255)
            brush = wxBrush(color, wxSOLID)
        stroke = layer.stroke
        stroke_width = layer.stroke_width
        if stroke is None:
            pen = wxTRANSPARENT_PEN
        else:
            color = wxColour(stroke.red * 255,
                             stroke.green * 255,
                             stroke.blue * 255)
            pen = wxPen(color, stroke_width, wxSOLID)

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

        shapetype = layer.ShapeType()

        if shapetype == SHAPETYPE_POLYGON:
            for i in range(layer.NumShapes()):
                self.draw_polygon_shape(layer, i, pen, brush)
        else:
            self.dc.SetBrush(brush)
            self.dc.SetPen(pen)
            if shapetype == SHAPETYPE_ARC:
                f = self.draw_arc_shape
            elif shapetype == SHAPETYPE_POINT:
                f = self.draw_point_shape
            for i in range(layer.NumShapes()):
                f(layer, i)

    def draw_polygon_shape(self, layer, index, pen, brush):
        offx, offy = self.offset        
        draw_polygon_shape(layer.shapefile.cobject(), index,
                           self.dc, pen, brush,
                           self.map.projection, layer.projection,
                           self.scale, -self.scale, offx, offy)

    def projected_points(self, layer, index):
        proj = self.map.projection
        if proj is not None:
            forward = proj.Forward
        else:
            forward = None
        proj = layer.projection
        if proj is not None:
            inverse = proj.Inverse
        else:
            inverse = None
        shape = layer.Shape(index)
        points = []
        scale = self.scale
        offx, offy = self.offset
        for x, y in shape.Points():
            if inverse:
                x, y = inverse(x, y)
            if forward:
                x, y = forward(x, y)
            points.append(wxPoint(x * scale + offx,
                                  -y * scale + offy))
        return points

    def draw_arc_shape(self, layer, index):
        points = self.projected_points(layer, index)
        self.dc.DrawLines(points)

    def draw_point_shape(self, layer, index):
        p = self.projected_points(layer, index)[0]
        radius = self.resolution * 5
        self.dc.DrawEllipse(p.x - radius, p.y - radius, 2*radius, 2*radius)

    def draw_label_layer(self, layer):
        scale = self.scale
        offx, offy = self.offset

        font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
        self.dc.SetFont(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)


class ScreenRenderer(MapRenderer):

    # On the screen we want to see only visible layers by default
    honor_visibility = 1
    
    def RenderMap(self, map, selected_layer, selected_shape):
        self.selected_layer = selected_layer
        self.selected_shape = selected_shape
        self.render_map(map)

    def draw_shape_layer(self, layer):
        MapRenderer.draw_shape_layer(self, layer)
        if layer is self.selected_layer and self.selected_shape is not None:
            pen = wxPen(wxBLACK, 3, wxSOLID)
            brush = wxBrush(wxBLACK, wxCROSS_HATCH)
            
            shapetype = layer.ShapeType()
            index = self.selected_shape
            if shapetype == SHAPETYPE_POLYGON:
                self.draw_polygon_shape(layer, index, pen, brush)
            else:
                self.dc.SetBrush(brush)
                self.dc.SetPen(pen)
                if shapetype == SHAPETYPE_ARC:
                    f = self.draw_arc_shape
                elif shapetype == SHAPETYPE_POINT:
                    f = self.draw_point_shape
                f(layer, index)


class PrinterRender(MapRenderer):

    # When printing we want to see all layers
    honor_visibility = 0

    RenderMap = MapRenderer.render_map
    
1	bh	76	# Copyright (c) 2001, 2002 by Intevation GmbH
2	bh	6	# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			__version__ = "$Revision$"
9
10			from wxPython.wx import wxPoint, wxColour, wxPen, wxBrush, wxFont, \
11			wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
12			wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL
13
14			from wxproj import draw_polygon_shape
15
16			from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
17			SHAPETYPE_POINT
18			from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
19			ALIGN_LEFT, ALIGN_RIGHT, ALIGN_BASELINE
20
21
22			class MapRenderer:
23
24			"""Class to render a map onto a wxDC"""
25
26			honor_visibility = 1
27
28			def __init__(self, dc, scale, offset, resolution = 72.0,
29			honor_visibility = None):
30			"""Inititalize the renderer.
31
32			dc -- the wxPython DC to render on
33			scale, offset -- the scale factor and translation to convert
34			between projected coordinates and the DC coordinates
35
36			resolution -- the assumed resolution of the DC. Used to convert
37			absolute lengths like font sizes to DC coordinates
38
39			honor_visibility -- boolean. If true, honor the visibility flag
40			of the layers, otherwise draw all layers. If None, use
41			the renderer's default.
42			"""
43			# resolution in pixel/inch
44			self.dc = dc
45			self.scale = scale
46			self.offset = offset
47			if honor_visibility is not None:
48			self.honor_visibility = honor_visibility
49			# store the resolution in pixel/point because it's more useful
50			# later.
51			self.resolution = resolution / 72.0
52
53			def render_map(self, map):
54			self.map = map
55			for layer in map.Layers():
56			# if honor_visibility is true, only draw visible layers,
57			# otherwise draw all layers
58			if not self.honor_visibility or layer.Visible():
59			self.draw_shape_layer(layer)
60			self.draw_label_layer(map.LabelLayer())
61
62			def draw_shape_layer(self, layer):
63			scale = self.scale
64			offx, offy = self.offset
65
66			fill = layer.fill
67			if fill is None:
68			brush = wxTRANSPARENT_BRUSH
69			else:
70			color = wxColour(fill.red * 255,
71			fill.green * 255,
72			fill.blue * 255)
73			brush = wxBrush(color, wxSOLID)
74			stroke = layer.stroke
75	bh	76	stroke_width = layer.stroke_width
76	bh	6	if stroke is None:
77			pen = wxTRANSPARENT_PEN
78			else:
79			color = wxColour(stroke.red * 255,
80			stroke.green * 255,
81			stroke.blue * 255)
82	bh	76	pen = wxPen(color, stroke_width, wxSOLID)
83	bh	6
84			map_proj = self.map.projection
85			layer_proj = layer.projection
86
87			shapetype = layer.ShapeType()
88
89			if shapetype == SHAPETYPE_POLYGON:
90			for i in range(layer.NumShapes()):
91			self.draw_polygon_shape(layer, i, pen, brush)
92			else:
93			self.dc.SetBrush(brush)
94			self.dc.SetPen(pen)
95			if shapetype == SHAPETYPE_ARC:
96			f = self.draw_arc_shape
97			elif shapetype == SHAPETYPE_POINT:
98			f = self.draw_point_shape
99			for i in range(layer.NumShapes()):
100			f(layer, i)
101
102			def draw_polygon_shape(self, layer, index, pen, brush):
103			offx, offy = self.offset
104			draw_polygon_shape(layer.shapefile.cobject(), index,
105			self.dc, pen, brush,
106			self.map.projection, layer.projection,
107			self.scale, -self.scale, offx, offy)
108
109			def projected_points(self, layer, index):
110			proj = self.map.projection
111			if proj is not None:
112			forward = proj.Forward
113			else:
114			forward = None
115			proj = layer.projection
116			if proj is not None:
117			inverse = proj.Inverse
118			else:
119			inverse = None
120			shape = layer.Shape(index)
121			points = []
122			scale = self.scale
123			offx, offy = self.offset
124			for x, y in shape.Points():
125			if inverse:
126			x, y = inverse(x, y)
127			if forward:
128			x, y = forward(x, y)
129			points.append(wxPoint(x * scale + offx,
130			-y * scale + offy))
131			return points
132
133			def draw_arc_shape(self, layer, index):
134			points = self.projected_points(layer, index)
135			self.dc.DrawLines(points)
136
137			def draw_point_shape(self, layer, index):
138			p = self.projected_points(layer, index)[0]
139			radius = self.resolution * 5
140			self.dc.DrawEllipse(p.x - radius, p.y - radius, 2radius, 2radius)
141
142			def draw_label_layer(self, layer):
143			scale = self.scale
144			offx, offy = self.offset
145
146			font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
147			self.dc.SetFont(font)
148
149			map_proj = self.map.projection
150			if map_proj is not None:
151			forward = map_proj.Forward
152			else:
153			forward = None
154
155			for label in layer.Labels():
156			x = label.x
157			y = label.y
158			text = label.text
159			if forward:
160			x, y = forward(x, y)
161			x = x * scale + offx
162			y = -y * scale + offy
163			width, height = self.dc.GetTextExtent(text)
164			if label.halign == ALIGN_LEFT:
165			# nothing to be done
166			pass
167			elif label.halign == ALIGN_RIGHT:
168			x = x - width
169			elif label.halign == ALIGN_CENTER:
170			x = x - width/2
171			if label.valign == ALIGN_TOP:
172			# nothing to be done
173			pass
174			elif label.valign == ALIGN_BOTTOM:
175			y = y - height
176			elif label.valign == ALIGN_CENTER:
177			y = y - height/2
178			self.dc.DrawText(text, x, y)
179
180
181			class ScreenRenderer(MapRenderer):
182
183			# On the screen we want to see only visible layers by default
184			honor_visibility = 1
185
186			def RenderMap(self, map, selected_layer, selected_shape):
187			self.selected_layer = selected_layer
188			self.selected_shape = selected_shape
189			self.render_map(map)
190
191			def draw_shape_layer(self, layer):
192			MapRenderer.draw_shape_layer(self, layer)
193			if layer is self.selected_layer and self.selected_shape is not None:
194			pen = wxPen(wxBLACK, 3, wxSOLID)
195			brush = wxBrush(wxBLACK, wxCROSS_HATCH)
196
197			shapetype = layer.ShapeType()
198			index = self.selected_shape
199			if shapetype == SHAPETYPE_POLYGON:
200			self.draw_polygon_shape(layer, index, pen, brush)
201			else:
202			self.dc.SetBrush(brush)
203			self.dc.SetPen(pen)
204			if shapetype == SHAPETYPE_ARC:
205			f = self.draw_arc_shape
206			elif shapetype == SHAPETYPE_POINT:
207			f = self.draw_point_shape
208			f(layer, index)
209
210
211			class PrinterRender(MapRenderer):
212
213			# When printing we want to see all layers
214			honor_visibility = 0
215
216			RenderMap = MapRenderer.render_map
217
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision