/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/UI/baserenderer.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/Thuban/UI/baserenderer.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1935 by bh, Tue Nov 11 18:16:20 2003 UTC revision 2537 by jonathan, Fri Jan 21 14:01:25 2005 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001, 2002, 2003 by Intevation GmbH  # Copyright (c) 2001, 2002, 2003, 2004 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]>
4  # Jonathan Coles <[email protected]>  # Jonathan Coles <[email protected]>
# Line 42  if Thuban.Model.resource.has_gdal_suppor Line 42  if Thuban.Model.resource.has_gdal_suppor
42  # (layer_class, draw_function) pairs. If the renderer has to draw a  # (layer_class, draw_function) pairs. If the renderer has to draw a
43  # non-builtin layer type, i.e. a layer that is not a subclass of Layer  # non-builtin layer type, i.e. a layer that is not a subclass of Layer
44  # or RasterLayer, it iterates through that list, tests whether the layer  # or RasterLayer, it iterates through that list, tests whether the layer
45  # to be drawin is an instance of layer_class and if so calls  # to be drawn is an instance of layer_class and if so calls
46  # draw_function with the renderer and the layer as arguments. Since  # draw_function with the renderer and the layer as arguments. Since
47  # drawing is done incrementally, the draw_function should return an  # drawing is done incrementally, the draw_function should return an
48  # iterable. The easiest way is to simply implement the draw_function as  # iterable. The easiest way is to simply implement the draw_function as
# Line 64  def add_renderer_extension(layer_class, Line 64  def add_renderer_extension(layer_class,
64      function should return an iterable. The easiest way is to simply      function should return an iterable. The easiest way is to simply
65      implement the draw_function as a generator and to yield True in      implement the draw_function as a generator and to yield True in
66      suitable places, or to return the empty tuple if it's not possible      suitable places, or to return the empty tuple if it's not possible
67      to do the rendering in incrementally.      to do the rendering incrementally.
68      """      """
69      _renderer_extensions.append((layer_class, function))      _renderer_extensions.append((layer_class, function))
70    
# Line 76  def init_renderer_extensions(): Line 76  def init_renderer_extensions():
76      """      """
77      del _renderer_extensions[:]      del _renderer_extensions[:]
78    
79    def proj_params_to_str(proj):
80        "Build a string suitable for GDAL describing the given projection"
81        str = ""
82        if proj is not None:
83            for p in proj.GetAllParameters():
84                str += "+" + p + " "
85        return str
86    
87  #  #
88  #       Base Renderer  #       Base Renderer
# Line 177  class BaseRenderer: Line 184  class BaseRenderer:
184          that methods especially in derived classes have access to the          that methods especially in derived classes have access to the
185          map if necessary.          map if necessary.
186          """          """
         # Whether the raster layer has already been drawn. See below for  
         # the optimization this is used for  
         seenRaster = True  
   
         #  
         # This is only a good optimization if there is only one  
         # raster layer and the image covers the entire window (as  
         # it currently does). We note if there is a raster layer  
         # and only begin drawing layers once we have drawn it.  
         # That way we avoid drawing layers that won't be seen.  
         #  
         if Thuban.Model.resource.has_gdal_support():  
             for layer in self.map.Layers():  
                 if isinstance(layer, RasterLayer) and layer.Visible():  
                     seenRaster = False  
                     break  
187    
188          for layer in self.map.Layers():          for layer in self.map.Layers():
189              # if honor_visibility is true, only draw visible layers,              # if honor_visibility is true, only draw visible layers,
190              # otherwise draw all layers              # otherwise draw all layers
191              if not self.honor_visibility or layer.Visible():              if not self.honor_visibility or layer.Visible():
192                  if isinstance(layer, Layer) and seenRaster:                  if isinstance(layer, Layer):
193                      for i in self.draw_shape_layer_incrementally(layer):                      for i in self.draw_shape_layer_incrementally(layer):
194                          yield True                          yield True
195                  elif isinstance(layer, RasterLayer) \                  elif isinstance(layer, RasterLayer) \
196                      and Thuban.Model.resource.has_gdal_support():                      and Thuban.Model.resource.has_gdal_support():
197                      self.draw_raster_layer(layer)                      self.draw_raster_layer(layer)
                     seenRaster = True  
198                      yield True                      yield True
199                  else:                  else:
200                      # look it up in the renderer extensions                      # look it up in the renderer extensions
# Line 288  class BaseRenderer: Line 278  class BaseRenderer:
278                  data = shape.RawData()                  data = shape.RawData()
279              else:              else:
280                  data = shape.Points()                  data = shape.Points()
281              draw_func(draw_func_param, data, pen, brush)              if draw_func == self.draw_point_shape:
282                     draw_func(draw_func_param, data, pen, brush,
283                               size = group.GetProperties().GetSize())
284                else:
285                     draw_func(draw_func_param, data, pen, brush)
286              if count % 500 == 0:              if count % 500 == 0:
287                  yield True                  yield True
288    
# Line 365  class BaseRenderer: Line 359  class BaseRenderer:
359          scale = self.scale          scale = self.scale
360          offx, offy = self.offset          offx, offy = self.offset
361          make_point = self.make_point          make_point = self.make_point
362    
363          for part in points:          for part in points:
364              result.append([])              result.append([])
365              for x, y in part:              for x, y in part:
# Line 383  class BaseRenderer: Line 378  class BaseRenderer:
378          value of the shape's Points() method. The coordinates in the          value of the shape's Points() method. The coordinates in the
379          DC's coordinate system are determined with          DC's coordinate system are determined with
380          self.projected_points.          self.projected_points.
381    
382            For a description of the algorithm look in wxproj.cpp.
383          """          """
384          points = self.projected_points(layer, points)          points = self.projected_points(layer, points)
385    
# Line 391  class BaseRenderer: Line 388  class BaseRenderer:
388              for part in points:              for part in points:
389                  polygon.extend(part)                  polygon.extend(part)
390    
391                # missing back vertices for correct filling.
392              insert_index = len(polygon)              insert_index = len(polygon)
393              for part in points[:-1]:              for part in points[:-1]:
394                  polygon.insert(insert_index, part[0])                  polygon.insert(insert_index, part[0])
# Line 420  class BaseRenderer: Line 418  class BaseRenderer:
418          for part in points:          for part in points:
419              self.dc.DrawLines(part)              self.dc.DrawLines(part)
420    
421      def draw_point_shape(self, layer, points, pen, brush):      def draw_point_shape(self, layer, points, pen, brush, size = 5):
422          """Draw a point shape from layer with the given brush and pen          """Draw a point shape from layer with the given brush and pen
423    
424          The shape is given by points argument which is a the return          The shape is given by points argument which is a the return
# Line 434  class BaseRenderer: Line 432  class BaseRenderer:
432          if not points:          if not points:
433              return              return
434    
435          radius = int(round(self.resolution * 5))          radius = int(round(self.resolution * size))
436          self.dc.SetBrush(brush)          self.dc.SetBrush(brush)
437          self.dc.SetPen(pen)          self.dc.SetPen(pen)
438          for part in points:          for part in points:
# Line 454  class BaseRenderer: Line 452  class BaseRenderer:
452          offx, offy = self.offset          offx, offy = self.offset
453          width, height = self.dc.GetSizeTuple()          width, height = self.dc.GetSizeTuple()
454    
455          in_proj = ""          in_proj  = proj_params_to_str(layer.GetProjection())
456          proj = layer.GetProjection()          out_proj = proj_params_to_str(self.map.GetProjection())
         if proj is not None:  
             for p in proj.GetAllParameters():  
                 in_proj += "+" + p + " "  
457    
458          out_proj = ""          # True  -- warp the image to the size of the whole screen
459          proj = self.map.GetProjection()          # False -- only use the bound box of the layer (currently inaccurate)
460          if proj is not None:          if True:
461              for p in proj.GetAllParameters():              pmin = [0,height]
462                  out_proj += "+" + p + " "              pmax = [width, 0]
463            else:
464                bb = layer.LatLongBoundingBox()
465                bb = [[[bb[0], bb[1]], [bb[2], bb[3]],],]
466                pmin, pmax = self.projected_points(layer, bb)[0]
467    
468            fmin = [max(0, pmin[0]) - offx, offy - min(height, pmin[1])]
469            fmax = [min(width, pmax[0]) - offx, offy - max(0, pmax[1])]
470    
471            xmin = fmin[0]/self.scale
472            ymin = fmin[1]/self.scale
473            xmax = fmax[0]/self.scale
474            ymax = fmax[1]/self.scale
475    
476          xmin = (0 - offx) / self.scale          width  = int(min(width,  round(fmax[0] - fmin[0] + 1)))
477          ymin = (offy - height) / self.scale          height = int(min(height, round(fmax[1] - fmin[1] + 1)))
         xmax = (width - offx) / self.scale  
         ymax = (offy - 0) / self.scale  
478    
479          try:          try:
480              data = ProjectRasterFile(layer.GetImageFilename(),              data = [width, height,
481                        ProjectRasterFile(layer.GetImageFilename(),
482                                       in_proj, out_proj,                                       in_proj, out_proj,
483                                       (xmin, ymin, xmax, ymax), "",                                       (xmin, ymin, xmax, ymax), "",
484                                       (width, height))                                       (width, height))
485                       ]
486          except (IOError, AttributeError, ValueError):          except (IOError, AttributeError, ValueError):
487              # Why does this catch AttributeError and ValueError?              # Why does this catch AttributeError and ValueError?
488              # FIXME: The exception should be communicated to the user              # FIXME: The exception should be communicated to the user
489              # better.              # better.
490              traceback.print_exc()              traceback.print_exc()
491          else:          else:
492              self.draw_raster_data(data, "BMP")              mask = "#030104"
493                #mask = None
494      def draw_raster_data(self, data, format="BMP"):              self.draw_raster_data(fmin[0]+offx, offy-fmax[1], data, "RAW", mask)
495          """Draw the raster image in data onto the DC              data = None
496    
497        def draw_raster_data(self, x, y, data, format="BMP", mask = None):
498            """Draw the raster image in data onto the DC with the top
499            left corner at (x,y)
500    
501          The raster image data is a string holding the data in the format          The raster image data is a list holding the image width, height,
502          indicated by the format parameter. The image is assumed to be          and data in the format indicated by the format parameter.
         exactly the size of the dc and to cover it completely.  
503    
504          The format parameter is a string with the name of the format.          The format parameter is a string with the name of the format.
505          The following format names should be used:          The following format names should be used:
506    
507            'BMP' -- Windows Bitmap            'RAW'  -- an array of RGB values (len=3*width*height)
508            'JPEG' -- Jpeg            'BMP'  -- Windows Bitmap
509              'JPEG' -- JPEG Image
510          The default format is 'bmp'.  
511            The default format is 'BMP'.
512    
513            The mask parameter determines how a mask (if any) is applied
514            to the image. mask can have the following values:
515            
516              o  None -- no mask is used
517              o  Any object accepted by wxBitmap.SetMaskColour()
518              o  A one-bit image the same size as the image data
519    
520          This method has to be implemented by derived classes. The          This method has to be implemented by derived classes. The
521          implementation in the derived class should try to support at          implementation in the derived class should try to support at
Legend:
Removed from v.1935  
changed lines
  Added in v.2537
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26