/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/UI/renderer.py

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

Parent Directory | Revision Log | View Patch Patch

-revision 394 by jonathan,
Mon Feb 10 15:27:13 2003 UTC
+revision 2537 by jonathan,
Fri Jan 21 14:01:25 2005 UTC
 Line 1
- # Copyright (c) 2001, 2002 by Intevation GmbH
+ # Copyright (c) 2001-2004 by Intevation GmbH
  # Authors:
- # Bernhard Herzog <[email protected]>
+ # Bernhard Herzog <[email protected]> (2001-2003)
+ # Jonathan Coles <[email protected]> (2003)
+ # Frank Koormann <[email protected]> (2003)
+ # Jan-Oliver Wagner <[email protected]> (2003, 2004)
  #
  # This program is free software under the GPL (>=v2)
  # Read the file COPYING coming with Thuban for details.
- __version__ = "$Revision$"
+ from __future__ import generators
- from wxPython.wx import wxPoint, wxColour, wxPen, wxBrush, wxFont, \
+ __version__ = "$Revision$"
-      wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
+ # $Source$
-      wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL
+ # $Id$
- from wxproj import draw_polygon_shape
+ import cStringIO
  from Thuban import _
- from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
+ from wxPython.wx import wxPoint, wxRect, wxPen, wxBrush, wxFont, \
-      SHAPETYPE_POINT
+     wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
- from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
+     wxBLACK_PEN, wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL, \
-      ALIGN_LEFT, ALIGN_RIGHT, ALIGN_BASELINE
+     wxBitmapFromImage, wxImageFromStream, wxBITMAP_TYPE_BMP, \
+     wxBITMAP_TYPE_JPEG, wxBITMAP_TYPE_PNG, wxBITMAP_TYPE_TIF, \
+     wxBITMAP_TYPE_GIF, wxEmptyImage
- from Thuban.Model.classification import Classification
+ from wxproj import draw_polygon_shape, draw_polygon_init
+ from Thuban.UI.common import Color2wxColour
+ from Thuban.UI.classifier import ClassDataPreviewer
+ from Thuban.UI.scalebar import ScaleBar
- class MapRenderer:
+ from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
+      SHAPETYPE_POINT, RAW_SHAPEFILE
-     """Class to render a map onto a wxDC"""
+ from Thuban.Model.color import Transparent
+ import Thuban.Model.resource
-     honor_visibility = 1
+ from baserenderer import BaseRenderer
-     def __init__(self, dc, scale, offset, resolution = 72.0,
+ from math import floor
-                  honor_visibility = None):
-         """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())
-     def draw_shape_layer(self, layer):
+ from types import StringType
-         scale = self.scale
-         offx, offy = self.offset
-         map_proj = self.map.projection
-         layer_proj = layer.projection
-         shapetype = layer.ShapeType()
+ # Map the strings used for the format parameter of the draw_raster_data
+ # method to the appropriate wxWindows constants
+ raster_format_map = {
+     "BMP": wxBITMAP_TYPE_BMP,
+     "JPEG": wxBITMAP_TYPE_JPEG,
+     "PNG": wxBITMAP_TYPE_PNG,
+     "TIFF": wxBITMAP_TYPE_TIF,
+     "GIF": wxBITMAP_TYPE_GIF,
+     }
-         brush = wxTRANSPARENT_BRUSH
+ class MapRenderer(BaseRenderer):
-         pen   = wxTRANSPARENT_PEN
-         old_prop = None
+     """Class to render a map onto a wxDC"""
-         for i in self.layer_ids(layer):
-             value = None
-             shape = layer.Shape(i)
-             lc = layer.classification
-             field = lc.field
-             if field is not None:
-                 record = layer.table.read_record(i)
-                 if record is not None:
-                     value = record[field]
-             #
-             # if the above statements fail 'value' should
-             # be null, at which point this call will
-             # at least retreive the NullData
-             #
-             prop = lc.GetProperties(value)
-             if prop != old_prop:
-                 old_prop = prop
-                 if shapetype == SHAPETYPE_ARC:
-                     fill = None
-                 else:
-                     fill = prop.GetFill()
-                 if fill is None:
-                     brush = wxTRANSPARENT_BRUSH
-                 else:
-                     color = wxColour(fill.red * 255,
-                                      fill.green * 255,
-                                      fill.blue * 255)
-                     brush = wxBrush(color, wxSOLID)
-                 stroke = prop.GetStroke()
-                 stroke_width = prop.GetStrokeWidth()
-                 if stroke is None:
-                     pen = wxTRANSPARENT_PEN
-                 else:
-                     color = wxColour(stroke.red * 255,
-                                      stroke.green * 255,
-                                      stroke.blue * 255)
-                     pen = wxPen(color, stroke_width, wxSOLID)
-             if shapetype == SHAPETYPE_POINT:
-                 self.dc.SetBrush(brush)
-                 self.dc.SetPen(pen)
-                 self.draw_point_shape(layer, i)
-             else:
-                 self.draw_polygon_shape(layer, i, pen, brush)
-     def layer_ids(self, layer):
+     TRANSPARENT_PEN = wxTRANSPARENT_PEN
-         """Return the shape ids of the given layer that have to be drawn.
+     TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH
-         The default implementation simply returns all ids in the layer.
-         Override in derived classes to be more precise.
-         """
-         return range(layer.NumShapes())
-     def draw_polygon_shape(self, layer, index, pen, brush):
+     def make_point(self, x, y):
-         offx, offy = self.offset
+         return wxPoint(int(round(x)), int(round(y)))
-         draw_polygon_shape(layer.shapefile.cobject(), index,
-                            self.dc, pen, brush,
-                            self.map.projection, layer.projection,
-                            self.scale, -self.scale, offx, offy)
-     def projected_points(self, layer, index):
+     def tools_for_property(self, prop):
-         proj = self.map.projection
+         fill = prop.GetFill()
-         if proj is not None:
+         if fill is Transparent:
-             forward = proj.Forward
+             brush = self.TRANSPARENT_BRUSH
          else:
-             forward = None
+             brush = wxBrush(Color2wxColour(fill), wxSOLID)
-         proj = layer.projection
-         if proj is not None:
+         stroke = prop.GetLineColor()
-             inverse = proj.Inverse
+         if stroke is Transparent:
+             pen = self.TRANSPARENT_PEN
          else:
-             inverse = None
+             pen = wxPen(Color2wxColour(stroke), prop.GetLineWidth(), wxSOLID)
-         shape = layer.Shape(index)
+         return pen, brush
-         points = []
-         scale = self.scale
-         offx, offy = self.offset
-         for x, y in shape.Points():
-             if inverse:
-                 x, y = inverse(x, y)
-             if forward:
-                 x, y = forward(x, y)
-             points.append(wxPoint(x * scale + offx,
-                                   -y * scale + offy))
-         return points
-     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)
-     def draw_label_layer(self, layer):
+     def low_level_renderer(self, layer):
-         scale = self.scale
+         """Override inherited method to provide more efficient renderers
-         offx, offy = self.offset
-         font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
+         If the underlying data format is not a shapefile or the layer
-         self.dc.SetFont(font)
+         contains points shapes, simply use what the inherited method
+         returns.
+         Otherwise, i.e. for arc and polygon use the more efficient
+         wxproj.draw_polygon_shape and its corresponding parameter
+         created with wxproj.draw_polygon_init.
+         """
+         if (layer.ShapeStore().RawShapeFormat() == RAW_SHAPEFILE
+             and layer.ShapeType() in (SHAPETYPE_ARC, SHAPETYPE_POLYGON)):
+             offx, offy = self.offset
+             return (True, draw_polygon_shape,
+                     draw_polygon_init(layer.ShapeStore().Shapefile(),
+                                       self.dc, self.map.projection,
+                                       layer.projection,
+                                       self.scale, -self.scale, offx, offy))
+         else:
+             return BaseRenderer.low_level_renderer(self, layer)
-         map_proj = self.map.projection
+     def label_font(self):
-         if map_proj is not None:
+         return wxFont(int(round(self.resolution * 10)), wxSWISS, wxNORMAL,
-             forward = map_proj.Forward
+                       wxNORMAL)
+     def draw_raster_data(self, x,y, data, format = 'BMP', mask = None):
+         if format == 'RAW':
+             image = wxEmptyImage(data[0], data[1])
+             image.SetData(data[2])
          else:
-             forward = None
+             stream = cStringIO.StringIO(data[2])
+             image = wxImageFromStream(stream, raster_format_map[format])
-         for label in layer.Labels():
+         bitmap = wxBitmapFromImage(image)
-             x = label.x
-             y = label.y
+         if mask is None:
-             text = label.text
+             self.dc.DrawBitmap(bitmap, int(round(x)), int(round(y)), False)
-             if forward:
+         else:
-                 x, y = forward(x, y)
+             # if we are given a mask object, try to pass it to SetMaskColour,
-             x = x * scale + offx
+             # otherwise assume it's a mask image
-             y = -y * scale + offy
+             try:
-             width, height = self.dc.GetTextExtent(text)
+                 bitmap.SetMaskColour(mask);
-             if label.halign == ALIGN_LEFT:
+                 self.dc.DrawBitmap(bitmap, int(round(x)), int(round(y)), True)
-                 # nothing to be done
+             except (TypeError):
-                 pass
+                 # implement using a mask image
-             elif label.halign == ALIGN_RIGHT:
+                 raise NotImplementedError
-                 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)
  class ScreenRenderer(MapRenderer):
      # On the screen we want to see only visible layers by default
      honor_visibility = 1
-     def RenderMap(self, map, region, selected_layer, selected_shape):
+     def RenderMap(self, selected_layer, selected_shapes):
          """Render the map.
          Only the given region (a tuple in window coordinates as returned
          by a wxrect's asTuple method) needs to be redrawn. Highlight the
-         shape with id selected_shape in the selected_layer.
+         shapes given by the ids in selected_shapes in the
+         selected_layer.
          """
-         self.update_region = region
          self.selected_layer = selected_layer
-         self.selected_shape = selected_shape
+         self.selected_shapes = selected_shapes
-         self.render_map(map)
+         self.render_map()
+     def RenderMapIncrementally(self):
+         """Render the map.
+         Only the given region (a tuple in window coordinates as returned
+         by a wxrect's asTuple method) needs to be redrawn. Highlight the
+         shapes given by the ids in selected_shapes in the
+         selected_layer.
+         """
+         return self.render_map_incrementally()
+     def draw_selection_incrementally(self, layer, selected_shapes):
+         """Draw the selected shapes in a emphasized way (i.e.
+         with a special pen and brush.
+         The drawing is performed incrementally, that means every
+         n shapes, the user can have interactions with the map.
+         n is currently fixed to 500.
+         layer -- the layer where the shapes belong to.
+         selected_shapes -- a list of the shape-ids representing the
+                            selected shapes for the given layer.
+         """
+         pen = wxPen(wxBLACK, 3, wxSOLID)
+         brush = wxBrush(wxBLACK, wxCROSS_HATCH)
-     def draw_shape_layer(self, layer):
+         shapetype = layer.ShapeType()
-         MapRenderer.draw_shape_layer(self, layer)
+         useraw, func, param = self.low_level_renderer(layer)
-         if layer is self.selected_layer and self.selected_shape is not None:
+         args = (pen, brush)
-             pen = wxPen(wxBLACK, 3, wxSOLID)
-             brush = wxBrush(wxBLACK, wxCROSS_HATCH)
+         # for point shapes we need to find out the properties
+         # to determine the size. Based on table and field,
-             shapetype = layer.ShapeType()
+         # we can find out the properties for object - see below.
-             index = self.selected_shape
+         if shapetype == SHAPETYPE_POINT:
-             if shapetype == SHAPETYPE_POLYGON:
+             lc = layer.GetClassification()
-                 self.draw_polygon_shape(layer, index, pen, brush)
+             field = layer.GetClassificationColumn()
-             elif shapetype == SHAPETYPE_ARC:
+             table = layer.ShapeStore().Table()
-                 self.draw_polygon_shape(layer, index, pen, None)
+         count = 0
+         for index in selected_shapes:
+             count += 1
+             shape = layer.Shape(index)
+             # Get the size of the specific property for this
+             # point
+             if shapetype == SHAPETYPE_POINT and field is not None:
+                 value = table.ReadValue(shape.ShapeID(), field)
+                 group = lc.FindGroup(value)
+                 size = group.GetProperties().GetSize()
+                 args = (pen, brush, size)
+             if useraw:
+                 data = shape.RawData()
              else:
-                 self.dc.SetBrush(brush)
+                 data = shape.Points()
-                 self.dc.SetPen(pen)
+             func(param, data, *args)
-                 if shapetype == SHAPETYPE_POINT:
+             if count % 500 == 0:
-                     self.draw_point_shape(layer, index)
+                 yield True
-                 else:
-                     raise TypeError(_("Unhandled shape type %s") % shapetype)
-     def layer_ids(self, layer):
+     def layer_shapes(self, layer):
          """Return the shapeids covered by the region that has to be redrawn
          Call the layer's ShapesInRegion method to determine the ids so
-Line 272 
 class ScreenRenderer(MapRenderer):
+Line 222 
 class ScreenRenderer(MapRenderer):
          offx, offy = self.offset
          xs = []
          ys = []
-         x, y, width, height = self.update_region
+         x, y, width, height = self.region
          for winx, winy in ((x, y), (x + width, y),
                             (x + width, y + height), (x, y + height)):
              px = (winx - offx) / scale
-Line 289 
 class ScreenRenderer(MapRenderer):
+Line 239 
 class ScreenRenderer(MapRenderer):
          return layer.ShapesInRegion((left, bottom, right, top))
- class PrinterRender(MapRenderer):
+ class ExportRenderer(ScreenRenderer):
+     honor_visibility = 1
+     def __init__(self, *args, **kw):
+         """Initialize the ExportRenderer.
+         In addition to all parameters of the the ScreenRender
+         constructor, this class requires and additional keyword argument
+         destination_region with a tuple (minx, miny, maxx, maxy) giving
+         the region in dc coordinates which is to contain the map.
+         """
+         self.destination_region = kw["destination_region"]
+         del kw["destination_region"]
+         ScreenRenderer.__init__(self, *args, **kw)
+     def RenderMap(self, selected_layer, selected_shapes):
+         """Render the map.
+         The rendering device has been specified during initialisation.
+         The device border distance was set in
+         Thuban.UI.viewport.output_transform().
+         RenderMap renders a frame set (one page frame, one around
+         legend/scalebar and one around the map), the map, the legend and
+         the scalebar on the given DC. The map is rendered with the
+         region displayed in the canvas view, centered on the area
+         available for map display.
+         """
+         self.selected_layer = selected_layer
+         self.selected_shapes = selected_shapes
+         # Get some dimensions
+         llx, lly, urx, ury = self.region
+         mminx, mminy, mmaxx, mmaxy = self.destination_region
-     # When printing we want to see all layers
+         # Manipulate the offset to position the map
-     honor_visibility = 0
+         offx, offy = self.offset
+         # 1. Shift to corner of map drawing area
+         offx = offx + mminx
+         offy = offy + mminy
+         # 2. Center the map on the map drawing area:
+         # region identifies the region on the canvas view:
+         # center of map drawing area - half the size of region: rendering origin
+         self.shiftx = (mmaxx - mminx)*0.5 - (urx - llx)*0.5
+         self.shifty = (mmaxy - mminy)*0.5 - (ury - lly)*0.5
+         self.offset = (offx+self.shiftx, offy+self.shifty)
+         self.region = (llx + self.shiftx, lly + self.shifty, urx, ury)
+         # Draw the map
+         self.dc.BeginDrawing()
+         self.dc.DestroyClippingRegion()
+         self.dc.SetClippingRegion(mminx+self.shiftx, mminy+self.shifty,
+                                   urx, ury)
+         self.render_map()
+         self.dc.EndDrawing()
+         # Draw the rest (frames, legend, scalebar)
+         self.dc.BeginDrawing()
+         self.dc.DestroyClippingRegion()
+         # Force the font for Legend drawing
+         font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
+         self.dc.SetFont(font)
+         self.render_frame()
+         self.render_legend()
+         self.render_scalebar()
+         self.dc.EndDrawing()
+     def render_frame(self):
+         """Render the frames for map and legend/scalebar."""
+         dc = self.dc
+         dc.SetPen(wxBLACK_PEN)
+         dc.SetBrush(wxTRANSPARENT_BRUSH)
+         # Dimension stuff
+         width, height = dc.GetSizeTuple()
+         mminx, mminy, mmaxx, mmaxy = self.destination_region
+         # Page Frame
+         dc.DrawRectangle(15,15,width-30, (mmaxy-mminy)+10)
+         # Map Frame
+         llx, lly, urx, ury = self.region
+         dc.DrawRectangle(mminx + self.shiftx, mminy + self.shifty, urx, ury)
+         # Legend Frame
+         dc.DrawRectangle(mmaxx+10,mminy,(width-20) - (mmaxx+10), mmaxy-mminy)
+         dc.DestroyClippingRegion()
+         dc.SetClippingRegion(mmaxx+10,mminy,
+                              (width-20) - (mmaxx+10), mmaxy-mminy)
+     def render_legend(self):
+         """Render the legend on the Map."""
+         previewer = ClassDataPreviewer()
+         dc = self.dc
+         dc.SetPen(wxBLACK_PEN)
+         dc.SetBrush(wxTRANSPARENT_BRUSH)
+         # Dimension stuff
+         width, height = dc.GetSizeTuple()
+         mminx, mminy, mmaxx, mmaxy = self.destination_region
+         textwidth, textheight = dc.GetTextExtent("0")
+         iconwidth  = textheight
+         iconheight = textheight
+         stepy = textheight+3
+         dx = 10
+         posx = mmaxx + 10 + 5   # 10 pix distance mapframe/legend frame,
+                                 # 5 pix inside legend frame
+         posy = mminy + 5        # 5 pix inside legend frame
+         # Render the legend
+         dc.SetTextForeground(wxBLACK)
+         if self.map.HasLayers():
+             layers = self.map.Layers()[:]
+             layers.reverse()
+             for l in layers:
+                 if l.Visible():
+                     # Render title
+                     dc.DrawText(l.Title(), posx, posy)
+                     posy+=stepy
+                     if l.HasClassification():
+                         # Render classification
+                         clazz = l.GetClassification()
+                         shapeType = l.ShapeType()
+                         for g in clazz:
+                             if g.IsVisible():
+                                 previewer.Draw(dc,
+                                     wxRect(posx+dx, posy,
+                                            iconwidth, iconheight),
+                                     g.GetProperties(), shapeType)
+                                 dc.DrawText(g.GetDisplayText(),
+                                             posx+2*dx+iconwidth, posy)
+                                 posy+=stepy
+     def render_scalebar(self):
+         """Render the scalebar."""
+         scalebar = ScaleBar(self.map)
+         # Dimension stuff
+         width, height = self.dc.GetSizeTuple()
+         mminx, mminy, mmaxx, mmaxy = self.destination_region
+         # Render the scalebar
+         scalebar.DrawScaleBar(self.scale, self.dc,
+                              (mmaxx+10+5, mmaxy-25),
+                              ((width-15-5) - (mmaxx+10+5),20)
+                             )
+         # 10 pix between map and legend frame, 5 pix inside legend frame
+         # 25 pix from the legend frame bottom line
+         # Width: 15 pix from DC border, 5 pix inside frame, 10, 5 as above
+         # Height: 20
+ class PrinterRenderer(ExportRenderer):
+     # Printing as well as Export / Screen display only the visible layer.
+     honor_visibility = 1
-     RenderMap = MapRenderer.render_map

 Legend:



Removed from v.394
 


changed lines


 
Added in v.2537
 Legend:



Removed from v.394
 


changed lines


 
Added in v.2537
-Removed from v.394
+Added in v.2537

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26