Thuban/UI/renderer.py

# Copyright (c) 2001 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
        if stroke is None:
            pen = wxTRANSPARENT_PEN
        else:
            color = wxColour(stroke.red * 255,
                             stroke.green * 255,
                             stroke.blue * 255)
            pen = wxPen(color, 1, 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	6	# Copyright (c) 2001 by Intevation GmbH
2			# 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			if stroke is None:
76			pen = wxTRANSPARENT_PEN
77			else:
78			color = wxColour(stroke.red * 255,
79			stroke.green * 255,
80			stroke.blue * 255)
81			pen = wxPen(color, 1, wxSOLID)
82
83			map_proj = self.map.projection
84			layer_proj = layer.projection
85
86			shapetype = layer.ShapeType()
87
88			if shapetype == SHAPETYPE_POLYGON:
89			for i in range(layer.NumShapes()):
90			self.draw_polygon_shape(layer, i, pen, brush)
91			else:
92			self.dc.SetBrush(brush)
93			self.dc.SetPen(pen)
94			if shapetype == SHAPETYPE_ARC:
95			f = self.draw_arc_shape
96			elif shapetype == SHAPETYPE_POINT:
97			f = self.draw_point_shape
98			for i in range(layer.NumShapes()):
99			f(layer, i)
100
101			def draw_polygon_shape(self, layer, index, pen, brush):
102			offx, offy = self.offset
103			draw_polygon_shape(layer.shapefile.cobject(), index,
104			self.dc, pen, brush,
105			self.map.projection, layer.projection,
106			self.scale, -self.scale, offx, offy)
107
108			def projected_points(self, layer, index):
109			proj = self.map.projection
110			if proj is not None:
111			forward = proj.Forward
112			else:
113			forward = None
114			proj = layer.projection
115			if proj is not None:
116			inverse = proj.Inverse
117			else:
118			inverse = None
119			shape = layer.Shape(index)
120			points = []
121			scale = self.scale
122			offx, offy = self.offset
123			for x, y in shape.Points():
124			if inverse:
125			x, y = inverse(x, y)
126			if forward:
127			x, y = forward(x, y)
128			points.append(wxPoint(x * scale + offx,
129			-y * scale + offy))
130			return points
131
132			def draw_arc_shape(self, layer, index):
133			points = self.projected_points(layer, index)
134			self.dc.DrawLines(points)
135
136			def draw_point_shape(self, layer, index):
137			p = self.projected_points(layer, index)[0]
138			radius = self.resolution * 5
139			self.dc.DrawEllipse(p.x - radius, p.y - radius, 2radius, 2radius)
140
141			def draw_label_layer(self, layer):
142			scale = self.scale
143			offx, offy = self.offset
144
145			font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
146			self.dc.SetFont(font)
147
148			map_proj = self.map.projection
149			if map_proj is not None:
150			forward = map_proj.Forward
151			else:
152			forward = None
153
154			for label in layer.Labels():
155			x = label.x
156			y = label.y
157			text = label.text
158			if forward:
159			x, y = forward(x, y)
160			x = x * scale + offx
161			y = -y * scale + offy
162			width, height = self.dc.GetTextExtent(text)
163			if label.halign == ALIGN_LEFT:
164			# nothing to be done
165			pass
166			elif label.halign == ALIGN_RIGHT:
167			x = x - width
168			elif label.halign == ALIGN_CENTER:
169			x = x - width/2
170			if label.valign == ALIGN_TOP:
171			# nothing to be done
172			pass
173			elif label.valign == ALIGN_BOTTOM:
174			y = y - height
175			elif label.valign == ALIGN_CENTER:
176			y = y - height/2
177			self.dc.DrawText(text, x, y)
178
179
180			class ScreenRenderer(MapRenderer):
181
182			# On the screen we want to see only visible layers by default
183			honor_visibility = 1
184
185			def RenderMap(self, map, selected_layer, selected_shape):
186			self.selected_layer = selected_layer
187			self.selected_shape = selected_shape
188			self.render_map(map)
189
190			def draw_shape_layer(self, layer):
191			MapRenderer.draw_shape_layer(self, layer)
192			if layer is self.selected_layer and self.selected_shape is not None:
193			pen = wxPen(wxBLACK, 3, wxSOLID)
194			brush = wxBrush(wxBLACK, wxCROSS_HATCH)
195
196			shapetype = layer.ShapeType()
197			index = self.selected_shape
198			if shapetype == SHAPETYPE_POLYGON:
199			self.draw_polygon_shape(layer, index, pen, brush)
200			else:
201			self.dc.SetBrush(brush)
202			self.dc.SetPen(pen)
203			if shapetype == SHAPETYPE_ARC:
204			f = self.draw_arc_shape
205			elif shapetype == SHAPETYPE_POINT:
206			f = self.draw_point_shape
207			f(layer, index)
208
209
210			class PrinterRender(MapRenderer):
211
212			# When printing we want to see all layers
213			honor_visibility = 0
214
215			RenderMap = MapRenderer.render_map
216
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision