/[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 394 by jonathan, Mon Feb 10 15:27:13 2003 UTC revision 1593 by bh, Fri Aug 15 14:10: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  
   
 from wxproj import draw_polygon_shape  
13    
14  from Thuban import _  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 Thuban.Model.classification import Classification  from wxproj import draw_polygon_shape, draw_polygon_init
22    
23    from Thuban.UI.common import Color2wxColour
24    from Thuban.UI.classifier import ClassDataPreviewer
25    from Thuban.UI.scalebar import ScaleBar
26    
27  class MapRenderer:  from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
28         SHAPETYPE_POINT, RAW_SHAPEFILE
29    
30      """Class to render a map onto a wxDC"""  from Thuban.Model.color import Transparent
31    import Thuban.Model.resource
32    
33      honor_visibility = 1  from baserenderer import BaseRenderer
34    
35      def __init__(self, dc, scale, offset, resolution = 72.0,  class MapRenderer(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())  
36    
37      def draw_shape_layer(self, layer):      """Class to render a map onto a wxDC"""
         scale = self.scale  
         offx, offy = self.offset  
38    
39          map_proj = self.map.projection      TRANSPARENT_PEN = wxTRANSPARENT_PEN
40          layer_proj = layer.projection      TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH
41    
42          shapetype = layer.ShapeType()      make_point = wxPoint
43    
44          brush = wxTRANSPARENT_BRUSH      def tools_for_property(self, prop):
45          pen   = wxTRANSPARENT_PEN          fill = prop.GetFill()
46            if fill is Transparent:
47                brush = self.TRANSPARENT_BRUSH
48            else:
49                brush = wxBrush(Color2wxColour(fill), wxSOLID)
50    
51          old_prop = None          stroke = prop.GetLineColor()
52          for i in self.layer_ids(layer):          if stroke is Transparent:
53              value = None              pen = self.TRANSPARENT_PEN
54              shape = layer.Shape(i)          else:
55              lc = layer.classification              pen = wxPen(Color2wxColour(stroke), prop.GetLineWidth(), wxSOLID)
56              field = lc.field          return pen, brush
   
             if field is not None:  
                 record = layer.table.read_record(i)  
                 if record is not None:  
                     value = record[field]  
   
             #  
             # if the above statements fail 'value' should  
             # be null, at which point this call will  
             # at least retreive the NullData  
             #  
             prop = lc.GetProperties(value)  
57    
58              if prop != old_prop:      def low_level_renderer(self, layer):
59                  old_prop = prop          """Override inherited method to provide more efficient renderers
60    
61                  if shapetype == SHAPETYPE_ARC:          If the underlying data format is not a shapefile or the layer
62                      fill = None          contains points shapes, simply use what the inherited method
63                  else:          returns.
64                      fill = prop.GetFill()  
65                Otherwise, i.e. for arc and polygon use the more efficient
66                  if fill is None:          wxproj.draw_polygon_shape and its corresponding parameter
67                      brush = wxTRANSPARENT_BRUSH          created with wxproj.draw_polygon_init.
                 else:  
                     color = wxColour(fill.red * 255,  
                                      fill.green * 255,  
                                      fill.blue * 255)  
                     brush = wxBrush(color, wxSOLID)  
       
                 stroke = prop.GetStroke()  
                 stroke_width = prop.GetStrokeWidth()  
                 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)  
       
             if shapetype == SHAPETYPE_POINT:  
                 self.dc.SetBrush(brush)  
                 self.dc.SetPen(pen)  
                 self.draw_point_shape(layer, i)  
             else:  
                 self.draw_polygon_shape(layer, i, pen, brush)  
   
     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.  
68          """          """
69          return range(layer.NumShapes())          if (layer.ShapeStore().RawShapeFormat() == RAW_SHAPEFILE
70                and layer.ShapeType() in (SHAPETYPE_ARC, SHAPETYPE_POLYGON)):
71      def draw_polygon_shape(self, layer, index, pen, brush):              offx, offy = self.offset
72          offx, offy = self.offset                      return (True, draw_polygon_shape,
73          draw_polygon_shape(layer.shapefile.cobject(), index,                      draw_polygon_init(layer.ShapeStore().Shapefile(),
74                             self.dc, pen, brush,                                        self.dc, self.map.projection,
75                             self.map.projection, layer.projection,                                        layer.projection,
76                             self.scale, -self.scale, offx, offy)                                        self.scale, -self.scale, offx, offy))
   
     def projected_points(self, layer, index):  
         proj = self.map.projection  
         if proj is not None:  
             forward = proj.Forward  
77          else:          else:
78              forward = None              return BaseRenderer.low_level_renderer(self, layer)
         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  
79    
80          font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)      def label_font(self):
81          self.dc.SetFont(font)          return wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
   
         map_proj = self.map.projection  
         if map_proj is not None:  
             forward = map_proj.Forward  
         else:  
             forward = None  
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 289  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        honor_visibility = 1
166    
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      # When printing we want to see all layers          RenderMap renders a frame set (one page frame, one around
175      honor_visibility = 0          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.394  
changed lines
  Added in v.1593
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26