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

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

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

revision 1338 by jonathan, Tue Jul 1 16:10:00 2003 UTC revision 2562 by jonathan, Wed Feb 16 21:14:47 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]>
5    # Silke Reimer <[email protected]>
6  #  #
7  # This program is free software under the GPL (>=v2)  # This program is free software under the GPL (>=v2)
8  # Read the file COPYING coming with Thuban for details.  # Read the file COPYING coming with Thuban for details.
9    
10  __version__ = "$Revision$"  __version__ = "$Revision$"
11    
12  from math import log, ceil  import os
13  import warnings  import warnings
14    
15  from Thuban import _  from Thuban import _
 import shapelib, shptree  
16    
17  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \
18       LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED       LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED, CLASS_CHANGED
19    
20  import classification  import classification
21    
22  from color import Transparent, Black  from color import Transparent, Black
23  from base import TitledObject, Modifiable  from base import TitledObject, Modifiable
24    from data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
25    
26  import resource  import resource
27    
28    from color import Color
 class Shape:  
   
     """Represent one shape"""  
   
     def __init__(self, points):  
         self.points = points  
         #self.compute_bbox()  
         self.bbox = None  
   
     def compute_bbox(self):  
         if self.bbox is not None:  
             return self.bbox  
   
         xs = []  
         ys = []  
         for x, y in self.points:  
             xs.append(x)  
             ys.append(y)  
         self.llx = min(xs)  
         self.lly = min(ys)  
         self.urx = max(xs)  
         self.ury = max(ys)  
   
         self.bbox = (self.llx, self.lly, self.urx, self.ury)  
   
         return self.bbox  
   
     def Points(self):  
         return self.points  
   
   
   
 # Shape type constants  
 SHAPETYPE_POLYGON = "polygon"  
 SHAPETYPE_ARC = "arc"  
 SHAPETYPE_POINT = "point"  
   
 # mapping from shapelib shapetype constants to our constants  
 shapelib_shapetypes = {shapelib.SHPT_POLYGON: SHAPETYPE_POLYGON,  
                        shapelib.SHPT_ARC: SHAPETYPE_ARC,  
                        shapelib.SHPT_POINT: SHAPETYPE_POINT}  
29    
30  shapetype_names = {SHAPETYPE_POINT: "Point",  shapetype_names = {SHAPETYPE_POINT: "Point",
31                     SHAPETYPE_ARC: "Arc",                     SHAPETYPE_ARC: "Arc",
# Line 96  class BaseLayer(TitledObject, Modifiable Line 56  class BaseLayer(TitledObject, Modifiable
56          self.issue(LAYER_VISIBILITY_CHANGED, self)          self.issue(LAYER_VISIBILITY_CHANGED, self)
57    
58      def HasClassification(self):      def HasClassification(self):
59          """Determine if this layer support classifications."""          """Determine if this layer supports classifications."""
60          return False          return False
61    
62      def HasShapes(self):      def HasShapes(self):
# Line 108  class BaseLayer(TitledObject, Modifiable Line 68  class BaseLayer(TitledObject, Modifiable
68          return self.projection          return self.projection
69    
70      def SetProjection(self, projection):      def SetProjection(self, projection):
71          """Set the layer's projection"""          """Set the layer's projection."""
72          self.projection = projection          self.projection = projection
73          self.changed(LAYER_PROJECTION_CHANGED, self)          self.changed(LAYER_PROJECTION_CHANGED, self)
74    
75        def Type(self):
76            return "Unknown"
77    
78  class Layer(BaseLayer):  class Layer(BaseLayer):
79    
80      """Represent the information of one geodata file (currently a shapefile)      """Represent the information of one geodata file (currently a shapefile)
# Line 152  class Layer(BaseLayer): Line 115  class Layer(BaseLayer):
115                                   visible = visible,                                   visible = visible,
116                                   projection = projection)                                   projection = projection)
117    
         #  
         # this is really important so that when the classification class  
         # tries to set its parent layer the variable will exist  
         #  
118          self.__classification = None          self.__classification = None
119            self.store = None
120    
121          self.SetShapeStore(data)          self.SetShapeStore(data)
122    
123            self.classification_column = None
124            self.SetClassificationColumn(None)
125          self.SetClassification(None)          self.SetClassification(None)
126    
127          self.__classification.SetDefaultLineColor(stroke)          self.__classification.SetDefaultLineColor(stroke)
# Line 168  class Layer(BaseLayer): Line 130  class Layer(BaseLayer):
130    
131          self.UnsetModified()          self.UnsetModified()
132    
     def __getattr__(self, attr):  
         """Access to some attributes for backwards compatibility  
   
         The attributes implemented here are now held by the shapestore  
         if at all. For backwards compatibility pretend that they are  
         still there but issue a DeprecationWarning when they are  
         accessed.  
         """  
         if attr in ("table", "shapetable"):  
             value = self.store.Table()  
         elif attr == "shapefile":  
             value = self.store.Shapefile()  
         elif attr == "filename":  
             value = self.store.FileName()  
         else:  
             raise AttributeError, attr  
         warnings.warn("The Layer attribute %r is deprecated."  
                       " It's value can be accessed through the shapestore"  
                       % attr, DeprecationWarning, stacklevel = 2)  
         return value  
   
133      def SetShapeStore(self, store):      def SetShapeStore(self, store):
         self.store = store  
         shapefile = self.store.Shapefile()  
   
         numshapes, shapetype, mins, maxs = shapefile.info()  
         self.numshapes = numshapes  
         self.shapetype = shapelib_shapetypes[shapetype]  
   
         # if there are shapes, set the bbox accordingly. Otherwise  
         # set it to None.  
         if self.numshapes:  
             self.bbox = mins[:2] + maxs[:2]  
         else:  
             self.bbox = None  
   
         # estimate a good depth for the quad tree. Each depth  
         # multiplies the number of nodes by four, therefore we  
         # basically take the base 4 logarithm of the number of  
         # shapes.  
         if self.numshapes < 4:  
             maxdepth = 1  
         else:  
             maxdepth = int(ceil(log(self.numshapes / 4.0) / log(4)))  
   
         self.shapetree = shptree.SHPTree(shapefile.cobject(), 2,  
                                          maxdepth)  
134          # Set the classification to None if there is a classification          # Set the classification to None if there is a classification
135          # and the new shapestore doesn't have a table with a suitable          # and the new shapestore doesn't have a table with a suitable
136          # column, i.e one with the same name and type as before          # column, i.e one with the same name and type as before
137          # FIXME: Maybe we should keep it the same if the type is          # FIXME: Maybe we should keep it the same if the type is
138          # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT          # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT
139          if self.__classification is not None:          if self.__classification is not None:
140              fieldname = self.__classification.GetField()              columnname = self.classification_column
141              fieldtype = self.__classification.GetFieldType()              columntype = self.GetFieldType(columnname)
142              table = self.store.Table()              table = store.Table()
143              if (fieldname is not None              if (columnname is not None
144                  and (not table.HasColumn(fieldname)                  and (not table.HasColumn(columnname)
145                       or table.Column(fieldname).type != fieldtype)):                       or table.Column(columnname).type != columntype)):
146                  self.SetClassification(None)                  self.SetClassification(None)
147    
148            self.store = store
149    
150          self.changed(LAYER_SHAPESTORE_REPLACED, self)          self.changed(LAYER_SHAPESTORE_REPLACED, self)
151    
152      def ShapeStore(self):      def ShapeStore(self):
# Line 235  class Layer(BaseLayer): Line 154  class Layer(BaseLayer):
154    
155      def Destroy(self):      def Destroy(self):
156          BaseLayer.Destroy(self)          BaseLayer.Destroy(self)
157          self.GetClassification()._set_layer(None)          if self.__classification is not None:
158                self.__classification.Unsubscribe(CLASS_CHANGED,
159                                                  self._classification_changed)
160    
161      def BoundingBox(self):      def BoundingBox(self):
162          """Return the layer's bounding box in the intrinsic coordinate system.          """Return the layer's bounding box in the intrinsic coordinate system.
163    
164          If the layer has no shapes, return None.          If the layer has no shapes, return None.
165          """          """
166          return self.bbox          return self.store.BoundingBox()
167    
168      def LatLongBoundingBox(self):      def LatLongBoundingBox(self):
169          """Return the layer's bounding box in lat/long coordinates.          """Return the layer's bounding box in lat/long coordinates.
# Line 250  class Layer(BaseLayer): Line 171  class Layer(BaseLayer):
171          Return None, if the layer doesn't contain any shapes.          Return None, if the layer doesn't contain any shapes.
172          """          """
173          bbox = self.BoundingBox()          bbox = self.BoundingBox()
174          if bbox is not None:          if bbox is not None and self.projection is not None:
175              llx, lly, urx, ury = bbox              bbox = self.projection.InverseBBox(bbox)
176              if self.projection is not None:          return bbox
177                  llx, lly = self.projection.Inverse(llx, lly)  
178                  urx, ury = self.projection.Inverse(urx, ury)      def Type(self):
179              return llx, lly, urx, ury          return self.ShapeType();
         else:  
             return None  
180    
181      def ShapesBoundingBox(self, shapes):      def ShapesBoundingBox(self, shapes):
182          """Return a bounding box in lat/long coordinates for the given          """Return a bounding box in lat/long coordinates for the given
# Line 268  class Layer(BaseLayer): Line 187  class Layer(BaseLayer):
187    
188          if shapes is None or len(shapes) == 0: return None          if shapes is None or len(shapes) == 0: return None
189    
190          llx = []          xs = []
191          lly = []          ys = []
         urx = []  
         ury = []  
   
         if self.projection is not None:  
             inverse = lambda x, y: self.projection.Inverse(x, y)  
         else:  
             inverse = lambda x, y: (x, y)  
192    
193          for id in shapes:          for id in shapes:
194              left, bottom, right, top = self.Shape(id).compute_bbox()              bbox = self.Shape(id).compute_bbox()
195                if self.projection is not None:
196              left, bottom = inverse(left, bottom)                  bbox = self.projection.InverseBBox(bbox)
197              right, top   = inverse(right, top)              left, bottom, right, top = bbox
198                xs.append(left); xs.append(right)
199                ys.append(bottom); ys.append(top)
200    
201              llx.append(left)          return (min(xs), min(ys), max(xs), max(ys))
             lly.append(bottom)  
             urx.append(right)  
             ury.append(top)  
202    
         return (min(llx), min(lly), max(urx), max(ury))  
203    
204      def GetFieldType(self, fieldName):      def GetFieldType(self, fieldName):
205          table = self.store.Table()          if self.store:
206          if table.HasColumn(fieldName):              table = self.store.Table()
207              return table.Column(fieldName).type              if table.HasColumn(fieldName):
208                    return table.Column(fieldName).type
209          return None          return None
210    
211      def HasShapes(self):      def HasShapes(self):
# Line 302  class Layer(BaseLayer): Line 213  class Layer(BaseLayer):
213    
214      def NumShapes(self):      def NumShapes(self):
215          """Return the number of shapes in the layer"""          """Return the number of shapes in the layer"""
216          return self.numshapes          return self.store.NumShapes()
217    
218      def ShapeType(self):      def ShapeType(self):
219          """Return the type of the shapes in the layer.          """Return the type of the shapes in the layer.
220          This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.  
221            The return value is one of the SHAPETYPE_* constants defined in
222            Thuban.Model.data.
223          """          """
224          return self.shapetype          return self.store.ShapeType()
225    
226      def Shape(self, index):      def Shape(self, index):
227          """Return the shape with index index"""          """Return the shape with index index"""
228          shape = self.store.Shapefile().read_object(index)          return self.store.Shape(index)
229    
230          if self.shapetype == SHAPETYPE_POINT:      def ShapesInRegion(self, bbox):
231              points = shape.vertices()          """Return an iterable over the shapes that overlap the bounding box.
         else:  
             #for poly in shape.vertices():  
             poly = shape.vertices()[0]  
             points = []  
             for x, y in poly:  
                 points.append((x, y))  
   
         return Shape(points)  
   
     def ShapesInRegion(self, box):  
         """Return the ids of the shapes that overlap the box.  
232    
233          Box is a tuple (left, bottom, right, top) in unprojected coordinates.          The bbox parameter should be the bounding box as a tuple in the
234            form (minx, miny, maxx, maxy) in unprojected coordinates.
235          """          """
         left, bottom, right, top = box  
   
236          if self.projection is not None:          if self.projection is not None:
237              left,  bottom = self.projection.Forward(left, bottom)              # Ensure that region lies within the layer's bounding box
238              right, top    = self.projection.Forward(right, top)              # Otherwise projection of the region would lead to incorrect
239                # values.
240          return self.shapetree.find_shapes((left, bottom), (right, top))              clipbbox = self.ClipBoundingBox(bbox)
241                bbox = self.projection.ForwardBBox(clipbbox)
242            return self.store.ShapesInRegion(bbox)
243    
244        def GetClassificationColumn(self):
245            return self.classification_column
246    
247        def SetClassificationColumn(self, column):
248            """Set the column to classifiy on, or None. If column is not None
249            and the column does not exist in the table, raise a ValueError.
250            """
251            if column:
252                columnType = self.GetFieldType(column)
253                if columnType is None:
254                    raise ValueError()
255            changed = self.classification_column != column
256            self.classification_column = column
257            if changed:
258                self.changed(LAYER_CHANGED, self)
259    
260      def HasClassification(self):      def HasClassification(self):
261          return True          return True
# Line 349  class Layer(BaseLayer): Line 268  class Layer(BaseLayer):
268    
269          If 'clazz' is None a default classification is created.          If 'clazz' is None a default classification is created.
270    
271          ValueError is raised if the classification's field name          This issues a LAYER_CHANGED event.
         and type are different (if they aren't None) than what  
         is in the shapestore. The Layer will not be changed in  
         this case.  
272          """          """
273    
274          old_class = self.__classification          if self.__classification is not None:
275                self.__classification.Unsubscribe(CLASS_CHANGED,
276                                                  self._classification_changed)
277    
278          if clazz is None:          if clazz is None:
279              clazz = classification.Classification()              clazz = classification.Classification()
280    
281          try:          self.__classification = clazz
282              clazz._set_layer(self)          self.__classification.Subscribe(CLASS_CHANGED,
283                                            self._classification_changed)
284    
285              # only change things after a successful call          self._classification_changed()
             if old_class is not None:  
                 old_class._set_layer(None)  
             self.__classification = clazz  
         except ValueError:  
             raise ValueError  
   
         # we don't need this since a message will be sent  
         # after calling _set_layer()  
         #self.changed(LAYER_CHANGED, self)  
286    
287      def ClassChanged(self):      def _classification_changed(self):
288          """Called from the classification object when it has changed."""          """Called from the classification object when it has changed."""
289          self.changed(LAYER_CHANGED, self)          self.changed(LAYER_CHANGED, self)
290    
# Line 391  class Layer(BaseLayer): Line 301  class Layer(BaseLayer):
301    
302          bbox = self.LatLongBoundingBox()          bbox = self.LatLongBoundingBox()
303          if bbox is not None:          if bbox is not None:
304              items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % bbox)              items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % tuple(bbox))
305          else:          else:
306              items.append(_("Extent (lat-lon):"))              items.append(_("Extent (lat-lon):"))
307          items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])          items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])
# Line 404  class Layer(BaseLayer): Line 314  class Layer(BaseLayer):
314    
315          return (_("Layer '%s'") % self.Title(), items)          return (_("Layer '%s'") % self.Title(), items)
316    
317        def ClipBoundingBox(self, bbox):
318            """ Clip bbox to layer's bounding box.
319    
320            Returns that part of bbox that lies within the layers bounding box.
321            If bbox is completely outside of the layers bounding box, bbox is
322            returned.  It is assumed that bbox has sensible values, i.e. bminx
323            < bmaxx and bminy < bmaxy.
324            """
325            bminx, bminy, bmaxx, bmaxy = bbox
326            lminx, lminy, lmaxx, lmaxy = self.LatLongBoundingBox()
327            if bminx > lmaxx or bmaxx < lminx:
328                left, right = bminx, bmaxx
329            else:
330                left = max(lminx, bminx)
331                right = min(lmaxx, bmaxx)
332            if bminy > lmaxy or bmaxy < lminy:
333                bottom, top = bminy, bmaxy
334            else:
335                bottom = max(lminy, bminy)
336                top = min(lmaxy, bmaxy)
337            
338            return (left, bottom, right, top)
339    
340    
341  if resource.has_gdal_support():  if resource.has_gdal_support():
342      import gdal      import gdal
# Line 411  if resource.has_gdal_support(): Line 344  if resource.has_gdal_support():
344    
345  class RasterLayer(BaseLayer):  class RasterLayer(BaseLayer):
346    
347        MASK_NONE  = 0
348        MASK_BIT   = 1
349        MASK_ALPHA = 2
350    
351      def __init__(self, title, filename, projection = None, visible = True):      def __init__(self, title, filename, projection = None, visible = True):
352          """Initialize the Raster Layer.          """Initialize the Raster Layer.
353    
# Line 430  class RasterLayer(BaseLayer): Line 367  class RasterLayer(BaseLayer):
367          BaseLayer.__init__(self, title, visible = visible)          BaseLayer.__init__(self, title, visible = visible)
368    
369          self.projection = projection          self.projection = projection
370          self.filename = filename          self.filename = os.path.abspath(filename)
371    
372          self.bbox = -1          self.bbox = -1
373    
374            self.mask_type = self.MASK_BIT
375            self.alpha_opacity = 1
376    
377            self.image_info = None
378    
379          if resource.has_gdal_support():          if resource.has_gdal_support():
380              #              #
381              # temporarily open the file so that GDAL can test if it's valid.              # temporarily open the file so that GDAL can test if it's valid.
# Line 443  class RasterLayer(BaseLayer): Line 385  class RasterLayer(BaseLayer):
385              if dataset is None:              if dataset is None:
386                  raise IOError()                  raise IOError()
387    
388                #
389                # while we have the file, extract some basic information
390                # that we can display later
391                #
392                self.image_info = {}
393    
394                self.image_info["nBands"] = dataset.RasterCount
395                self.image_info["Size"] = (dataset.RasterXSize, dataset.RasterYSize)
396                self.image_info["Driver"] = dataset.GetDriver().ShortName
397    
398                # store some information about the individual bands
399                # [min_value, max_value]
400                a = self.image_info["BandData"] = []
401    
402                for i in range(1, dataset.RasterCount+1):
403                    band = dataset.GetRasterBand(i)
404                    a.append(band.ComputeRasterMinMax())
405    
406          self.UnsetModified()          self.UnsetModified()
407    
408      def BoundingBox(self):      def BoundingBox(self):
# Line 492  class RasterLayer(BaseLayer): Line 452  class RasterLayer(BaseLayer):
452          if bbox is None:          if bbox is None:
453              return None              return None
454    
         llx, lly, urx, ury = bbox  
455          if self.projection is not None:          if self.projection is not None:
456              llx, lly = self.projection.Inverse(llx, lly)              bbox = self.projection.InverseBBox(bbox)
457              urx, ury = self.projection.Inverse(urx, ury)  
458            return bbox
459    
460          return llx, lly, urx, ury      def Type(self):
461            return "Image"
462    
463      def GetImageFilename(self):      def GetImageFilename(self):
464          return self.filename          return self.filename
465    
466        def MaskType(self):
467            """Return True if the mask should be used when rendering the layer."""
468            return self.mask_type
469    
470        def SetMaskType(self, type):
471            """Set the type of mask to use.
472    
473            type can be one of MASK_NONE, MASK_BIT, MASK_ALPHA
474    
475            If the state changes, a LAYER_CHANGED message is sent.
476            """
477            if type not in (self.MASK_NONE, self.MASK_BIT, self.MASK_ALPHA):
478                raise ValueError("type is invalid")
479    
480            if type != self.mask_type:
481                self.mask_type = type
482                self.changed(LAYER_CHANGED, self)
483    
484        def AlphaOpacity(self):
485            """Return the level of opacity used in alpha blending, or None
486            if mask type is not MASK_ALPHA.
487            """
488            if self.mask_type == self.MASK_ALPHA:
489                return self.alpha_opacity
490            else:
491                return None
492    
493        def SetAlphaOpacity(self, op):
494            """Set the level of alpha opacity.
495    
496            0 <= op <= 1.
497    
498            The layer is fully opaque when op = 1.
499            """
500            if not (0 <= op <= 1):
501                raise ValueError("op out of range")
502    
503            self.alpha_opacity = op
504    
505        def ImageInfo(self):
506            return self.image_info
507    
508      def TreeInfo(self):      def TreeInfo(self):
509          items = []          items = []
510    
Legend:
Removed from v.1338  
changed lines
  Added in v.2562
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26