/[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 1591 by bh, Fri Aug 15 14:00:53 2003 UTC revision 2551 by jonathan, Thu Jan 27 14:19:41 2005 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001, 2002, 2003 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]>  # Jonathan Coles <[email protected]> (2003)
5  # Frank Koormann <[email protected]>  # 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  import cStringIO
18    
# Line 16  from Thuban import _ Line 21  from Thuban import _
21  from wxPython.wx import wxPoint, wxRect, wxPen, wxBrush, wxFont, \  from wxPython.wx import wxPoint, wxRect, wxPen, wxBrush, wxFont, \
22      wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \      wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
23      wxBLACK_PEN, wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL, \      wxBLACK_PEN, wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL, \
24      wxBitmapFromImage, wxImageFromStream, wxBITMAP_TYPE_BMP      wxBitmapFromImage, wxImageFromStream, wxBITMAP_TYPE_BMP, \
25        wxBITMAP_TYPE_JPEG, wxBITMAP_TYPE_PNG, wxBITMAP_TYPE_TIF, \
26        wxBITMAP_TYPE_GIF, wxEmptyImage, wxMask
27    
28  from wxproj import draw_polygon_shape, draw_polygon_init  from wxproj import draw_polygon_shape, draw_polygon_init
29    
# Line 32  import Thuban.Model.resource Line 39  import Thuban.Model.resource
39    
40  from baserenderer import BaseRenderer  from baserenderer import BaseRenderer
41    
42    from math import floor
43    
44    from types import StringType
45    
46    
47    # Map the strings used for the format parameter of the draw_raster_data
48    # method to the appropriate wxWindows constants
49    raster_format_map = {
50        "BMP": wxBITMAP_TYPE_BMP,
51        "JPEG": wxBITMAP_TYPE_JPEG,
52        "PNG": wxBITMAP_TYPE_PNG,
53        "TIFF": wxBITMAP_TYPE_TIF,
54        "GIF": wxBITMAP_TYPE_GIF,
55        }
56    
57  class MapRenderer(BaseRenderer):  class MapRenderer(BaseRenderer):
58    
59      """Class to render a map onto a wxDC"""      """Class to render a map onto a wxDC"""
# Line 39  class MapRenderer(BaseRenderer): Line 61  class MapRenderer(BaseRenderer):
61      TRANSPARENT_PEN = wxTRANSPARENT_PEN      TRANSPARENT_PEN = wxTRANSPARENT_PEN
62      TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH      TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH
63    
64      make_point = wxPoint      def make_point(self, x, y):
65            return wxPoint(int(round(x)), int(round(y)))
66    
67      def tools_for_property(self, prop):      def tools_for_property(self, prop):
68          fill = prop.GetFill()          fill = prop.GetFill()
# Line 78  class MapRenderer(BaseRenderer): Line 101  class MapRenderer(BaseRenderer):
101              return BaseRenderer.low_level_renderer(self, layer)              return BaseRenderer.low_level_renderer(self, layer)
102    
103      def label_font(self):      def label_font(self):
104          return wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)          return wxFont(int(round(self.resolution * 10)), wxSWISS, wxNORMAL,
105                          wxNORMAL)
106    
107        def draw_raster_data(self, x,y, data, format = 'BMP'):
108    
109            mask = None
110            if format == 'RAW':
111                image = wxEmptyImage(data[0], data[1])
112                image.SetData(data[2][0])
113                if data[2][1] is not None:
114                    mask = wxEmptyImage(data[0], data[1])
115                    mask.SetData(data[2][1])
116            else:
117                stream = cStringIO.StringIO(data[2][0])
118                image = wxImageFromStream(stream, raster_format_map[format])
119                if data[2][1] is not None:
120                    stream = cStringIO.StringIO(data[2][1])
121                    mask = wxImageFromStream(stream, raster_format_map[format])
122    
     def draw_raster_data(self, data):  
         stream = cStringIO.StringIO(data)  
         image = wxImageFromStream(stream, wxBITMAP_TYPE_BMP)  
123          bitmap = wxBitmapFromImage(image)          bitmap = wxBitmapFromImage(image)
124          self.dc.DrawBitmap(bitmap, 0, 0)  
125            if mask is None:
126                self.dc.DrawBitmap(bitmap, int(round(x)), int(round(y)), False)
127            else:
128                # if we are given a mask object, try to pass it to SetMaskColour,
129                # otherwise assume it's a mask image
130                try:
131                    bitmap.SetMask(wxMask(wxBitmapFromImage(mask, 1)))
132                    self.dc.DrawBitmap(bitmap, int(round(x)), int(round(y)), True)
133                except (TypeError):
134                    # implement using a mask image
135                    raise NotImplementedError
136    
137    
138  class ScreenRenderer(MapRenderer):  class ScreenRenderer(MapRenderer):
# Line 92  class ScreenRenderer(MapRenderer): Line 140  class ScreenRenderer(MapRenderer):
140      # On the screen we want to see only visible layers by default      # On the screen we want to see only visible layers by default
141      honor_visibility = 1      honor_visibility = 1
142    
143      def RenderMap(self, map, region, selected_layer, selected_shapes):      def RenderMap(self, selected_layer, selected_shapes):
144          """Render the map.          """Render the map.
145    
146          Only the given region (a tuple in window coordinates as returned          Only the given region (a tuple in window coordinates as returned
# Line 100  class ScreenRenderer(MapRenderer): Line 148  class ScreenRenderer(MapRenderer):
148          shapes given by the ids in selected_shapes in the          shapes given by the ids in selected_shapes in the
149          selected_layer.          selected_layer.
150          """          """
         self.update_region = region  
151          self.selected_layer = selected_layer          self.selected_layer = selected_layer
152          self.selected_shapes = selected_shapes          self.selected_shapes = selected_shapes
153          self.render_map(map)          self.render_map()
154    
155      def draw_shape_layer(self, layer):      def RenderMapIncrementally(self):
156          MapRenderer.draw_shape_layer(self, layer)          """Render the map.
         if layer is self.selected_layer and self.selected_shapes:  
             pen = wxPen(wxBLACK, 3, wxSOLID)  
             brush = wxBrush(wxBLACK, wxCROSS_HATCH)  
   
             shapetype = layer.ShapeType()  
             useraw, func, param = self.low_level_renderer(layer)  
             args = (pen, brush)  
             for index in self.selected_shapes:  
                 shape = layer.Shape(index)  
                 if useraw:  
                     data = shape.RawData()  
                 else:  
                     data = shape.Points()  
                 func(param, data, *args)  
157    
158      def layer_ids(self, layer):          Only the given region (a tuple in window coordinates as returned
159            by a wxrect's asTuple method) needs to be redrawn. Highlight the
160            shapes given by the ids in selected_shapes in the
161            selected_layer.
162            """
163            return self.render_map_incrementally()
164    
165        def draw_selection_incrementally(self, layer, selected_shapes):
166            """Draw the selected shapes in a emphasized way (i.e.
167            with a special pen and brush.
168            The drawing is performed incrementally, that means every
169            n shapes, the user can have interactions with the map.
170            n is currently fixed to 500.
171    
172            layer -- the layer where the shapes belong to.
173            selected_shapes -- a list of the shape-ids representing the
174                               selected shapes for the given layer.
175            """
176            pen = wxPen(wxBLACK, 3, wxSOLID)
177            brush = wxBrush(wxBLACK, wxCROSS_HATCH)
178    
179            shapetype = layer.ShapeType()
180            useraw, func, param = self.low_level_renderer(layer)
181            args = (pen, brush)
182    
183            # for point shapes we need to find out the properties
184            # to determine the size. Based on table and field,
185            # we can find out the properties for object - see below.
186            if shapetype == SHAPETYPE_POINT:
187                lc = layer.GetClassification()
188                field = layer.GetClassificationColumn()
189                table = layer.ShapeStore().Table()
190    
191            count = 0
192            for index in selected_shapes:
193                count += 1
194                shape = layer.Shape(index)
195    
196                # Get the size of the specific property for this
197                # point
198                if shapetype == SHAPETYPE_POINT and field is not None:
199                    value = table.ReadValue(shape.ShapeID(), field)
200                    group = lc.FindGroup(value)
201                    size = group.GetProperties().GetSize()
202                    args = (pen, brush, size)
203    
204                if useraw:
205                    data = shape.RawData()
206                else:
207                    data = shape.Points()
208                func(param, data, *args)
209                if count % 500 == 0:
210                    yield True
211    
212        def layer_shapes(self, layer):
213          """Return the shapeids covered by the region that has to be redrawn          """Return the shapeids covered by the region that has to be redrawn
214    
215          Call the layer's ShapesInRegion method to determine the ids so          Call the layer's ShapesInRegion method to determine the ids so
# Line 143  class ScreenRenderer(MapRenderer): Line 230  class ScreenRenderer(MapRenderer):
230          offx, offy = self.offset          offx, offy = self.offset
231          xs = []          xs = []
232          ys = []          ys = []
233          x, y, width, height = self.update_region          x, y, width, height = self.region
234          for winx, winy in ((x, y), (x + width, y),          for winx, winy in ((x, y), (x + width, y),
235                             (x + width, y + height), (x, y + height)):                             (x + width, y + height), (x, y + height)):
236              px = (winx - offx) / scale              px = (winx - offx) / scale
# Line 164  class ExportRenderer(ScreenRenderer): Line 251  class ExportRenderer(ScreenRenderer):
251    
252      honor_visibility = 1      honor_visibility = 1
253    
254      def RenderMap(self, map, region, mapregion,      def __init__(self, *args, **kw):
255                    selected_layer, selected_shapes ):          """Initialize the ExportRenderer.
256    
257            In addition to all parameters of the the ScreenRender
258            constructor, this class requires and additional keyword argument
259            destination_region with a tuple (minx, miny, maxx, maxy) giving
260            the region in dc coordinates which is to contain the map.
261            """
262            self.destination_region = kw["destination_region"]
263            del kw["destination_region"]
264            ScreenRenderer.__init__(self, *args, **kw)
265    
266        def RenderMap(self, selected_layer, selected_shapes):
267          """Render the map.          """Render the map.
268    
269          The rendering device has been specified during initialisation.          The rendering device has been specified during initialisation.
270          The device border distance was set in Thuban.UI.view.OutputTranform().          The device border distance was set in
271            Thuban.UI.viewport.output_transform().
272    
273          RenderMap renders a frame set (one page frame, one around          RenderMap renders a frame set (one page frame, one around
274          legend/scalebar and one around the map), the map, the legend and the          legend/scalebar and one around the map), the map, the legend and
275          scalebar on the given DC. The map is rendered with the region displayed          the scalebar on the given DC. The map is rendered with the
276          in the canvas view, centered on the area available for map display.          region displayed in the canvas view, centered on the area
277            available for map display.
278          """          """
279    
         self.update_region = region  
280          self.selected_layer = selected_layer          self.selected_layer = selected_layer
281          self.selected_shapes = selected_shapes          self.selected_shapes = selected_shapes
282    
283          # Get some dimensions          # Get some dimensions
284          llx, lly, urx, ury = region          llx, lly, urx, ury = self.region
285          self.mapregion = mapregion          mminx, mminy, mmaxx, mmaxy = self.destination_region
         mminx, mminy, mmaxx, mmaxy = self.mapregion  
286    
287          # Manipulate the offset to position the map          # Manipulate the offset to position the map
288          offx, offy = self.offset          offx, offy = self.offset
# Line 199  class ExportRenderer(ScreenRenderer): Line 297  class ExportRenderer(ScreenRenderer):
297          self.shifty = (mmaxy - mminy)*0.5 - (ury - lly)*0.5          self.shifty = (mmaxy - mminy)*0.5 - (ury - lly)*0.5
298    
299          self.offset = (offx+self.shiftx, offy+self.shifty)          self.offset = (offx+self.shiftx, offy+self.shifty)
300            self.region = (llx + self.shiftx, lly + self.shifty, urx, ury)
301    
302          # Draw the map          # Draw the map
303          self.dc.BeginDrawing()          self.dc.BeginDrawing()
304          self.dc.DestroyClippingRegion()          self.dc.DestroyClippingRegion()
305          self.dc.SetClippingRegion(mminx+self.shiftx, mminy+self.shifty,          self.dc.SetClippingRegion(mminx+self.shiftx, mminy+self.shifty,
306                                    urx, ury)                                    urx, ury)
307          self.render_map(map)          self.render_map()
308          self.dc.EndDrawing()          self.dc.EndDrawing()
309    
310          # Draw the rest (frames, legend, scalebar)          # Draw the rest (frames, legend, scalebar)
# Line 216  class ExportRenderer(ScreenRenderer): Line 315  class ExportRenderer(ScreenRenderer):
315          font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)          font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
316          self.dc.SetFont(font)          self.dc.SetFont(font)
317    
318          self.render_frame(region)          self.render_frame()
319          self.render_legend(map)          self.render_legend()
320          self.render_scalebar(map)          self.render_scalebar()
321          self.dc.EndDrawing()          self.dc.EndDrawing()
322    
323      def render_frame(self, region):      def render_frame(self):
324          """Render the frames for map and legend/scalebar."""          """Render the frames for map and legend/scalebar."""
325    
326          dc = self.dc          dc = self.dc
# Line 230  class ExportRenderer(ScreenRenderer): Line 329  class ExportRenderer(ScreenRenderer):
329    
330          # Dimension stuff          # Dimension stuff
331          width, height = dc.GetSizeTuple()          width, height = dc.GetSizeTuple()
332          mminx, mminy, mmaxx, mmaxy = self.mapregion          mminx, mminy, mmaxx, mmaxy = self.destination_region
333    
334          # Page Frame          # Page Frame
335          dc.DrawRectangle(15,15,width-30, (mmaxy-mminy)+10)          dc.DrawRectangle(15,15,width-30, (mmaxy-mminy)+10)
336    
337          # Map Frame          # Map Frame
338          llx, lly, urx, ury = region          llx, lly, urx, ury = self.region
339          dc.DrawRectangle(mminx + self.shiftx, mminy + self.shifty, urx, ury)          dc.DrawRectangle(mminx + self.shiftx, mminy + self.shifty, urx, ury)
340    
341          # Legend Frame          # Legend Frame
# Line 246  class ExportRenderer(ScreenRenderer): Line 345  class ExportRenderer(ScreenRenderer):
345          dc.SetClippingRegion(mmaxx+10,mminy,          dc.SetClippingRegion(mmaxx+10,mminy,
346                               (width-20) - (mmaxx+10), mmaxy-mminy)                               (width-20) - (mmaxx+10), mmaxy-mminy)
347    
348      def render_legend(self, map):      def render_legend(self):
349          """Render the legend on the Map."""          """Render the legend on the Map."""
350    
351          previewer = ClassDataPreviewer()          previewer = ClassDataPreviewer()
# Line 256  class ExportRenderer(ScreenRenderer): Line 355  class ExportRenderer(ScreenRenderer):
355    
356          # Dimension stuff          # Dimension stuff
357          width, height = dc.GetSizeTuple()          width, height = dc.GetSizeTuple()
358          mminx, mminy, mmaxx, mmaxy = self.mapregion          mminx, mminy, mmaxx, mmaxy = self.destination_region
359          textwidth, textheight = dc.GetTextExtent("0")          textwidth, textheight = dc.GetTextExtent("0")
360          iconwidth  = textheight          iconwidth  = textheight
361          iconheight = textheight          iconheight = textheight
# Line 268  class ExportRenderer(ScreenRenderer): Line 367  class ExportRenderer(ScreenRenderer):
367    
368          # Render the legend          # Render the legend
369          dc.SetTextForeground(wxBLACK)          dc.SetTextForeground(wxBLACK)
370          if map.HasLayers():          if self.map.HasLayers():
371              layers = map.Layers()              layers = self.map.Layers()[:]
372              layers.reverse()              layers.reverse()
373              for l in layers:              for l in layers:
374                  if l.Visible():                  if l.Visible():
# Line 290  class ExportRenderer(ScreenRenderer): Line 389  class ExportRenderer(ScreenRenderer):
389                                              posx+2*dx+iconwidth, posy)                                              posx+2*dx+iconwidth, posy)
390                                  posy+=stepy                                  posy+=stepy
391    
392      def render_scalebar(self, map):      def render_scalebar(self):
393          """Render the scalebar."""          """Render the scalebar."""
394    
395          scalebar = ScaleBar(map)          scalebar = ScaleBar(self.map)
396    
397          # Dimension stuff          # Dimension stuff
398          width, height = self.dc.GetSizeTuple()          width, height = self.dc.GetSizeTuple()
399          mminx, mminy, mmaxx, mmaxy = self.mapregion          mminx, mminy, mmaxx, mmaxy = self.destination_region
400    
401          # Render the scalebar          # Render the scalebar
402          scalebar.DrawScaleBar(self.scale, self.dc,          scalebar.DrawScaleBar(self.scale, self.dc,
Legend:
Removed from v.1591  
changed lines
  Added in v.2551
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26