/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/Model/layer.py

Diff of /branches/WIP-pyshapelib-bramz/Thuban/Model/layer.py

Parent Directory | Revision Log | View Patch Patch

-revision 2339 by silke,
Fri Aug 20 16:59:21 2004 UTC
+revision 2710 by dpinte,
Tue Oct 10 08:31:44 2006 UTC
 Line 1
- # Copyright (c) 2001, 2002, 2003, 2004 by Intevation GmbH
+ # Copyright (c) 2001, 2002, 2003, 2004, 2005 by Intevation GmbH
  # Authors:
  # Bernhard Herzog <[email protected]>
  # Jonathan Coles <[email protected]>
 Line 12 
 __version__ = "$Revision$"
  import os
  import warnings
+ from wxproj import point_in_polygon_shape, shape_centroid
  from Thuban import _
  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \
-Line 22 
 import classification
+Line 24 
 import classification
  from color import Transparent, Black
  from base import TitledObject, Modifiable
  from data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
+ from label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
+      ALIGN_LEFT, ALIGN_RIGHT
  import resource
+ from color import Color
  shapetype_names = {SHAPETYPE_POINT: "Point",
                     SHAPETYPE_ARC: "Arc",
-Line 55 
 class BaseLayer(TitledObject, Modifiable
+Line 60 
 class BaseLayer(TitledObject, Modifiable
          self.issue(LAYER_VISIBILITY_CHANGED, self)
      def HasClassification(self):
-         """Determine if this layer support classifications."""
+         """Determine if this layer supports classifications."""
          return False
      def HasShapes(self):
-Line 67 
 class BaseLayer(TitledObject, Modifiable
+Line 72 
 class BaseLayer(TitledObject, Modifiable
          return self.projection
      def SetProjection(self, projection):
-         """Set the layer's projection"""
+         """Set the layer's projection."""
          self.projection = projection
          self.changed(LAYER_PROJECTION_CHANGED, self)
+     def Type(self):
+         return "Unknown"
  class Layer(BaseLayer):
      """Represent the information of one geodata file (currently a shapefile)
-Line 171 
 class Layer(BaseLayer):
+Line 179 
 class Layer(BaseLayer):
              bbox = self.projection.InverseBBox(bbox)
          return bbox
+     def Type(self):
+         return self.ShapeType();
      def ShapesBoundingBox(self, shapes):
          """Return a bounding box in lat/long coordinates for the given
          list of shape ids.
-Line 230 
 class Layer(BaseLayer):
+Line 241 
 class Layer(BaseLayer):
              # Ensure that region lies within the layer's bounding box
              # Otherwise projection of the region would lead to incorrect
              # values.
-             clipbbox = self.ClipBoundingBox(bbox)
+             clipbbox = self.__mangle_bounding_box(bbox)
              bbox = self.projection.ForwardBBox(clipbbox)
          return self.store.ShapesInRegion(bbox)
-Line 307 
 class Layer(BaseLayer):
+Line 318 
 class Layer(BaseLayer):
          return (_("Layer '%s'") % self.Title(), items)
-     def ClipBoundingBox(self, bbox):
+     def __mangle_bounding_box(self, bbox):
-         """ Clip bbox to layer's bounding box.
+         # FIXME: This method doesn't make much sense.
+         # See RT #2845 which effectively says:
-         Returns that part of bbox that lies within the layers bounding box.
+         #
-         If bbox is completely outside of the layers bounding box, bbox is
+         # If this method, which was originally called ClipBoundingBox,
-         returned.  It is assumed that bbox has sensible values, i.e. bminx
+         # is supposed to do clipping it shouldn't return the parameter
-         < bmaxx and bminy < bmaxy.
+         # unchanged when it lies completely outside of the bounding box.
-         """
+         # It would be better to return None and return an empty list in
+         # ShapesInRegion (the only caller) in that case.
+         #
+         # This method was introduced to fix a bug that IIRC had
+         # something todo with projections and bounding boxes containing
+         # NaN or INF when the parameter to ShapesInRegion covered the
+         # entire earth or something similarly large).
          bminx, bminy, bmaxx, bmaxy = bbox
          lminx, lminy, lmaxx, lmaxy = self.LatLongBoundingBox()
          if bminx > lmaxx or bmaxx < lminx:
-Line 327 
 class Layer(BaseLayer):
+Line 344 
 class Layer(BaseLayer):
          else:
              bottom = max(lminy, bminy)
              top = min(lmaxy, bmaxy)
          return (left, bottom, right, top)
+     def GetLabelPosFromShape(self, cmap, shape_index):
+         '''
+         Return the label position parameters (x, y, halign, valign) from the
+         shape object
+         '''
+         proj = cmap.projection
+         if proj is not None:
+             map_proj = proj
+         else:
+             map_proj = None
+         proj = self.projection
+         if proj is not None:
+             layer_proj = proj
+         else:
+             layer_proj = None
+         shapetype = self.ShapeType()
+         if shapetype == SHAPETYPE_POLYGON:
+             shapefile = self.ShapeStore().Shapefile().cobject()
+             x, y = shape_centroid(shapefile, shape_index,
+                                   map_proj, layer_proj, 1, 1, 0, 0)
+             if map_proj is not None:
+                 x, y = map_proj.Inverse(x, y)
+         else:
+             shape = self.Shape(shape_index)
+             if shapetype == SHAPETYPE_POINT:
+                 x, y = shape.Points()[0][0]
+             else:
+                 # assume SHAPETYPE_ARC
+                 points = shape.Points()[0]
+                 x, y = points[len(points) / 2]
+             if layer_proj is not None:
+                 x, y = layer_proj.Inverse(x, y)
+         if shapetype == SHAPETYPE_POINT:
+             halign = ALIGN_LEFT
+             valign = ALIGN_CENTER
+         elif shapetype == SHAPETYPE_POLYGON:
+             halign = ALIGN_CENTER
+             valign = ALIGN_CENTER
+         elif shapetype == SHAPETYPE_ARC:
+             halign = ALIGN_LEFT
+             valign = ALIGN_CENTER
+         return (x, y, halign, valign)
  if resource.has_gdal_support():
      import gdal
-Line 337 
 if resource.has_gdal_support():
+Line 400 
 if resource.has_gdal_support():
  class RasterLayer(BaseLayer):
-     def __init__(self, title, filename, projection = None, visible = True):
+     MASK_NONE  = 0
+     MASK_BIT   = 1
+     MASK_ALPHA = 2
+     def __init__(self, title, filename, projection = None,
+                  visible = True, opacity = 1, masktype = MASK_BIT):
          """Initialize the Raster Layer.
          title -- title for the layer.
-Line 360 
 class RasterLayer(BaseLayer):
+Line 428 
 class RasterLayer(BaseLayer):
          self.bbox = -1
+         self.mask_type = masktype
+         self.opacity = opacity
+         self.image_info = None
          if resource.has_gdal_support():
              #
              # temporarily open the file so that GDAL can test if it's valid.
-Line 369 
 class RasterLayer(BaseLayer):
+Line 442 
 class RasterLayer(BaseLayer):
              if dataset is None:
                  raise IOError()
+             #
+             # while we have the file, extract some basic information
+             # that we can display later
+             #
+             self.image_info = {}
+             self.image_info["nBands"] = dataset.RasterCount
+             self.image_info["Size"] = (dataset.RasterXSize, dataset.RasterYSize)
+             self.image_info["Driver"] = dataset.GetDriver().ShortName
+             # store some information about the individual bands
+             # [min_value, max_value]
+             a = self.image_info["BandData"] = []
+             for i in range(1, dataset.RasterCount+1):
+                 band = dataset.GetRasterBand(i)
+                 a.append(band.ComputeRasterMinMax())
          self.UnsetModified()
      def BoundingBox(self):
-Line 423 
 class RasterLayer(BaseLayer):
+Line 514 
 class RasterLayer(BaseLayer):
          return bbox
+     def Type(self):
+         return "Image"
      def GetImageFilename(self):
          return self.filename
+     def MaskType(self):
+         """Return True if the mask should be used when rendering the layer."""
+         return self.mask_type
+     def SetMaskType(self, type):
+         """Set the type of mask to use.
+         type can be one of MASK_NONE, MASK_BIT, MASK_ALPHA
+         If the state changes, a LAYER_CHANGED message is sent.
+         """
+         if type not in (self.MASK_NONE, self.MASK_BIT, self.MASK_ALPHA):
+             raise ValueError("type is invalid")
+         if type != self.mask_type:
+             self.mask_type = type
+             self.changed(LAYER_CHANGED, self)
+     def Opacity(self):
+         """Return the level of opacity used in alpha blending.
+         """
+         return self.opacity
+     def SetOpacity(self, op):
+         """Set the level of alpha opacity.
+<= op <= 1.
+         The layer is fully opaque when op = 1.
+         """
+         if not (0 <= op <= 1):
+             raise ValueError("op out of range")
+         if op != self.opacity:
+             self.opacity = op
+             self.changed(LAYER_CHANGED, self)
+     def ImageInfo(self):
+         return self.image_info
      def TreeInfo(self):
          items = []

 Legend:



Removed from v.2339
 


changed lines


 
Added in v.2710
 Legend:



Removed from v.2339
 


changed lines


 
Added in v.2710
-Removed from v.2339
+Added in v.2710

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26