/[thuban]/trunk/thuban/Thuban/Model/layer.py
ViewVC logotype

Diff of /trunk/thuban/Thuban/Model/layer.py

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

revision 929 by jonathan, Tue May 20 15:22:42 2003 UTC revision 1599 by bh, Mon Aug 18 12:45:28 2003 UTC
# Line 8  Line 8 
8    
9  __version__ = "$Revision$"  __version__ = "$Revision$"
10    
11  from math import log, ceil  import os
12    import warnings
13    
14  from Thuban import _  from Thuban import _
15    
 import shapelib, shptree  
   
 import gdal  
 from gdalconst import GA_ReadOnly  
   
16  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \
17       LAYER_CHANGED       LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED, CLASS_CHANGED
   
 from color import Color  
18    
19  import classification  import classification
20    
21    from color import Transparent, Black
22  from base import TitledObject, Modifiable  from base import TitledObject, Modifiable
23    from data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
24    
25    import resource
26    
 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}  
27    
28  shapetype_names = {SHAPETYPE_POINT: "Point",  shapetype_names = {SHAPETYPE_POINT: "Point",
29                     SHAPETYPE_ARC: "Arc",                     SHAPETYPE_ARC: "Arc",
# Line 101  class BaseLayer(TitledObject, Modifiable Line 57  class BaseLayer(TitledObject, Modifiable
57          """Determine if this layer support classifications."""          """Determine if this layer support classifications."""
58          return False          return False
59    
60        def HasShapes(self):
61            """Determine if this layer supports shapes."""
62            return False
63    
64      def GetProjection(self):      def GetProjection(self):
65          """Return the layer's projection."""          """Return the layer's projection."""
66          return self.projection          return self.projection
# Line 117  class Layer(BaseLayer): Line 77  class Layer(BaseLayer):
77      All children of the layer have the same type.      All children of the layer have the same type.
78    
79      A layer has fill and stroke colors. Colors should be instances of      A layer has fill and stroke colors. Colors should be instances of
80      Color. They can also be None, indicating no fill or no stroke.      Color. They can also be Transparent, indicating no fill or no stroke.
81    
82      The layer objects send the following events, all of which have the      The layer objects send the following events, all of which have the
83      layer object as parameter:      layer object as parameter:
# Line 127  class Layer(BaseLayer): Line 87  class Layer(BaseLayer):
87      """      """
88    
89      def __init__(self, title, data, projection = None,      def __init__(self, title, data, projection = None,
90                   fill = Color.Transparent,                   fill = Transparent,
91                   stroke = Color.Black,                   stroke = Black,
92                   lineWidth = 1,                   lineWidth = 1,
93                   visible = True):                   visible = True):
94          """Initialize the layer.          """Initialize the layer.
# Line 138  class Layer(BaseLayer): Line 98  class Layer(BaseLayer):
98          projection -- the projection object. Its Inverse method is          projection -- the projection object. Its Inverse method is
99                 assumed to map the layer's coordinates to lat/long                 assumed to map the layer's coordinates to lat/long
100                 coordinates                 coordinates
101          fill -- the fill color or Color.Transparent if the shapes are          fill -- the fill color or Transparent if the shapes are
102                  not filled                  not filled
103          stroke -- the stroke color or Color.Transparent if the shapes          stroke -- the stroke color or Transparent if the shapes
104                  are not stroked                  are not stroked
105          visible -- boolean. If true the layer is visible.          visible -- boolean. If true the layer is visible.
106    
# Line 150  class Layer(BaseLayer): Line 110  class Layer(BaseLayer):
110                                   visible = visible,                                   visible = visible,
111                                   projection = projection)                                   projection = projection)
112    
         #  
         # this is really important so that when the classification class  
         # tries to set its parent layer the variable will exist  
         #  
113          self.__classification = None          self.__classification = None
114          self.__setClassLock = False          self.store = None
115    
116          self.SetShapeStore(data)          self.SetShapeStore(data)
117    
118            self.classification_column = None
119            self.SetClassificationColumn(None)
120          self.SetClassification(None)          self.SetClassification(None)
121    
122          self.__classification.SetDefaultLineColor(stroke)          self.__classification.SetDefaultLineColor(stroke)
123          self.__classification.SetDefaultLineWidth(lineWidth)          self.__classification.SetDefaultLineWidth(lineWidth)
124          self.__classification.SetDefaultFill(fill)          self.__classification.SetDefaultFill(fill)
         self.__classification.SetLayer(self)  
125    
126          self.UnsetModified()          self.UnsetModified()
127    
128        def __getattr__(self, attr):
129            """Access to some attributes for backwards compatibility
130    
131      def SetShapeStore(self, store):          The attributes implemented here are now held by the shapestore
132          self.store = store          if at all. For backwards compatibility pretend that they are
133          self.shapefile = self.store.Shapefile()          still there but issue a DeprecationWarning when they are
134          self.shapetable = self.store.Table()          accessed.
135          self.filename = self.store.filename          """
136          self.table = self.shapetable          if attr in ("table", "shapetable"):
137                value = self.store.Table()
138          numshapes, shapetype, mins, maxs = self.shapefile.info()          elif attr == "shapefile":
139          self.numshapes = numshapes              value = self.store.Shapefile()
140          self.shapetype = shapelib_shapetypes[shapetype]          elif attr == "filename":
141                value = self.store.FileName()
         # 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  
142          else:          else:
143              maxdepth = int(ceil(log(self.numshapes / 4.0) / log(4)))              raise AttributeError, attr
144            warnings.warn("The Layer attribute %r is deprecated."
145                          " It's value can be accessed through the shapestore"
146                          % attr, DeprecationWarning, stacklevel = 2)
147            return value
148    
149          self.shapetree = shptree.SHPTree(self.shapefile.cobject(), 2,      def SetShapeStore(self, store):
150                                           maxdepth)          # Set the classification to None if there is a classification
151            # and the new shapestore doesn't have a table with a suitable
152            # column, i.e one with the same name and type as before
153            # FIXME: Maybe we should keep it the same if the type is
154            # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT
155          if self.__classification is not None:          if self.__classification is not None:
156              fieldname = self.__classification.GetField()              columnname = self.classification_column
157              if fieldname is not None and \              columntype = self.GetFieldType(columnname)
158                 not self.store.Table().HasColumn(fieldname):              table = store.Table()
159                if (columnname is not None
160                    and (not table.HasColumn(columnname)
161                         or table.Column(columnname).type != columntype)):
162                  self.SetClassification(None)                  self.SetClassification(None)
163          self.changed(LAYER_CHANGED, self)  
164            self.store = store
165    
166            self.changed(LAYER_SHAPESTORE_REPLACED, self)
167    
168      def ShapeStore(self):      def ShapeStore(self):
169          return self.store          return self.store
170    
171      def Destroy(self):      def Destroy(self):
172          BaseLayer.Destroy(self)          BaseLayer.Destroy(self)
173          self.SetClassification(None)          if self.__classification is not None:
174                self.__classification.Unsubscribe(CLASS_CHANGED,
175                                                  self._classification_changed)
176    
177      def BoundingBox(self):      def BoundingBox(self):
178          """Return the layer's bounding box in the intrinsic coordinate system.          """Return the layer's bounding box in the intrinsic coordinate system.
179    
180          If the layer has no shapes, return None.          If the layer has no shapes, return None.
181          """          """
182          return self.bbox          return self.store.BoundingBox()
183    
184      def LatLongBoundingBox(self):      def LatLongBoundingBox(self):
185          """Return the layer's bounding box in lat/long coordinates.          """Return the layer's bounding box in lat/long coordinates.
# Line 267  class Layer(BaseLayer): Line 229  class Layer(BaseLayer):
229          return (min(llx), min(lly), max(urx), max(ury))          return (min(llx), min(lly), max(urx), max(ury))
230    
231      def GetFieldType(self, fieldName):      def GetFieldType(self, fieldName):
232          if self.table.HasColumn(fieldName):          if self.store:
233              return self.table.Column(fieldName).type              table = self.store.Table()
234                if table.HasColumn(fieldName):
235                    return table.Column(fieldName).type
236          return None          return None
237    
238        def HasShapes(self):
239            return True
240    
241      def NumShapes(self):      def NumShapes(self):
242          """Return the number of shapes in the layer"""          """Return the number of shapes in the layer"""
243          return self.numshapes          return self.store.NumShapes()
244    
245      def ShapeType(self):      def ShapeType(self):
246          """Return the type of the shapes in the layer.          """Return the type of the shapes in the layer.
247          This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.  
248            The return value is one of the SHAPETYPE_* constants defined in
249            Thuban.Model.data.
250          """          """
251          return self.shapetype          return self.store.ShapeType()
252    
253      def Shape(self, index):      def Shape(self, index):
254          """Return the shape with index index"""          """Return the shape with index index"""
255          shape = self.shapefile.read_object(index)          return self.store.Shape(index)
   
         if self.shapetype == SHAPETYPE_POINT:  
             points = shape.vertices()  
         else:  
             #for poly in shape.vertices():  
             poly = shape.vertices()[0]  
             points = []  
             for x, y in poly:  
                 points.append((x, y))  
   
         return Shape(points)  
256    
257      def ShapesInRegion(self, box):      def ShapesInRegion(self, bbox):
258          """Return the ids of the shapes that overlap the box.          """Return an iterable over the shapes that overlap the bounding box.
259    
260          Box is a tuple (left, bottom, right, top) in unprojected coordinates.          The bbox parameter should be the bounding box as a tuple in the
261            form (minx, miny, maxx, maxy) in unprojected coordinates.
262          """          """
         left, bottom, right, top = box  
   
263          if self.projection is not None:          if self.projection is not None:
264              left,  bottom = self.projection.Forward(left, bottom)              left, bottom, right, top = bbox
265              right, top    = self.projection.Forward(right, top)              xs = []; ys = []
266                for x, y in [(left, bottom), (left, top), (right, top),
267          return self.shapetree.find_shapes((left, bottom), (right, top))                           (right, bottom)]:
268                    x, y = self.projection.Forward(x, y)
269                    xs.append(x)
270                    ys.append(y)
271                bbox = (min(xs), min(ys), max(xs), max(ys))
272    
273            return self.store.ShapesInRegion(bbox)
274    
275        def GetClassificationColumn(self):
276            return self.classification_column
277    
278        def SetClassificationColumn(self, column):
279            """Set the column to classifiy on, or None. If column is not None
280            and the column does not exist in the table, raise a ValueError.
281            """
282            if column:
283                columnType = self.GetFieldType(column)
284                if columnType is None:
285                    raise ValueError()
286            changed = self.classification_column != column
287            self.classification_column = column
288            if changed:
289                self.changed(LAYER_CHANGED, self)
290    
291      def HasClassification(self):      def HasClassification(self):
292          return True          return True
# Line 316  class Layer(BaseLayer): Line 295  class Layer(BaseLayer):
295          return self.__classification          return self.__classification
296    
297      def SetClassification(self, clazz):      def SetClassification(self, clazz):
298          """Set the classification to 'clazz'          """Set the classification used by this layer to 'clazz'
299    
300          If 'clazz' is None a default classification is created          If 'clazz' is None a default classification is created.
         """  
301    
302          # prevent infinite recursion when calling SetLayer()          This issues a LAYER_CHANGED event.
303          if self.__setClassLock: return          """
304    
305          self.__setClassLock = True          if self.__classification is not None:
306                self.__classification.Unsubscribe(CLASS_CHANGED,
307                                                  self._classification_changed)
308    
309          if clazz is None:          if clazz is None:
310              if self.__classification is not None:              clazz = classification.Classification()
                 self.__classification.SetLayer(None)  
             self.__classification = classification.Classification()  
         else:  
             self.__classification = clazz  
             try:  
                 self.__classification.SetLayer(self)  
             except ValueError:  
                 self.__setClassLock = False  
                 raise ValueError  
311    
312          self.changed(LAYER_CHANGED, self)          self.__classification = clazz
313            self.__classification.Subscribe(CLASS_CHANGED,
314                                            self._classification_changed)
315    
316          self.__setClassLock = False          self._classification_changed()
317    
318      def ClassChanged(self):      def _classification_changed(self):
319          """Called from the classification object when it has changed."""          """Called from the classification object when it has changed."""
320          self.changed(LAYER_CHANGED, self)          self.changed(LAYER_CHANGED, self)
321    
322      def TreeInfo(self):      def TreeInfo(self):
323          items = []          items = []
324    
325            items.append(_("Filename: %s") % self.ShapeStore().FileName())
326    
327          if self.Visible():          if self.Visible():
328              items.append(_("Shown"))              items.append(_("Shown"))
329          else:          else:
# Line 371  class Layer(BaseLayer): Line 346  class Layer(BaseLayer):
346          return (_("Layer '%s'") % self.Title(), items)          return (_("Layer '%s'") % self.Title(), items)
347    
348    
349    if resource.has_gdal_support():
350        import gdal
351        from gdalconst import GA_ReadOnly
352    
353  class RasterLayer(BaseLayer):  class RasterLayer(BaseLayer):
354    
355      def __init__(self, title, filename, projection = None, visible = True):      def __init__(self, title, filename, projection = None, visible = True):
# Line 384  class RasterLayer(BaseLayer): Line 363  class RasterLayer(BaseLayer):
363                        the source image is in.                        the source image is in.
364    
365          visible -- True is the layer should initially be visible.          visible -- True is the layer should initially be visible.
366    
367            Throws IOError if the filename is invalid or points to a file that
368            is not in a format GDAL can use.
369          """          """
370    
371          BaseLayer.__init__(self, title, visible = visible)          BaseLayer.__init__(self, title, visible = visible)
372    
373          self.projection = projection          self.projection = projection
374          self.filename = filename          self.filename = os.path.abspath(filename)
375    
376          self.bbox = -1          self.bbox = -1
377    
378          self.UnsetModified()          if resource.has_gdal_support():
379                #
380                # temporarily open the file so that GDAL can test if it's valid.
381                #
382                dataset = gdal.Open(self.filename, GA_ReadOnly)
383    
384                if dataset is None:
385                    raise IOError()
386    
387            self.UnsetModified()
388    
389      def BoundingBox(self):      def BoundingBox(self):
390          """Return the layer's bounding box in the intrinsic coordinate system.          """Return the layer's bounding box in the intrinsic coordinate system.
391    
392          If the layer has no shapes, return None.          If the there is no support for images, or the file cannot
393            be read, or there is no geographics information available, return None.
394          """          """
395            if not resource.has_gdal_support():
396                return None
397    
398          if self.bbox == -1:          if self.bbox == -1:
399              dataset = gdal.Open(self.filename, GA_ReadOnly)              dataset = gdal.Open(self.filename, GA_ReadOnly)
400              if dataset is None:              if dataset is None:
401                  self.bbox = None                  self.bbox = None
402              else:              else:
403                  left, bottom = self.__CalcCorner(dataset,                  geotransform = dataset.GetGeoTransform()
404                                                   0, dataset.RasterYSize)                  if geotransform is None:
405                  right, top   = self.__CalcCorner(dataset,                      return None
406                                                   dataset.RasterXSize, 0)  
407                    x = 0
408                    y = dataset.RasterYSize
409                    left = geotransform[0] +        \
410                           geotransform[1] * x +    \
411                           geotransform[2] * y
412    
413                    bottom = geotransform[3] +      \
414                             geotransform[4] * x +  \
415                             geotransform[5] * y
416    
417                    x = dataset.RasterXSize
418                    y = 0
419                    right = geotransform[0] +       \
420                            geotransform[1] * x +   \
421                            geotransform[2] * y
422    
423                    top = geotransform[3] +         \
424                          geotransform[4] * x +     \
425                          geotransform[5] * y
426    
427                  self.bbox = (left, bottom, right, top)                  self.bbox = (left, bottom, right, top)
428    
429          return self.bbox          return self.bbox
430    
     def __CalcCorner(self, dataset, x, y):  
         geotransform = dataset.GetGeoTransform()  
         return geotransform[0] + geotransform[1] * x + geotransform[2] * y, \  
                geotransform[3] + geotransform[4] * x + geotransform[5] * y  
   
431      def LatLongBoundingBox(self):      def LatLongBoundingBox(self):
432          bbox = self.BoundingBox()          bbox = self.BoundingBox()
433          if bbox is not None:          if bbox is None:
             llx, lly, urx, ury = bbox  
             if self.projection is not None:  
                 llx, lly = self.projection.Inverse(llx, lly)  
                 urx, ury = self.projection.Inverse(urx, ury)  
             return llx, lly, urx, ury  
         else:  
434              return None              return None
435    
436            llx, lly, urx, ury = bbox
437            if self.projection is not None:
438                llx, lly = self.projection.Inverse(llx, lly)
439                urx, ury = self.projection.Inverse(urx, ury)
440    
441            return llx, lly, urx, ury
442    
443      def GetImageFilename(self):      def GetImageFilename(self):
444          return self.filename          return self.filename
445    
446      def TreeInfo(self):      def TreeInfo(self):
447          items = []          items = []
448    
449            items.append(_("Filename: %s") % self.GetImageFilename())
450    
451          if self.Visible():          if self.Visible():
452              items.append(_("Shown"))              items.append(_("Shown"))
453          else:          else:
454              items.append(_("Hidden"))              items.append(_("Hidden"))
         items.append(_("Shapes: %d") % self.NumShapes())  
455    
456          bbox = self.LatLongBoundingBox()          bbox = self.LatLongBoundingBox()
457          if bbox is not None:          if bbox is not None:
Legend:
Removed from v.929  
changed lines
  Added in v.1599
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26