/[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 6 by bh, Tue Aug 28 15:41:52 2001 UTC revision 1591 by bh, Fri Aug 15 14:00:53 2003 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001 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    from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
28         SHAPETYPE_POINT, RAW_SHAPEFILE
29    
30    from Thuban.Model.color import Transparent
31    import Thuban.Model.resource
32    
33    from baserenderer import BaseRenderer
34    
35    class MapRenderer(BaseRenderer):
36    
37      """Class to render a map onto a wxDC"""      """Class to render a map onto a wxDC"""
38    
39        TRANSPARENT_PEN = wxTRANSPARENT_PEN
40        TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH
41    
42        make_point = wxPoint
43    
44        def tools_for_property(self, prop):
45            fill = prop.GetFill()
46            if fill is Transparent:
47                brush = self.TRANSPARENT_BRUSH
48            else:
49                brush = wxBrush(Color2wxColour(fill), wxSOLID)
50    
51            stroke = prop.GetLineColor()
52            if stroke is Transparent:
53                pen = self.TRANSPARENT_PEN
54            else:
55                pen = wxPen(Color2wxColour(stroke), prop.GetLineWidth(), wxSOLID)
56            return pen, brush
57    
58        def low_level_renderer(self, layer):
59            """Override inherited method to provide more efficient renderers
60    
61            If the underlying data format is not a shapefile or the layer
62            contains points shapes, simply use what the inherited method
63            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:
78                return BaseRenderer.low_level_renderer(self, layer)
79    
80        def label_font(self):
81            return wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
82    
83        def draw_raster_data(self, data):
84            stream = cStringIO.StringIO(data)
85            image = wxImageFromStream(stream, wxBITMAP_TYPE_BMP)
86            bitmap = wxBitmapFromImage(image)
87            self.dc.DrawBitmap(bitmap, 0, 0)
88    
89    
90    class ScreenRenderer(MapRenderer):
91    
92        # On the screen we want to see only visible layers by default
93      honor_visibility = 1      honor_visibility = 1
94    
95      def __init__(self, dc, scale, offset, resolution = 72.0,      def RenderMap(self, map, region, selected_layer, selected_shapes):
96                   honor_visibility = None):          """Render the map.
97          """Inititalize the renderer.  
98            Only the given region (a tuple in window coordinates as returned
99          dc -- the wxPython DC to render on          by a wxrect's asTuple method) needs to be redrawn. Highlight the
100          scale, offset -- the scale factor and translation to convert          shapes given by the ids in selected_shapes in the
101                  between projected coordinates and the DC coordinates          selected_layer.
   
         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.  
102          """          """
103          # resolution in pixel/inch          self.update_region = region
104          self.dc = dc          self.selected_layer = selected_layer
105          self.scale = scale          self.selected_shapes = selected_shapes
106          self.offset = offset          self.render_map(map)
         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())  
107    
108      def draw_shape_layer(self, layer):      def draw_shape_layer(self, layer):
109          scale = self.scale          MapRenderer.draw_shape_layer(self, layer)
110          offx, offy = self.offset          if layer is self.selected_layer and self.selected_shapes:
111                pen = wxPen(wxBLACK, 3, wxSOLID)
112                brush = wxBrush(wxBLACK, wxCROSS_HATCH)
113    
114          fill = layer.fill              shapetype = layer.ShapeType()
115          if fill is None:              useraw, func, param = self.low_level_renderer(layer)
116              brush = wxTRANSPARENT_BRUSH              args = (pen, brush)
117          else:              for index in self.selected_shapes:
118              color = wxColour(fill.red * 255,                  shape = layer.Shape(index)
119                               fill.green * 255,                  if useraw:
120                               fill.blue * 255)                      data = shape.RawData()
121              brush = wxBrush(color, wxSOLID)                  else:
122          stroke = layer.stroke                      data = shape.Points()
123          if stroke is None:                  func(param, data, *args)
             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)  
124    
125      def projected_points(self, layer, index):      def layer_ids(self, layer):
126            """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
129            that it can use the quadtree.
130            """
131            # FIXME: the quad-tree should be built from the projected
132            # coordinates not the lat-long ones because it's not trivial to
133            # determine an appropriate rectangle in lat-long for a given
134            # rectangle in projected coordinates which we have to start from
135            # here.
136          proj = self.map.projection          proj = self.map.projection
137          if proj is not None:          if proj is not None:
             forward = proj.Forward  
         else:  
             forward = None  
         proj = layer.projection  
         if proj is not None:  
138              inverse = proj.Inverse              inverse = proj.Inverse
139          else:          else:
140              inverse = None              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)  
141    
     def draw_label_layer(self, layer):  
142          scale = self.scale          scale = self.scale
143          offx, offy = self.offset          offx, offy = self.offset
144            xs = []
145            ys = []
146            x, y, width, height = self.update_region
147            for winx, winy in ((x, y), (x + width, y),
148                               (x + width, y + height), (x, y + height)):
149                px = (winx - offx) / scale
150                py = -(winy - offy) / scale
151                if inverse:
152                    px, py = inverse(px, py)
153                xs.append(px)
154                ys.append(py)
155            left = min(xs)
156            right = max(xs)
157            top = max(ys)
158            bottom = min(ys)
159    
160          font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)          return layer.ShapesInRegion((left, bottom, right, top))
         self.dc.SetFont(font)  
161    
         map_proj = self.map.projection  
         if map_proj is not None:  
             forward = map_proj.Forward  
         else:  
             forward = None  
162    
163          for label in layer.Labels():  class ExportRenderer(ScreenRenderer):
             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)  
164    
165        honor_visibility = 1
166    
167  class ScreenRenderer(MapRenderer):      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      # On the screen we want to see only visible layers by default          self.update_region = region
     honor_visibility = 1  
       
     def RenderMap(self, map, selected_layer, selected_shape):  
181          self.selected_layer = selected_layer          self.selected_layer = selected_layer
182          self.selected_shape = selected_shape          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)          self.render_map(map)
209            self.dc.EndDrawing()
210    
211      def draw_shape_layer(self, layer):          # Draw the rest (frames, legend, scalebar)
212          MapRenderer.draw_shape_layer(self, layer)          self.dc.BeginDrawing()
213          if layer is self.selected_layer and self.selected_shape is not None:          self.dc.DestroyClippingRegion()
             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)  
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 PrinterRender(MapRenderer):  class PrinterRenderer(ExportRenderer):
313    
314      # When printing we want to see all layers      # Printing as well as Export / Screen display only the visible layer.
315      honor_visibility = 0      honor_visibility = 1
316    
     RenderMap = MapRenderer.render_map  
       
Legend:
Removed from v.6  
changed lines
  Added in v.1591
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26