/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/UI/renderer.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/Thuban/UI/renderer.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 290 by bh, Thu Aug 29 14:11:28 2002 UTC revision 1750 by bh, Wed Sep 24 15:46:27 2003 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001, 2002 by Intevation GmbH  # Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # 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)  # This program is free software under the GPL (>=v2)
8  # Read the file COPYING coming with Thuban for details.  # Read the file COPYING coming with Thuban for details.
9    
10  __version__ = "$Revision$"  __version__ = "$Revision$"
11    
12  from wxPython.wx import wxPoint, wxColour, wxPen, wxBrush, wxFont, \  import cStringIO
      wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \  
      wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL  
13    
14  from wxproj import draw_polygon_shape  from Thuban import _
15    
16  from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \  from wxPython.wx import wxPoint, wxRect, wxPen, wxBrush, wxFont, \
17       SHAPETYPE_POINT      wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
18  from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \      wxBLACK_PEN, wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL, \
19       ALIGN_LEFT, ALIGN_RIGHT, ALIGN_BASELINE      wxBitmapFromImage, wxImageFromStream, wxBITMAP_TYPE_BMP
20    
21    from wxproj import draw_polygon_shape, draw_polygon_init
22    
23  class MapRenderer:  from Thuban.UI.common import Color2wxColour
24    from Thuban.UI.classifier import ClassDataPreviewer
25    from Thuban.UI.scalebar import ScaleBar
26    
27      """Class to render a map onto a wxDC"""  from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
28         SHAPETYPE_POINT, RAW_SHAPEFILE
29    
30      honor_visibility = 1  from Thuban.Model.color import Transparent
31    import Thuban.Model.resource
32    
33      def __init__(self, dc, scale, offset, resolution = 72.0,  from baserenderer import BaseRenderer
                  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())  
34    
35      def draw_shape_layer(self, layer):  class MapRenderer(BaseRenderer):
         scale = self.scale  
         offx, offy = self.offset  
36    
37          fill = layer.fill      """Class to render a map onto a wxDC"""
         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 self.layer_ids(layer):  
                 self.draw_polygon_shape(layer, i, pen, brush)  
         elif shapetype == SHAPETYPE_ARC:  
             for i in self.layer_ids(layer):  
                 self.draw_polygon_shape(layer, i, pen, None)  
         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 self.layer_ids(layer):  
                 f(layer, i)  
   
     def layer_ids(self, layer):  
         """Return the shape ids of the given layer that have to be drawn.  
           
         The default implementation simply returns all ids in the layer.  
         Override in derived classes to be more precise.  
         """  
         return range(layer.NumShapes())  
38    
39      def draw_polygon_shape(self, layer, index, pen, brush):      TRANSPARENT_PEN = wxTRANSPARENT_PEN
40          offx, offy = self.offset              TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH
         draw_polygon_shape(layer.shapefile.cobject(), index,  
                            self.dc, pen, brush,  
                            self.map.projection, layer.projection,  
                            self.scale, -self.scale, offx, offy)  
41    
42      def projected_points(self, layer, index):      make_point = wxPoint
43          proj = self.map.projection  
44          if proj is not None:      def tools_for_property(self, prop):
45              forward = proj.Forward          fill = prop.GetFill()
46          else:          if fill is Transparent:
47              forward = None              brush = self.TRANSPARENT_BRUSH
         proj = layer.projection  
         if proj is not None:  
             inverse = proj.Inverse  
48          else:          else:
49              inverse = None              brush = wxBrush(Color2wxColour(fill), wxSOLID)
         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)  
50    
51      def draw_label_layer(self, layer):          stroke = prop.GetLineColor()
52          scale = self.scale          if stroke is Transparent:
53          offx, offy = self.offset              pen = self.TRANSPARENT_PEN
54            else:
55                pen = wxPen(Color2wxColour(stroke), prop.GetLineWidth(), wxSOLID)
56            return pen, brush
57    
58          font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)      def low_level_renderer(self, layer):
59          self.dc.SetFont(font)          """Override inherited method to provide more efficient renderers
60    
61          map_proj = self.map.projection          If the underlying data format is not a shapefile or the layer
62          if map_proj is not None:          contains points shapes, simply use what the inherited method
63              forward = map_proj.Forward          returns.
64    
65            Otherwise, i.e. for arc and polygon use the more efficient
66            wxproj.draw_polygon_shape and its corresponding parameter
67            created with wxproj.draw_polygon_init.
68            """
69            if (layer.ShapeStore().RawShapeFormat() == RAW_SHAPEFILE
70                and layer.ShapeType() in (SHAPETYPE_ARC, SHAPETYPE_POLYGON)):
71                offx, offy = self.offset
72                return (True, draw_polygon_shape,
73                        draw_polygon_init(layer.ShapeStore().Shapefile(),
74                                          self.dc, self.map.projection,
75                                          layer.projection,
76                                          self.scale, -self.scale, offx, offy))
77          else:          else:
78              forward = None              return BaseRenderer.low_level_renderer(self, layer)
79    
80        def label_font(self):
81            return wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
82    
83          for label in layer.Labels():      def draw_raster_data(self, data):
84              x = label.x          stream = cStringIO.StringIO(data)
85              y = label.y          image = wxImageFromStream(stream, wxBITMAP_TYPE_BMP)
86              text = label.text          bitmap = wxBitmapFromImage(image)
87              if forward:          self.dc.DrawBitmap(bitmap, 0, 0)
                 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)  
88    
89    
90  class ScreenRenderer(MapRenderer):  class ScreenRenderer(MapRenderer):
91    
92      # On the screen we want to see only visible layers by default      # On the screen we want to see only visible layers by default
93      honor_visibility = 1      honor_visibility = 1
94        
95      def RenderMap(self, map, region, selected_layer, selected_shape):      def RenderMap(self, map, region, selected_layer, selected_shapes):
96          """Render the map.          """Render the map.
97    
98          Only the given region (a tuple in window coordinates as returned          Only the given region (a tuple in window coordinates as returned
99          by a wxrect's asTuple method) needs to be redrawn. Highlight the          by a wxrect's asTuple method) needs to be redrawn. Highlight the
100          shape with id selected_shape in the selected_layer.          shapes given by the ids in selected_shapes in the
101            selected_layer.
102          """          """
103          self.update_region = region          self.update_region = region
104          self.selected_layer = selected_layer          self.selected_layer = selected_layer
105          self.selected_shape = selected_shape          self.selected_shapes = selected_shapes
106          self.render_map(map)          self.render_map(map)
107    
108      def draw_shape_layer(self, layer):      def draw_shape_layer(self, layer):
109          MapRenderer.draw_shape_layer(self, layer)          MapRenderer.draw_shape_layer(self, layer)
110          if layer is self.selected_layer and self.selected_shape is not None:          if layer is self.selected_layer and self.selected_shapes:
111              pen = wxPen(wxBLACK, 3, wxSOLID)              pen = wxPen(wxBLACK, 3, wxSOLID)
112              brush = wxBrush(wxBLACK, wxCROSS_HATCH)              brush = wxBrush(wxBLACK, wxCROSS_HATCH)
113                
114              shapetype = layer.ShapeType()              shapetype = layer.ShapeType()
115              index = self.selected_shape              useraw, func, param = self.low_level_renderer(layer)
116              if shapetype == SHAPETYPE_POLYGON:              args = (pen, brush)
117                  self.draw_polygon_shape(layer, index, pen, brush)              for index in self.selected_shapes:
118              elif shapetype == SHAPETYPE_ARC:                  shape = layer.Shape(index)
119                  self.draw_polygon_shape(layer, index, pen, None)                  if useraw:
120              else:                      data = shape.RawData()
                 self.dc.SetBrush(brush)  
                 self.dc.SetPen(pen)  
                 if shapetype == SHAPETYPE_POINT:  
                     self.draw_point_shape(layer, index)  
121                  else:                  else:
122                      raise TypeError("Unhandled shape type %s" % shapetype)                      data = shape.Points()
123                    func(param, data, *args)
124    
125      def layer_ids(self, layer):      def layer_shapes(self, layer):
126          """Return the shapeids covered by the region that has to be redrawn          """Return the shapeids covered by the region that has to be redrawn
127    
128          Call the layer's ShapesInRegion method to determine the ids so          Call the layer's ShapesInRegion method to determine the ids so
# Line 264  class ScreenRenderer(MapRenderer): Line 160  class ScreenRenderer(MapRenderer):
160          return layer.ShapesInRegion((left, bottom, right, top))          return layer.ShapesInRegion((left, bottom, right, top))
161    
162    
163  class PrinterRender(MapRenderer):  class ExportRenderer(ScreenRenderer):
164    
165      # When printing we want to see all layers      honor_visibility = 1
166      honor_visibility = 0  
167        def RenderMap(self, map, region, mapregion,
168                      selected_layer, selected_shapes ):
169            """Render the map.
170    
171            The rendering device has been specified during initialisation.
172            The device border distance was set in Thuban.UI.view.OutputTranform().
173    
174            RenderMap renders a frame set (one page frame, one around
175            legend/scalebar and one around the map), the map, the legend and the
176            scalebar on the given DC. The map is rendered with the region displayed
177            in the canvas view, centered on the area available for map display.
178            """
179    
180            self.update_region = region
181            self.selected_layer = selected_layer
182            self.selected_shapes = selected_shapes
183    
184            # Get some dimensions
185            llx, lly, urx, ury = region
186            self.mapregion = mapregion
187            mminx, mminy, mmaxx, mmaxy = self.mapregion
188    
189            # Manipulate the offset to position the map
190            offx, offy = self.offset
191            # 1. Shift to corner of map drawing area
192            offx = offx + mminx
193            offy = offy + mminy
194    
195            # 2. Center the map on the map drawing area:
196            # region identifies the region on the canvas view:
197            # center of map drawing area - half the size of region: rendering origin
198            self.shiftx = (mmaxx - mminx)*0.5 - (urx - llx)*0.5
199            self.shifty = (mmaxy - mminy)*0.5 - (ury - lly)*0.5
200    
201            self.offset = (offx+self.shiftx, offy+self.shifty)
202    
203            # Draw the map
204            self.dc.BeginDrawing()
205            self.dc.DestroyClippingRegion()
206            self.dc.SetClippingRegion(mminx+self.shiftx, mminy+self.shifty,
207                                      urx, ury)
208            self.render_map(map)
209            self.dc.EndDrawing()
210    
211            # Draw the rest (frames, legend, scalebar)
212            self.dc.BeginDrawing()
213            self.dc.DestroyClippingRegion()
214    
215            # Force the font for Legend drawing
216            font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
217            self.dc.SetFont(font)
218    
219            self.render_frame(region)
220            self.render_legend(map)
221            self.render_scalebar(map)
222            self.dc.EndDrawing()
223    
224        def render_frame(self, region):
225            """Render the frames for map and legend/scalebar."""
226    
227            dc = self.dc
228            dc.SetPen(wxBLACK_PEN)
229            dc.SetBrush(wxTRANSPARENT_BRUSH)
230    
231            # Dimension stuff
232            width, height = dc.GetSizeTuple()
233            mminx, mminy, mmaxx, mmaxy = self.mapregion
234    
235            # Page Frame
236            dc.DrawRectangle(15,15,width-30, (mmaxy-mminy)+10)
237    
238            # Map Frame
239            llx, lly, urx, ury = region
240            dc.DrawRectangle(mminx + self.shiftx, mminy + self.shifty, urx, ury)
241    
242            # Legend Frame
243            dc.DrawRectangle(mmaxx+10,mminy,(width-20) - (mmaxx+10), mmaxy-mminy)
244    
245            dc.DestroyClippingRegion()
246            dc.SetClippingRegion(mmaxx+10,mminy,
247                                 (width-20) - (mmaxx+10), mmaxy-mminy)
248    
249        def render_legend(self, map):
250            """Render the legend on the Map."""
251    
252            previewer = ClassDataPreviewer()
253            dc = self.dc
254            dc.SetPen(wxBLACK_PEN)
255            dc.SetBrush(wxTRANSPARENT_BRUSH)
256    
257            # Dimension stuff
258            width, height = dc.GetSizeTuple()
259            mminx, mminy, mmaxx, mmaxy = self.mapregion
260            textwidth, textheight = dc.GetTextExtent("0")
261            iconwidth  = textheight
262            iconheight = textheight
263            stepy = textheight+3
264            dx = 10
265            posx = mmaxx + 10 + 5   # 10 pix distance mapframe/legend frame,
266                                    # 5 pix inside legend frame
267            posy = mminy + 5        # 5 pix inside legend frame
268    
269            # Render the legend
270            dc.SetTextForeground(wxBLACK)
271            if map.HasLayers():
272                layers = map.Layers()[:]
273                layers.reverse()
274                for l in layers:
275                    if l.Visible():
276                        # Render title
277                        dc.DrawText(l.Title(), posx, posy)
278                        posy+=stepy
279                        if l.HasClassification():
280                            # Render classification
281                            clazz = l.GetClassification()
282                            shapeType = l.ShapeType()
283                            for g in clazz:
284                                if g.IsVisible():
285                                    previewer.Draw(dc,
286                                        wxRect(posx+dx, posy,
287                                               iconwidth, iconheight),
288                                        g.GetProperties(), shapeType)
289                                    dc.DrawText(g.GetDisplayText(),
290                                                posx+2*dx+iconwidth, posy)
291                                    posy+=stepy
292    
293        def render_scalebar(self, map):
294            """Render the scalebar."""
295    
296            scalebar = ScaleBar(map)
297    
298            # Dimension stuff
299            width, height = self.dc.GetSizeTuple()
300            mminx, mminy, mmaxx, mmaxy = self.mapregion
301    
302            # Render the scalebar
303            scalebar.DrawScaleBar(self.scale, self.dc,
304                                 (mmaxx+10+5, mmaxy-25),
305                                 ((width-15-5) - (mmaxx+10+5),20)
306                                )
307            # 10 pix between map and legend frame, 5 pix inside legend frame
308            # 25 pix from the legend frame bottom line
309            # Width: 15 pix from DC border, 5 pix inside frame, 10, 5 as above
310            # Height: 20
311    
312    class PrinterRenderer(ExportRenderer):
313    
314        # Printing as well as Export / Screen display only the visible layer.
315        honor_visibility = 1
316    
     RenderMap = MapRenderer.render_map  
       
Legend:
Removed from v.290  
changed lines
  Added in v.1750
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26