/[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 676 by jonathan, Tue Apr 15 19:20:40 2003 UTC revision 882 by jonathan, Fri May 9 16:34:28 2003 UTC
# Line 8  Line 8 
8    
9  __version__ = "$Revision$"  __version__ = "$Revision$"
10    
11    from Thuban import _
12    
13  from wxPython.wx import wxPoint, wxPen, wxBrush, wxFont, \  from wxPython.wx import wxPoint, wxPen, wxBrush, wxFont, \
14       wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \       wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
15       wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL       wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL
16    
17  from wxproj import draw_polygon_shape, draw_polygon_init  from wxproj import draw_polygon_shape, draw_polygon_init
18    
19  from Thuban import _  from Thuban.UI.common import Color2wxColour
 from Thuban.UI.common import *  
20    
21  from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \  from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
22       SHAPETYPE_POINT       SHAPETYPE_POINT
# Line 25  from Thuban.Model.label import ALIGN_CEN Line 26  from Thuban.Model.label import ALIGN_CEN
26  from Thuban.Model.classification import Classification  from Thuban.Model.classification import Classification
27  from Thuban.Model.color import Color  from Thuban.Model.color import Color
28    
 import time  
   
   
29  class MapRenderer:  class MapRenderer:
30    
31      """Class to render a map onto a wxDC"""      """Class to render a map onto a wxDC"""
# Line 51  class MapRenderer: Line 49  class MapRenderer:
49          """          """
50          # resolution in pixel/inch          # resolution in pixel/inch
51    
         assert scale > 0  
   
52          self.dc = dc          self.dc = dc
53          self.scale = scale          self.scale = scale
54          self.offset = offset          self.offset = offset
# Line 84  class MapRenderer: Line 80  class MapRenderer:
80          pen   = wxTRANSPARENT_PEN          pen   = wxTRANSPARENT_PEN
81    
82          old_prop = None          old_prop = None
83            old_group = None
84          lc = layer.GetClassification()          lc = layer.GetClassification()
85          field = lc.GetField()          field = lc.GetField()
86            defaultGroup = lc.GetDefaultGroup()
87    
         #print "drawing layer: ", layer.Title(),  
         #start = time.clock()  
         #count = 0  
88    
89          if shapetype != SHAPETYPE_POINT:          if shapetype != SHAPETYPE_POINT:
90              offx, offy = self.offset                      polygon_render_param = self.polygon_render_param(layer)
             draw_polygon_init(layer.shapefile.cobject(),  
                               self.dc,  
                               self.map.projection, layer.projection,  
                               self.scale, -self.scale, offx, offy)  
91    
92            if shapetype == SHAPETYPE_POINT:
93                draw_func = lambda i: \
94                       self.draw_point_shape(layer, i)
95            else:
96                draw_func = lambda i: \
97                       self.draw_polygon_shape(polygon_render_param, i, pen, brush)
98                
99          for i in self.layer_ids(layer):          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  
                 #  
   
                 group = lc.FindGroup(value)  
100    
101                  #prop = lc.GetProperties(value)              if field is None:
102                    group = defaultGroup
103              else:              else:
104                  group = lc.GetDefaultGroup()                  record = layer.table.ReadRowAsDict(i)
105                    assert record is not None
106                    group = lc.FindGroup(record[field])
107    
108    
109              if not group.IsVisible():              if not group.IsVisible():
110                  continue                  continue
111    
             prop = group.GetProperties()  
112    
113              # don't recreate new objects if they are the same as before              # don't recreate new objects if they are the same as before
114              if prop != old_prop:              if group is not old_group:
115                  old_prop = prop                  old_group = group
116    
117                  if shapetype == SHAPETYPE_ARC:                  prop = group.GetProperties()
                     fill = Color.Transparent  
                 else:  
                     fill = prop.GetFill()  
118    
119                        if prop != old_prop:
120                  if fill is Color.Transparent:                      old_prop = prop
                     brush = wxTRANSPARENT_BRUSH  
                 else:  
                     color = Color2wxColour(fill)  
                     brush = wxBrush(color, wxSOLID)  
       
                 stroke = prop.GetLineColor()  
                 stroke_width = prop.GetLineWidth()  
                 if stroke is Color.Transparent:  
                     pen = wxTRANSPARENT_PEN  
                 else:  
                     color = Color2wxColour(stroke)  
                     pen = wxPen(color, stroke_width, wxSOLID)  
121    
122                  self.dc.SetBrush(brush)                      if shapetype == SHAPETYPE_ARC:
123                  self.dc.SetPen(pen)                          fill = Color.Transparent
124                            else:
125              if shapetype == SHAPETYPE_POINT:                          fill = prop.GetFill()
126                  self.draw_point_shape(layer, i)  
127              else:  
128                  self.draw_polygon_shape(layer, i, pen, brush)                      if fill is Color.Transparent:
129                            brush = wxTRANSPARENT_BRUSH
130              #count += 1                      else:
131                            color = Color2wxColour(fill)
132          #end = time.clock()                          brush = wxBrush(color, wxSOLID)
133          #print (end-start), "seconds -- ", count  
134                        stroke = prop.GetLineColor()
135                        stroke_width = prop.GetLineWidth()
136                        if stroke is Color.Transparent:
137                            pen = wxTRANSPARENT_PEN
138                        else:
139                            color = Color2wxColour(stroke)
140                            pen = wxPen(color, stroke_width, wxSOLID)
141    
142                        if shapetype == SHAPETYPE_POINT:
143                            self.dc.SetBrush(brush)
144                            self.dc.SetPen(pen)
145    
146                draw_func(i)
147    
148      def layer_ids(self, layer):      def layer_ids(self, layer):
149          """Return the shape ids of the given layer that have to be drawn.          """Return the shape ids of the given layer that have to be drawn.
150            
151          The default implementation simply returns all ids in the layer.          The default implementation simply returns all ids in the layer.
152          Override in derived classes to be more precise.          Override in derived classes to be more precise.
153          """          """
154          return range(layer.NumShapes())          return range(layer.NumShapes())
155    
156      def draw_polygon_shape(self, layer, index, pen, brush):      def polygon_render_param(self, layer):
157          draw_polygon_shape(index, pen, brush)          """Return the low-lever render parameter for the layer"""
158            offx, offy = self.offset
159            return draw_polygon_init(layer.shapefile, self.dc,
160                                     self.map.projection,
161                                     layer.projection,
162                                     self.scale, -self.scale,
163                                     offx, offy)
164    
165        def draw_polygon_shape(self, draw_polygon_info, index, pen, brush):
166            draw_polygon_shape(draw_polygon_info, index, pen, brush)
167    
168      def projected_points(self, layer, index):      def projected_points(self, layer, index):
169          proj = self.map.projection          proj = self.map.GetProjection()
170          if proj is not None:          if proj is not None:
171              forward = proj.Forward              forward = proj.Forward
172          else:          else:
173              forward = None              forward = None
174          proj = layer.projection          proj = layer.GetProjection()
175          if proj is not None:          if proj is not None:
176              inverse = proj.Inverse              inverse = proj.Inverse
177          else:          else:
# Line 278  class ScreenRenderer(MapRenderer): Line 267  class ScreenRenderer(MapRenderer):
267    
268              shapetype = layer.ShapeType()              shapetype = layer.ShapeType()
269              if shapetype == SHAPETYPE_POLYGON:              if shapetype == SHAPETYPE_POLYGON:
270                    offx, offy = self.offset
271                    renderparam = self.polygon_render_param(layer)
272                  func = self.draw_polygon_shape                  func = self.draw_polygon_shape
273                  args = (pen, brush)                  args = (pen, brush)
274              elif shapetype == SHAPETYPE_ARC:              elif shapetype == SHAPETYPE_ARC:
275                    renderparam = self.polygon_render_param(layer)
276                  func = self.draw_polygon_shape                  func = self.draw_polygon_shape
277                  args = (pen, None)                  args = (pen, None)
278              elif shapetype == SHAPETYPE_POINT:              elif shapetype == SHAPETYPE_POINT:
279                    renderparam = layer
280                  self.dc.SetBrush(brush)                  self.dc.SetBrush(brush)
281                  self.dc.SetPen(pen)                  self.dc.SetPen(pen)
282                  func = self.draw_point_shape                  func = self.draw_point_shape
# Line 292  class ScreenRenderer(MapRenderer): Line 285  class ScreenRenderer(MapRenderer):
285                  raise TypeError(_("Unhandled shape type %s") % shapetype)                  raise TypeError(_("Unhandled shape type %s") % shapetype)
286    
287              for index in self.selected_shapes:              for index in self.selected_shapes:
288                  func(layer, index, *args)                  func(renderparam, index, *args)
289    
290    
291      def layer_ids(self, layer):      def layer_ids(self, layer):
292          """Return the shapeids covered by the region that has to be redrawn          """Return the shapeids covered by the region that has to be redrawn
Legend:
Removed from v.676  
changed lines
  Added in v.882
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26