/[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 2562 by jonathan, Wed Feb 16 21:14:47 2005 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001 by Intevation GmbH  # Copyright (c) 2001-2004 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]> (2001-2003)
4    # Jonathan Coles <[email protected]> (2003)
5    # Frank Koormann <[email protected]> (2003)
6    # Jan-Oliver Wagner <[email protected]> (2003, 2004)
7  #  #
8  # This program is free software under the GPL (>=v2)  # This program is free software under the GPL (>=v2)
9  # Read the file COPYING coming with Thuban for details.  # Read the file COPYING coming with Thuban for details.
10    
11    from __future__ import generators
12    
13  __version__ = "$Revision$"  __version__ = "$Revision$"
14    # $Source$
15    # $Id$
16    
17    import cStringIO
18    
19    from Thuban import _
20    
21    from wxPython.wx import wxPoint, wxRect, wxPen, wxBrush, wxFont, \
22        wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
23        wxBLACK_PEN, wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL, \
24        wxBitmapFromImage, wxImageFromStream, wxBITMAP_TYPE_BMP, \
25        wxBITMAP_TYPE_JPEG, wxBITMAP_TYPE_PNG, wxBITMAP_TYPE_TIF, \
26        wxBITMAP_TYPE_GIF, wxEmptyImage, wxMask, wxBitmapFromBits
27    
28    from wxproj import draw_polygon_shape, draw_polygon_init
29    
30    from Thuban.UI.common import Color2wxColour
31    from Thuban.UI.classifier import ClassDataPreviewer
32    from Thuban.UI.scalebar import ScaleBar
33    
34    from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
35         SHAPETYPE_POINT, RAW_SHAPEFILE
36    
37    from Thuban.Model.color import Transparent
38    import Thuban.Model.resource
39    
40  from wxPython.wx import wxPoint, wxColour, wxPen, wxBrush, wxFont, \  from baserenderer import BaseRenderer
      wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \  
      wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL  
41    
42  from wxproj import draw_polygon_shape  from math import floor
43    
44  from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \  from types import StringType
      SHAPETYPE_POINT  
 from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \  
      ALIGN_LEFT, ALIGN_RIGHT, ALIGN_BASELINE  
45    
46    from Thuban.version import versions
47    
48  class MapRenderer:  
49    # Map the strings used for the format parameter of the draw_raster_data
50    # method to the appropriate wxWindows constants
51    raster_format_map = {
52        "BMP": wxBITMAP_TYPE_BMP,
53        "JPEG": wxBITMAP_TYPE_JPEG,
54        "PNG": wxBITMAP_TYPE_PNG,
55        "TIFF": wxBITMAP_TYPE_TIF,
56        "GIF": wxBITMAP_TYPE_GIF,
57        }
58    
59    class MapRenderer(BaseRenderer):
60    
61      """Class to render a map onto a wxDC"""      """Class to render a map onto a wxDC"""
62    
63      honor_visibility = 1      TRANSPARENT_PEN = wxTRANSPARENT_PEN
64        TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH
65    
66      def __init__(self, dc, scale, offset, resolution = 72.0,      def make_point(self, x, y):
67                   honor_visibility = None):          return wxPoint(int(round(x)), int(round(y)))
         """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())  
68    
69      def draw_shape_layer(self, layer):      def tools_for_property(self, prop):
70          scale = self.scale          fill = prop.GetFill()
71          offx, offy = self.offset          if fill is Transparent:
72                brush = self.TRANSPARENT_BRUSH
73            else:
74                brush = wxBrush(Color2wxColour(fill), wxSOLID)
75    
76          fill = layer.fill          stroke = prop.GetLineColor()
77          if fill is None:          if stroke is Transparent:
78              brush = wxTRANSPARENT_BRUSH              pen = self.TRANSPARENT_PEN
79          else:          else:
80              color = wxColour(fill.red * 255,              pen = wxPen(Color2wxColour(stroke), prop.GetLineWidth(), wxSOLID)
81                               fill.green * 255,          return pen, brush
82                               fill.blue * 255)  
83              brush = wxBrush(color, wxSOLID)      def low_level_renderer(self, layer):
84          stroke = layer.stroke          """Override inherited method to provide more efficient renderers
85          if stroke is None:  
86              pen = wxTRANSPARENT_PEN          If the underlying data format is not a shapefile or the layer
87            contains points shapes, simply use what the inherited method
88            returns.
89    
90            Otherwise, i.e. for arc and polygon use the more efficient
91            wxproj.draw_polygon_shape and its corresponding parameter
92            created with wxproj.draw_polygon_init.
93            """
94            if (layer.ShapeStore().RawShapeFormat() == RAW_SHAPEFILE
95                and layer.ShapeType() in (SHAPETYPE_ARC, SHAPETYPE_POLYGON)):
96                offx, offy = self.offset
97                x = lambda a, b, c, d: None
98                #return (True, x, None)
99                return (True, draw_polygon_shape,
100                        draw_polygon_init(layer.ShapeStore().Shapefile(),
101                                          self.dc, self.map.projection,
102                                          layer.projection,
103                                          self.scale, -self.scale, offx, offy))
104            else:
105                return BaseRenderer.low_level_renderer(self, layer)
106    
107        def label_font(self):
108            return wxFont(int(round(self.resolution * 10)), wxSWISS, wxNORMAL,
109                          wxNORMAL)
110    
111        def draw_raster_data(self, x,y, data, format = 'BMP'):
112    
113            mask = None
114            width = data[0]
115            height = data[1]
116            image_data, mask_data, alpha_data = data[2]
117    
118            if versions['wxPython-tuple'] < (2,5,3):
119                alpha_data = None
120    
121            if format == 'RAW':
122                image = wxEmptyImage(width, height)
123                image.SetData(image_data)
124                if mask_data is not None:
125                    mask = wxBitmapFromBits(mask_data, width, height, 1)
126                    mask = wxMask(mask)
127                elif alpha_data is not None:
128                    image.SetAlphaData(alpha_data)
129          else:          else:
130              color = wxColour(stroke.red * 255,              stream = cStringIO.StringIO(image_data)
131                               stroke.green * 255,              image = wxImageFromStream(stream, raster_format_map[format])
132                               stroke.blue * 255)              if mask_data is not None:
133              pen = wxPen(color, 1, wxSOLID)                  stream = cStringIO.StringIO(mask_data)
134                    mask = wxImageFromStream(stream, raster_format_map[format])
135                    mask = wxMask(wxBitmapFromImage(mask, 1))
136                elif alpha_data is not None:
137                    stream = cStringIO.StringIO(alpha_data)
138                    alpha = wxImageFromStream(stream, raster_format_map[format])
139                    image.SetAlpha(alpha.GetData()[:])
140    
141            bitmap = wxBitmapFromImage(image)
142            bitmap.SetMask(mask)
143    
144            self.dc.DrawBitmap(bitmap, int(round(x)), int(round(y)), True)
145    
146    
147    class ScreenRenderer(MapRenderer):
148    
149        # On the screen we want to see only visible layers by default
150        honor_visibility = 1
151    
152        def RenderMap(self, selected_layer, selected_shapes):
153            """Render the map.
154    
155            Only the given region (a tuple in window coordinates as returned
156            by a wxrect's asTuple method) needs to be redrawn. Highlight the
157            shapes given by the ids in selected_shapes in the
158            selected_layer.
159            """
160            self.selected_layer = selected_layer
161            self.selected_shapes = selected_shapes
162            self.render_map()
163    
164          map_proj = self.map.projection      def RenderMapIncrementally(self):
165          layer_proj = layer.projection          """Render the map.
166    
167            Only the given region (a tuple in window coordinates as returned
168            by a wxrect's asTuple method) needs to be redrawn. Highlight the
169            shapes given by the ids in selected_shapes in the
170            selected_layer.
171            """
172            return self.render_map_incrementally()
173    
174        def draw_selection_incrementally(self, layer, selected_shapes):
175            """Draw the selected shapes in a emphasized way (i.e.
176            with a special pen and brush.
177            The drawing is performed incrementally, that means every
178            n shapes, the user can have interactions with the map.
179            n is currently fixed to 500.
180    
181            layer -- the layer where the shapes belong to.
182            selected_shapes -- a list of the shape-ids representing the
183                               selected shapes for the given layer.
184            """
185            pen = wxPen(wxBLACK, 3, wxSOLID)
186            brush = wxBrush(wxBLACK, wxCROSS_HATCH)
187    
188          shapetype = layer.ShapeType()          shapetype = layer.ShapeType()
189            useraw, func, param = self.low_level_renderer(layer)
190            args = (pen, brush)
191    
192          if shapetype == SHAPETYPE_POLYGON:          # for point shapes we need to find out the properties
193              for i in range(layer.NumShapes()):          # to determine the size. Based on table and field,
194                  self.draw_polygon_shape(layer, i, pen, brush)          # we can find out the properties for object - see below.
195          else:          if shapetype == SHAPETYPE_POINT:
196              self.dc.SetBrush(brush)              lc = layer.GetClassification()
197              self.dc.SetPen(pen)              field = layer.GetClassificationColumn()
198              if shapetype == SHAPETYPE_ARC:              table = layer.ShapeStore().Table()
199                  f = self.draw_arc_shape  
200              elif shapetype == SHAPETYPE_POINT:          count = 0
201                  f = self.draw_point_shape          for index in selected_shapes:
202              for i in range(layer.NumShapes()):              count += 1
203                  f(layer, i)              shape = layer.Shape(index)
204    
205      def draw_polygon_shape(self, layer, index, pen, brush):              # Get the size of the specific property for this
206          offx, offy = self.offset                      # point
207          draw_polygon_shape(layer.shapefile.cobject(), index,              if shapetype == SHAPETYPE_POINT and field is not None:
208                             self.dc, pen, brush,                  value = table.ReadValue(shape.ShapeID(), field)
209                             self.map.projection, layer.projection,                  group = lc.FindGroup(value)
210                             self.scale, -self.scale, offx, offy)                  size = group.GetProperties().GetSize()
211                    args = (pen, brush, size)
212    
213                if useraw:
214                    data = shape.RawData()
215                else:
216                    data = shape.Points()
217                func(param, data, *args)
218                if count % 500 == 0:
219                    yield True
220    
221        def layer_shapes(self, layer):
222            """Return the shapeids covered by the region that has to be redrawn
223    
224      def projected_points(self, layer, index):          Call the layer's ShapesInRegion method to determine the ids so
225            that it can use the quadtree.
226            """
227            # FIXME: the quad-tree should be built from the projected
228            # coordinates not the lat-long ones because it's not trivial to
229            # determine an appropriate rectangle in lat-long for a given
230            # rectangle in projected coordinates which we have to start from
231            # here.
232          proj = self.map.projection          proj = self.map.projection
233          if proj is not None:          if proj is not None:
             forward = proj.Forward  
         else:  
             forward = None  
         proj = layer.projection  
         if proj is not None:  
234              inverse = proj.Inverse              inverse = proj.Inverse
235          else:          else:
236              inverse = None              inverse = None
237          shape = layer.Shape(index)  
         points = []  
238          scale = self.scale          scale = self.scale
239          offx, offy = self.offset          offx, offy = self.offset
240          for x, y in shape.Points():          xs = []
241            ys = []
242            x, y, width, height = self.region
243            for winx, winy in ((x, y), (x + width, y),
244                               (x + width, y + height), (x, y + height)):
245                px = (winx - offx) / scale
246                py = -(winy - offy) / scale
247              if inverse:              if inverse:
248                  x, y = inverse(x, y)                  px, py = inverse(px, py)
249              if forward:              xs.append(px)
250                  x, y = forward(x, y)              ys.append(py)
251              points.append(wxPoint(x * scale + offx,          left = min(xs)
252                                    -y * scale + offy))          right = max(xs)
253          return points          top = max(ys)
254            bottom = min(ys)
     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)  
255    
256      def draw_label_layer(self, layer):          return layer.ShapesInRegion((left, bottom, right, top))
         scale = self.scale  
         offx, offy = self.offset  
257    
         font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)  
         self.dc.SetFont(font)  
258    
259          map_proj = self.map.projection  class ExportRenderer(ScreenRenderer):
         if map_proj is not None:  
             forward = map_proj.Forward  
         else:  
             forward = None  
260    
261          for label in layer.Labels():      honor_visibility = 1
             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)  
262    
263        def __init__(self, *args, **kw):
264            """Initialize the ExportRenderer.
265    
266  class ScreenRenderer(MapRenderer):          In addition to all parameters of the the ScreenRender
267            constructor, this class requires and additional keyword argument
268            destination_region with a tuple (minx, miny, maxx, maxy) giving
269            the region in dc coordinates which is to contain the map.
270            """
271            self.destination_region = kw["destination_region"]
272            del kw["destination_region"]
273            ScreenRenderer.__init__(self, *args, **kw)
274    
275        def RenderMap(self, selected_layer, selected_shapes):
276            """Render the map.
277    
278            The rendering device has been specified during initialisation.
279            The device border distance was set in
280            Thuban.UI.viewport.output_transform().
281    
282            RenderMap renders a frame set (one page frame, one around
283            legend/scalebar and one around the map), the map, the legend and
284            the scalebar on the given DC. The map is rendered with the
285            region displayed in the canvas view, centered on the area
286            available for map display.
287            """
288    
     # On the screen we want to see only visible layers by default  
     honor_visibility = 1  
       
     def RenderMap(self, map, selected_layer, selected_shape):  
289          self.selected_layer = selected_layer          self.selected_layer = selected_layer
290          self.selected_shape = selected_shape          self.selected_shapes = selected_shapes
         self.render_map(map)  
291    
292      def draw_shape_layer(self, layer):          # Get some dimensions
293          MapRenderer.draw_shape_layer(self, layer)          llx, lly, urx, ury = self.region
294          if layer is self.selected_layer and self.selected_shape is not None:          mminx, mminy, mmaxx, mmaxy = self.destination_region
             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)  
295    
296            # Manipulate the offset to position the map
297            offx, offy = self.offset
298            # 1. Shift to corner of map drawing area
299            offx = offx + mminx
300            offy = offy + mminy
301    
302            # 2. Center the map on the map drawing area:
303            # region identifies the region on the canvas view:
304            # center of map drawing area - half the size of region: rendering origin
305            self.shiftx = (mmaxx - mminx)*0.5 - (urx - llx)*0.5
306            self.shifty = (mmaxy - mminy)*0.5 - (ury - lly)*0.5
307    
308            self.offset = (offx+self.shiftx, offy+self.shifty)
309            self.region = (llx + self.shiftx, lly + self.shifty, urx, ury)
310    
311            # Draw the map
312            self.dc.BeginDrawing()
313            self.dc.DestroyClippingRegion()
314            self.dc.SetClippingRegion(mminx+self.shiftx, mminy+self.shifty,
315                                      urx, ury)
316            self.render_map()
317            self.dc.EndDrawing()
318    
319            # Draw the rest (frames, legend, scalebar)
320            self.dc.BeginDrawing()
321            self.dc.DestroyClippingRegion()
322    
323  class PrinterRender(MapRenderer):          # Force the font for Legend drawing
324            font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
325            self.dc.SetFont(font)
326    
327      # When printing we want to see all layers          self.render_frame()
328      honor_visibility = 0          self.render_legend()
329            self.render_scalebar()
330            self.dc.EndDrawing()
331    
332        def render_frame(self):
333            """Render the frames for map and legend/scalebar."""
334    
335            dc = self.dc
336            dc.SetPen(wxBLACK_PEN)
337            dc.SetBrush(wxTRANSPARENT_BRUSH)
338    
339            # Dimension stuff
340            width, height = dc.GetSizeTuple()
341            mminx, mminy, mmaxx, mmaxy = self.destination_region
342    
343            # Page Frame
344            dc.DrawRectangle(15,15,width-30, (mmaxy-mminy)+10)
345    
346            # Map Frame
347            llx, lly, urx, ury = self.region
348            dc.DrawRectangle(mminx + self.shiftx, mminy + self.shifty, urx, ury)
349    
350            # Legend Frame
351            dc.DrawRectangle(mmaxx+10,mminy,(width-20) - (mmaxx+10), mmaxy-mminy)
352    
353            dc.DestroyClippingRegion()
354            dc.SetClippingRegion(mmaxx+10,mminy,
355                                 (width-20) - (mmaxx+10), mmaxy-mminy)
356    
357        def render_legend(self):
358            """Render the legend on the Map."""
359    
360            previewer = ClassDataPreviewer()
361            dc = self.dc
362            dc.SetPen(wxBLACK_PEN)
363            dc.SetBrush(wxTRANSPARENT_BRUSH)
364    
365            # Dimension stuff
366            width, height = dc.GetSizeTuple()
367            mminx, mminy, mmaxx, mmaxy = self.destination_region
368            textwidth, textheight = dc.GetTextExtent("0")
369            iconwidth  = textheight
370            iconheight = textheight
371            stepy = textheight+3
372            dx = 10
373            posx = mmaxx + 10 + 5   # 10 pix distance mapframe/legend frame,
374                                    # 5 pix inside legend frame
375            posy = mminy + 5        # 5 pix inside legend frame
376    
377            # Render the legend
378            dc.SetTextForeground(wxBLACK)
379            if self.map.HasLayers():
380                layers = self.map.Layers()[:]
381                layers.reverse()
382                for l in layers:
383                    if l.Visible():
384                        # Render title
385                        dc.DrawText(l.Title(), posx, posy)
386                        posy+=stepy
387                        if l.HasClassification():
388                            # Render classification
389                            clazz = l.GetClassification()
390                            shapeType = l.ShapeType()
391                            for g in clazz:
392                                if g.IsVisible():
393                                    previewer.Draw(dc,
394                                        wxRect(posx+dx, posy,
395                                               iconwidth, iconheight),
396                                        g.GetProperties(), shapeType)
397                                    dc.DrawText(g.GetDisplayText(),
398                                                posx+2*dx+iconwidth, posy)
399                                    posy+=stepy
400    
401        def render_scalebar(self):
402            """Render the scalebar."""
403    
404            scalebar = ScaleBar(self.map)
405    
406            # Dimension stuff
407            width, height = self.dc.GetSizeTuple()
408            mminx, mminy, mmaxx, mmaxy = self.destination_region
409    
410            # Render the scalebar
411            scalebar.DrawScaleBar(self.scale, self.dc,
412                                 (mmaxx+10+5, mmaxy-25),
413                                 ((width-15-5) - (mmaxx+10+5),20)
414                                )
415            # 10 pix between map and legend frame, 5 pix inside legend frame
416            # 25 pix from the legend frame bottom line
417            # Width: 15 pix from DC border, 5 pix inside frame, 10, 5 as above
418            # Height: 20
419    
420    class PrinterRenderer(ExportRenderer):
421    
422        # Printing as well as Export / Screen display only the visible layer.
423        honor_visibility = 1
424    
     RenderMap = MapRenderer.render_map  
       
Legend:
Removed from v.6  
changed lines
  Added in v.2562
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26