/[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 798 by jonathan, Wed Apr 30 17:02:04 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  #  #
6  # This program is free software under the GPL (>=v2)  # This program is free software under the GPL (>=v2)
7  # Read the file COPYING coming with Thuban for details.  # Read the file COPYING coming with Thuban for details.
8    
9  __version__ = "$Revision$"  __version__ = "$Revision$"
10    
11  from wxPython.wx import wxPoint, wxColour, wxPen, wxBrush, wxFont, \  from wxPython.wx import wxPoint, wxPen, wxBrush, wxFont, \
12       wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \       wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
13       wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL       wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL
14    
15  from wxproj import draw_polygon_shape  from wxproj import draw_polygon_shape, draw_polygon_init
16    
17    from Thuban import _
18    from Thuban.UI.common import *
19    
20  from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \  from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
21       SHAPETYPE_POINT       SHAPETYPE_POINT
22  from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \  from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
23       ALIGN_LEFT, ALIGN_RIGHT, ALIGN_BASELINE       ALIGN_LEFT, ALIGN_RIGHT, ALIGN_BASELINE
24    
25    from Thuban.Model.classification import Classification
26    from Thuban.Model.color import Color
27    
28  class MapRenderer:  class MapRenderer:
29    
# Line 41  class MapRenderer: Line 47  class MapRenderer:
47                  the renderer's default.                  the renderer's default.
48          """          """
49          # resolution in pixel/inch          # resolution in pixel/inch
50    
51          self.dc = dc          self.dc = dc
52          self.scale = scale          self.scale = scale
53          self.offset = offset          self.offset = offset
# Line 63  class MapRenderer: Line 70  class MapRenderer:
70          scale = self.scale          scale = self.scale
71          offx, offy = self.offset          offx, offy = self.offset
72    
         fill = layer.fill  
         if fill is None:  
             brush = wxTRANSPARENT_BRUSH  
         else:  
             color = wxColour(fill.red * 255,  
                              fill.green * 255,  
                              fill.blue * 255)  
             brush = wxBrush(color, wxSOLID)  
         stroke = layer.stroke  
         if stroke is None:  
             pen = wxTRANSPARENT_PEN  
         else:  
             color = wxColour(stroke.red * 255,  
                              stroke.green * 255,  
                              stroke.blue * 255)  
             pen = wxPen(color, 1, wxSOLID)  
   
73          map_proj = self.map.projection          map_proj = self.map.projection
74          layer_proj = layer.projection          layer_proj = layer.projection
75    
76          shapetype = layer.ShapeType()          shapetype = layer.ShapeType()
77    
78          if shapetype == SHAPETYPE_POLYGON:          brush = wxTRANSPARENT_BRUSH
79              for i in range(layer.NumShapes()):          pen   = wxTRANSPARENT_PEN
80                  self.draw_polygon_shape(layer, i, pen, brush)  
81            old_prop = None
82            old_group = None
83            lc = layer.GetClassification()
84            field = lc.GetField()
85            defaultGroup = lc.GetDefaultGroup()
86    
87    
88            if shapetype != SHAPETYPE_POINT:
89                polygon_render_param = self.polygon_render_param(layer)
90    
91            if shapetype == SHAPETYPE_POINT:
92                draw_func = lambda i: \
93                       self.draw_point_shape(layer, i)
94          else:          else:
95              self.dc.SetBrush(brush)              draw_func = lambda i: \
96              self.dc.SetPen(pen)                     self.draw_polygon_shape(polygon_render_param, i, pen, brush)
97              if shapetype == SHAPETYPE_ARC:              
98                  f = self.draw_arc_shape          for i in self.layer_ids(layer):
99              elif shapetype == SHAPETYPE_POINT:  
100                  f = self.draw_point_shape              if field is None:
101              for i in range(layer.NumShapes()):                  group = defaultGroup
102                  f(layer, i)              else:
103                    record = layer.table.read_record(i)
104      def draw_polygon_shape(self, layer, index, pen, brush):                  assert record is not None
105          offx, offy = self.offset                          group = lc.FindGroup(record[field])
106          draw_polygon_shape(layer.shapefile.cobject(), index,  
107                             self.dc, pen, brush,  
108                             self.map.projection, layer.projection,              if not group.IsVisible():
109                             self.scale, -self.scale, offx, offy)                  continue
110    
111    
112                # don't recreate new objects if they are the same as before
113                if group is not old_group:
114                    old_group = group
115    
116                    prop = group.GetProperties()
117    
118                    if prop != old_prop:
119                        old_prop = prop
120    
121                        if shapetype == SHAPETYPE_ARC:
122                            fill = Color.Transparent
123                        else:
124                            fill = prop.GetFill()
125    
126    
127                        if fill is Color.Transparent:
128                            brush = wxTRANSPARENT_BRUSH
129                        else:
130                            color = Color2wxColour(fill)
131                            brush = wxBrush(color, wxSOLID)
132    
133                        stroke = prop.GetLineColor()
134                        stroke_width = prop.GetLineWidth()
135                        if stroke is Color.Transparent:
136                            pen = wxTRANSPARENT_PEN
137                        else:
138                            color = Color2wxColour(stroke)
139                            pen = wxPen(color, stroke_width, wxSOLID)
140    
141                        if shapetype == SHAPETYPE_POINT:
142                            self.dc.SetBrush(brush)
143                            self.dc.SetPen(pen)
144    
145                draw_func(i)
146    
147        def layer_ids(self, layer):
148            """Return the shape ids of the given layer that have to be drawn.
149    
150            The default implementation simply returns all ids in the layer.
151            Override in derived classes to be more precise.
152            """
153            return range(layer.NumShapes())
154    
155        def polygon_render_param(self, layer):
156            """Return the low-lever render parameter for the layer"""
157            offx, offy = self.offset
158            return draw_polygon_init(layer.shapefile, self.dc,
159                                     self.map.projection,
160                                     layer.projection,
161                                     self.scale, -self.scale,
162                                     offx, offy)
163    
164        def draw_polygon_shape(self, draw_polygon_info, index, pen, brush):
165            draw_polygon_shape(draw_polygon_info, index, pen, brush)
166    
167      def projected_points(self, layer, index):      def projected_points(self, layer, index):
168          proj = self.map.projection          proj = self.map.GetProjection()
169          if proj is not None:          if proj is not None:
170              forward = proj.Forward              forward = proj.Forward
171          else:          else:
172              forward = None              forward = None
173          proj = layer.projection          proj = layer.GetProjection()
174          if proj is not None:          if proj is not None:
175              inverse = proj.Inverse              inverse = proj.Inverse
176          else:          else:
# Line 134  class MapRenderer: Line 193  class MapRenderer:
193          self.dc.DrawLines(points)          self.dc.DrawLines(points)
194    
195      def draw_point_shape(self, layer, index):      def draw_point_shape(self, layer, index):
196          p = self.projected_points(layer, index)[0]          pp = self.projected_points(layer, index)
197    
198            if len(pp) == 0: return # ignore Null Shapes which have no points
199    
200            p = pp[0]
201          radius = self.resolution * 5          radius = self.resolution * 5
202          self.dc.DrawEllipse(p.x - radius, p.y - radius, 2*radius, 2*radius)          self.dc.DrawEllipse(p.x - radius, p.y - radius, 2*radius, 2*radius)
203    
# Line 182  class ScreenRenderer(MapRenderer): Line 245  class ScreenRenderer(MapRenderer):
245      # On the screen we want to see only visible layers by default      # On the screen we want to see only visible layers by default
246      honor_visibility = 1      honor_visibility = 1
247            
248      def RenderMap(self, map, selected_layer, selected_shape):      def RenderMap(self, map, region, selected_layer, selected_shapes):
249            """Render the map.
250    
251            Only the given region (a tuple in window coordinates as returned
252            by a wxrect's asTuple method) needs to be redrawn. Highlight the
253            shapes given by the ids in selected_shapes in the
254            selected_layer.
255            """
256            self.update_region = region
257          self.selected_layer = selected_layer          self.selected_layer = selected_layer
258          self.selected_shape = selected_shape          self.selected_shapes = selected_shapes
259          self.render_map(map)          self.render_map(map)
260    
261      def draw_shape_layer(self, layer):      def draw_shape_layer(self, layer):
262          MapRenderer.draw_shape_layer(self, layer)          MapRenderer.draw_shape_layer(self, layer)
263          if layer is self.selected_layer and self.selected_shape is not None:          if layer is self.selected_layer and self.selected_shapes:
264              pen = wxPen(wxBLACK, 3, wxSOLID)              pen = wxPen(wxBLACK, 3, wxSOLID)
265              brush = wxBrush(wxBLACK, wxCROSS_HATCH)              brush = wxBrush(wxBLACK, wxCROSS_HATCH)
266                
267              shapetype = layer.ShapeType()              shapetype = layer.ShapeType()
             index = self.selected_shape  
268              if shapetype == SHAPETYPE_POLYGON:              if shapetype == SHAPETYPE_POLYGON:
269                  self.draw_polygon_shape(layer, index, pen, brush)                  offx, offy = self.offset
270              else:                  renderparam = self.polygon_render_param(layer)
271                    func = self.draw_polygon_shape
272                    args = (pen, brush)
273                elif shapetype == SHAPETYPE_ARC:
274                    renderparam = self.polygon_render_param(layer)
275                    func = self.draw_polygon_shape
276                    args = (pen, None)
277                elif shapetype == SHAPETYPE_POINT:
278                    renderparam = layer
279                  self.dc.SetBrush(brush)                  self.dc.SetBrush(brush)
280                  self.dc.SetPen(pen)                  self.dc.SetPen(pen)
281                  if shapetype == SHAPETYPE_ARC:                  func = self.draw_point_shape
282                      f = self.draw_arc_shape                  args = ()
283                  elif shapetype == SHAPETYPE_POINT:              else:
284                      f = self.draw_point_shape                  raise TypeError(_("Unhandled shape type %s") % shapetype)
285                  f(layer, index)  
286                for index in self.selected_shapes:
287                    func(renderparam, index, *args)
288    
289    
290        def layer_ids(self, layer):
291            """Return the shapeids covered by the region that has to be redrawn
292    
293            Call the layer's ShapesInRegion method to determine the ids so
294            that it can use the quadtree.
295            """
296            # FIXME: the quad-tree should be built from the projected
297            # coordinates not the lat-long ones because it's not trivial to
298            # determine an appropriate rectangle in lat-long for a given
299            # rectangle in projected coordinates which we have to start from
300            # here.
301            proj = self.map.projection
302            if proj is not None:
303                inverse = proj.Inverse
304            else:
305                inverse = None
306    
307            scale = self.scale
308            offx, offy = self.offset
309            xs = []
310            ys = []
311            x, y, width, height = self.update_region
312            for winx, winy in ((x, y), (x + width, y),
313                               (x + width, y + height), (x, y + height)):
314                px = (winx - offx) / scale
315                py = -(winy - offy) / scale
316                if inverse:
317                    px, py = inverse(px, py)
318                xs.append(px)
319                ys.append(py)
320            left = min(xs)
321            right = max(xs)
322            top = max(ys)
323            bottom = min(ys)
324    
325            return layer.ShapesInRegion((left, bottom, right, top))
326    
327    
328  class PrinterRender(MapRenderer):  class PrinterRender(MapRenderer):
Legend:
Removed from v.6  
changed lines
  Added in v.798
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26