/[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 468 by jonathan, Wed Mar 5 18:19:13 2003 UTC revision 1750 by bh, Wed Sep 24 15:46:27 2003 UTC
# Line 2  Line 2 
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]>
4  # Jonathan Coles <[email protected]>  # 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, 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 _
 from Thuban.UI.common import *  
   
 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  
   
 from Thuban.Model.classification import Classification  
 from Thuban.Model.color import Color  
   
15    
16  class MapRenderer:  from wxPython.wx import wxPoint, wxRect, wxPen, wxBrush, wxFont, \
17        wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
18        wxBLACK_PEN, wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL, \
19        wxBitmapFromImage, wxImageFromStream, wxBITMAP_TYPE_BMP
20    
21      """Class to render a map onto a wxDC"""  from wxproj import draw_polygon_shape, draw_polygon_init
   
     honor_visibility = 1  
22    
23      def __init__(self, dc, scale, offset, resolution = 72.0,  from Thuban.UI.common import Color2wxColour
24                   honor_visibility = None):  from Thuban.UI.classifier import ClassDataPreviewer
25          """Inititalize the renderer.  from Thuban.UI.scalebar import ScaleBar
   
         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())  
26    
27      def draw_shape_layer(self, layer):  from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
28          scale = self.scale       SHAPETYPE_POINT, RAW_SHAPEFILE
         offx, offy = self.offset  
29    
30          map_proj = self.map.projection  from Thuban.Model.color import Transparent
31          layer_proj = layer.projection  import Thuban.Model.resource
32    
33          shapetype = layer.ShapeType()  from baserenderer import BaseRenderer
34    
35          brush = wxTRANSPARENT_BRUSH  class MapRenderer(BaseRenderer):
         pen   = wxTRANSPARENT_PEN  
36    
37          old_prop = None      """Class to render a map onto a wxDC"""
         lc = layer.GetClassification()  
         field = lc.GetField()  
   
         defaultProps = lc.GetDefaultGroup().GetProperties()  
   
         for i in self.layer_ids(layer):  
             value = None  
   
             if field is not None:  
                 try:  
                     record = layer.table.read_record(i)  
                     if record is not None:  
                         value = record[field]  
                 except:  
                     pass  
   
                 #  
                 # if the above statements fail 'value' should  
                 # be null, at which point this call will  
                 # at least retreive the NullData  
                 #  
                 prop = lc.GetProperties(value)  
             else:  
                 prop = defaultProps  
   
             # don't recreate new objects if they are the same as before  
             if prop != old_prop:  
                 old_prop = prop  
38    
39                  if shapetype == SHAPETYPE_ARC:      TRANSPARENT_PEN = wxTRANSPARENT_PEN
40                      fill = Color.None      TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH
                 else:  
                     fill = prop.GetFill()  
       
                 if fill is Color.None:  
                     brush = wxTRANSPARENT_BRUSH  
                 else:  
                     color = Color2wxColour(fill)  
                     brush = wxBrush(color, wxSOLID)  
       
                 stroke = prop.GetLineColor()  
                 stroke_width = prop.GetLineWidth()  
                 if stroke is Color.None:  
                     pen = wxTRANSPARENT_PEN  
                 else:  
                     color = Color2wxColour(stroke)  
                     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.  
         """  
         return range(layer.NumShapes())  
41    
42      def draw_polygon_shape(self, layer, index, pen, brush):      make_point = wxPoint
         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)  
43    
44      def projected_points(self, layer, index):      def tools_for_property(self, prop):
45          proj = self.map.projection          fill = prop.GetFill()
46          if proj is not None:          if fill is Transparent:
47              forward = proj.Forward              brush = self.TRANSPARENT_BRUSH
48          else:          else:
49              forward = None              brush = wxBrush(Color2wxColour(fill), wxSOLID)
50          proj = layer.projection  
51          if proj is not None:          stroke = prop.GetLineColor()
52              inverse = proj.Inverse          if stroke is Transparent:
53                pen = self.TRANSPARENT_PEN
54          else:          else:
55              inverse = None              pen = wxPen(Color2wxColour(stroke), prop.GetLineWidth(), wxSOLID)
56          shape = layer.Shape(index)          return pen, brush
         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)  
57    
58      def draw_label_layer(self, layer):      def low_level_renderer(self, layer):
59          scale = self.scale          """Override inherited method to provide more efficient renderers
         offx, offy = self.offset  
60    
61          font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)          If the underlying data format is not a shapefile or the layer
62          self.dc.SetFont(font)          contains points shapes, simply use what the inherited method
63            returns.
64          map_proj = self.map.projection  
65          if map_proj is not None:          Otherwise, i.e. for arc and polygon use the more efficient
66              forward = map_proj.Forward          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 296  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.468  
changed lines
  Added in v.1750
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26