/[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 1452 by bh, Fri Jul 18 12:57:59 2003 UTC
# Line 9  Line 9 
9  __version__ = "$Revision$"  __version__ = "$Revision$"
10    
11  from math import log, ceil  from math import log, ceil
12    import warnings
13    
14  from Thuban import _  from Thuban import _
   
15  import shapelib, shptree  import shapelib, shptree
16    
 import gdal  
 from gdalconst import GA_ReadOnly  
   
17  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \
18       LAYER_CHANGED       LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED, CLASS_CHANGED
   
 from color import Color  
19    
20  import classification  import classification
21    
22    from color import Transparent, Black
23  from base import TitledObject, Modifiable  from base import TitledObject, Modifiable
24    
25    import resource
26    
27    
28  class Shape:  class Shape:
29    
# Line 101  class BaseLayer(TitledObject, Modifiable Line 99  class BaseLayer(TitledObject, Modifiable
99          """Determine if this layer support classifications."""          """Determine if this layer support classifications."""
100          return False          return False
101    
102        def HasShapes(self):
103            """Determine if this layer supports shapes."""
104            return False
105    
106      def GetProjection(self):      def GetProjection(self):
107          """Return the layer's projection."""          """Return the layer's projection."""
108          return self.projection          return self.projection
# Line 117  class Layer(BaseLayer): Line 119  class Layer(BaseLayer):
119      All children of the layer have the same type.      All children of the layer have the same type.
120    
121      A layer has fill and stroke colors. Colors should be instances of      A layer has fill and stroke colors. Colors should be instances of
122      Color. They can also be None, indicating no fill or no stroke.      Color. They can also be Transparent, indicating no fill or no stroke.
123    
124      The layer objects send the following events, all of which have the      The layer objects send the following events, all of which have the
125      layer object as parameter:      layer object as parameter:
# Line 127  class Layer(BaseLayer): Line 129  class Layer(BaseLayer):
129      """      """
130    
131      def __init__(self, title, data, projection = None,      def __init__(self, title, data, projection = None,
132                   fill = Color.Transparent,                   fill = Transparent,
133                   stroke = Color.Black,                   stroke = Black,
134                   lineWidth = 1,                   lineWidth = 1,
135                   visible = True):                   visible = True):
136          """Initialize the layer.          """Initialize the layer.
# Line 138  class Layer(BaseLayer): Line 140  class Layer(BaseLayer):
140          projection -- the projection object. Its Inverse method is          projection -- the projection object. Its Inverse method is
141                 assumed to map the layer's coordinates to lat/long                 assumed to map the layer's coordinates to lat/long
142                 coordinates                 coordinates
143          fill -- the fill color or Color.Transparent if the shapes are          fill -- the fill color or Transparent if the shapes are
144                  not filled                  not filled
145          stroke -- the stroke color or Color.Transparent if the shapes          stroke -- the stroke color or Transparent if the shapes
146                  are not stroked                  are not stroked
147          visible -- boolean. If true the layer is visible.          visible -- boolean. If true the layer is visible.
148    
# Line 150  class Layer(BaseLayer): Line 152  class Layer(BaseLayer):
152                                   visible = visible,                                   visible = visible,
153                                   projection = projection)                                   projection = projection)
154    
         #  
         # this is really important so that when the classification class  
         # tries to set its parent layer the variable will exist  
         #  
155          self.__classification = None          self.__classification = None
156          self.__setClassLock = False          self.store = None
157    
158          self.SetShapeStore(data)          self.SetShapeStore(data)
159    
160            self.classification_column = None
161            self.SetClassificationColumn(None)
162          self.SetClassification(None)          self.SetClassification(None)
163    
164          self.__classification.SetDefaultLineColor(stroke)          self.__classification.SetDefaultLineColor(stroke)
165          self.__classification.SetDefaultLineWidth(lineWidth)          self.__classification.SetDefaultLineWidth(lineWidth)
166          self.__classification.SetDefaultFill(fill)          self.__classification.SetDefaultFill(fill)
         self.__classification.SetLayer(self)  
167    
168          self.UnsetModified()          self.UnsetModified()
169    
170        def __getattr__(self, attr):
171            """Access to some attributes for backwards compatibility
172    
173            The attributes implemented here are now held by the shapestore
174            if at all. For backwards compatibility pretend that they are
175            still there but issue a DeprecationWarning when they are
176            accessed.
177            """
178            if attr in ("table", "shapetable"):
179                value = self.store.Table()
180            elif attr == "shapefile":
181                value = self.store.Shapefile()
182            elif attr == "filename":
183                value = self.store.FileName()
184            else:
185                raise AttributeError, attr
186            warnings.warn("The Layer attribute %r is deprecated."
187                          " It's value can be accessed through the shapestore"
188                          % attr, DeprecationWarning, stacklevel = 2)
189            return value
190    
191      def SetShapeStore(self, store):      def SetShapeStore(self, store):
192            # Set the classification to None if there is a classification
193            # and the new shapestore doesn't have a table with a suitable
194            # column, i.e one with the same name and type as before
195            # FIXME: Maybe we should keep it the same if the type is
196            # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT
197            if self.__classification is not None:
198                columnname = self.classification_column
199                columntype = self.GetFieldType(columnname)
200                table = store.Table()
201                if (columnname is not None
202                    and (not table.HasColumn(columnname)
203                         or table.Column(columnname).type != columntype)):
204                    self.SetClassification(None)
205    
206          self.store = store          self.store = store
207          self.shapefile = self.store.Shapefile()          shapefile = self.store.Shapefile()
         self.shapetable = self.store.Table()  
         self.filename = self.store.filename  
         self.table = self.shapetable  
208    
209          numshapes, shapetype, mins, maxs = self.shapefile.info()          numshapes, shapetype, mins, maxs = shapefile.info()
210          self.numshapes = numshapes          self.numshapes = numshapes
211          self.shapetype = shapelib_shapetypes[shapetype]          self.shapetype = shapelib_shapetypes[shapetype]
212    
# Line 196  class Layer(BaseLayer): Line 226  class Layer(BaseLayer):
226          else:          else:
227              maxdepth = int(ceil(log(self.numshapes / 4.0) / log(4)))              maxdepth = int(ceil(log(self.numshapes / 4.0) / log(4)))
228    
229          self.shapetree = shptree.SHPTree(self.shapefile.cobject(), 2,          self.shapetree = shptree.SHPTree(shapefile.cobject(), 2,
230                                           maxdepth)                                           maxdepth)
231          if self.__classification is not None:          self.changed(LAYER_SHAPESTORE_REPLACED, self)
             fieldname = self.__classification.GetField()  
             if fieldname is not None and \  
                not self.store.Table().HasColumn(fieldname):  
                 self.SetClassification(None)  
         self.changed(LAYER_CHANGED, self)  
232    
233      def ShapeStore(self):      def ShapeStore(self):
234          return self.store          return self.store
235    
236      def Destroy(self):      def Destroy(self):
237          BaseLayer.Destroy(self)          BaseLayer.Destroy(self)
238          self.SetClassification(None)          if self.__classification is not None:
239                self.__classification.Unsubscribe(CLASS_CHANGED,
240                                                  self._classification_changed)
241    
242      def BoundingBox(self):      def BoundingBox(self):
243          """Return the layer's bounding box in the intrinsic coordinate system.          """Return the layer's bounding box in the intrinsic coordinate system.
# Line 267  class Layer(BaseLayer): Line 294  class Layer(BaseLayer):
294          return (min(llx), min(lly), max(urx), max(ury))          return (min(llx), min(lly), max(urx), max(ury))
295    
296      def GetFieldType(self, fieldName):      def GetFieldType(self, fieldName):
297          if self.table.HasColumn(fieldName):          if self.store:
298              return self.table.Column(fieldName).type              table = self.store.Table()
299                if table.HasColumn(fieldName):
300                    return table.Column(fieldName).type
301          return None          return None
302    
303        def HasShapes(self):
304            return True
305    
306      def NumShapes(self):      def NumShapes(self):
307          """Return the number of shapes in the layer"""          """Return the number of shapes in the layer"""
308          return self.numshapes          return self.numshapes
# Line 283  class Layer(BaseLayer): Line 315  class Layer(BaseLayer):
315    
316      def Shape(self, index):      def Shape(self, index):
317          """Return the shape with index index"""          """Return the shape with index index"""
318          shape = self.shapefile.read_object(index)          shape = self.store.Shapefile().read_object(index)
319    
320          if self.shapetype == SHAPETYPE_POINT:          if self.shapetype == SHAPETYPE_POINT:
321              points = shape.vertices()              points = shape.vertices()
# Line 309  class Layer(BaseLayer): Line 341  class Layer(BaseLayer):
341    
342          return self.shapetree.find_shapes((left, bottom), (right, top))          return self.shapetree.find_shapes((left, bottom), (right, top))
343    
344        def GetClassificationColumn(self):
345            return self.classification_column
346    
347        def SetClassificationColumn(self, column):
348            """Set the column to classifiy on, or None. If column is not None
349            and the column does not exist in the table, raise a ValueError.
350            """
351            if column:
352                columnType = self.GetFieldType(column)
353                if columnType is None:
354                    raise ValueError()
355            changed = self.classification_column != column
356            self.classification_column = column
357            if changed:
358                self.changed(LAYER_CHANGED, self)
359    
360      def HasClassification(self):      def HasClassification(self):
361          return True          return True
362    
# Line 316  class Layer(BaseLayer): Line 364  class Layer(BaseLayer):
364          return self.__classification          return self.__classification
365    
366      def SetClassification(self, clazz):      def SetClassification(self, clazz):
367          """Set the classification to 'clazz'          """Set the classification used by this layer to 'clazz'
368    
369          If 'clazz' is None a default classification is created          If 'clazz' is None a default classification is created.
         """  
370    
371          # prevent infinite recursion when calling SetLayer()          This issues a LAYER_CHANGED event.
372          if self.__setClassLock: return          """
373    
374          self.__setClassLock = True          if self.__classification is not None:
375                self.__classification.Unsubscribe(CLASS_CHANGED,
376                                                  self._classification_changed)
377    
378          if clazz is None:          if clazz is None:
379              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  
380    
381          self.changed(LAYER_CHANGED, self)          self.__classification = clazz
382            self.__classification.Subscribe(CLASS_CHANGED,
383                                            self._classification_changed)
384    
385          self.__setClassLock = False          self._classification_changed()
386    
387      def ClassChanged(self):      def _classification_changed(self):
388          """Called from the classification object when it has changed."""          """Called from the classification object when it has changed."""
389          self.changed(LAYER_CHANGED, self)          self.changed(LAYER_CHANGED, self)
390    
391      def TreeInfo(self):      def TreeInfo(self):
392          items = []          items = []
393    
394            items.append(_("Filename: %s") % self.ShapeStore().FileName())
395    
396          if self.Visible():          if self.Visible():
397              items.append(_("Shown"))              items.append(_("Shown"))
398          else:          else:
# Line 371  class Layer(BaseLayer): Line 415  class Layer(BaseLayer):
415          return (_("Layer '%s'") % self.Title(), items)          return (_("Layer '%s'") % self.Title(), items)
416    
417    
418    if resource.has_gdal_support():
419        import gdal
420        from gdalconst import GA_ReadOnly
421    
422  class RasterLayer(BaseLayer):  class RasterLayer(BaseLayer):
423    
424      def __init__(self, title, filename, projection = None, visible = True):      def __init__(self, title, filename, projection = None, visible = True):
# Line 384  class RasterLayer(BaseLayer): Line 432  class RasterLayer(BaseLayer):
432                        the source image is in.                        the source image is in.
433    
434          visible -- True is the layer should initially be visible.          visible -- True is the layer should initially be visible.
435    
436            Throws IOError if the filename is invalid or points to a file that
437            is not in a format GDAL can use.
438          """          """
439    
440          BaseLayer.__init__(self, title, visible = visible)          BaseLayer.__init__(self, title, visible = visible)
# Line 393  class RasterLayer(BaseLayer): Line 444  class RasterLayer(BaseLayer):
444    
445          self.bbox = -1          self.bbox = -1
446    
447          self.UnsetModified()          if resource.has_gdal_support():
448                #
449                # temporarily open the file so that GDAL can test if it's valid.
450                #
451                dataset = gdal.Open(self.filename, GA_ReadOnly)
452    
453                if dataset is None:
454                    raise IOError()
455    
456            self.UnsetModified()
457    
458      def BoundingBox(self):      def BoundingBox(self):
459          """Return the layer's bounding box in the intrinsic coordinate system.          """Return the layer's bounding box in the intrinsic coordinate system.
460    
461          If the layer has no shapes, return None.          If the there is no support for images, or the file cannot
462            be read, or there is no geographics information available, return None.
463          """          """
464            if not resource.has_gdal_support():
465                return None
466    
467          if self.bbox == -1:          if self.bbox == -1:
468              dataset = gdal.Open(self.filename, GA_ReadOnly)              dataset = gdal.Open(self.filename, GA_ReadOnly)
469              if dataset is None:              if dataset is None:
470                  self.bbox = None                  self.bbox = None
471              else:              else:
472                  left, bottom = self.__CalcCorner(dataset,                  geotransform = dataset.GetGeoTransform()
473                                                   0, dataset.RasterYSize)                  if geotransform is None:
474                  right, top   = self.__CalcCorner(dataset,                      return None
475                                                   dataset.RasterXSize, 0)  
476                    x = 0
477                    y = dataset.RasterYSize
478                    left = geotransform[0] +        \
479                           geotransform[1] * x +    \
480                           geotransform[2] * y
481    
482                    bottom = geotransform[3] +      \
483                             geotransform[4] * x +  \
484                             geotransform[5] * y
485    
486                    x = dataset.RasterXSize
487                    y = 0
488                    right = geotransform[0] +       \
489                            geotransform[1] * x +   \
490                            geotransform[2] * y
491    
492                    top = geotransform[3] +         \
493                          geotransform[4] * x +     \
494                          geotransform[5] * y
495    
496                  self.bbox = (left, bottom, right, top)                  self.bbox = (left, bottom, right, top)
497    
498          return self.bbox          return self.bbox
499    
     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  
   
500      def LatLongBoundingBox(self):      def LatLongBoundingBox(self):
501          bbox = self.BoundingBox()          bbox = self.BoundingBox()
502          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:  
503              return None              return None
504    
505            llx, lly, urx, ury = bbox
506            if self.projection is not None:
507                llx, lly = self.projection.Inverse(llx, lly)
508                urx, ury = self.projection.Inverse(urx, ury)
509    
510            return llx, lly, urx, ury
511    
512      def GetImageFilename(self):      def GetImageFilename(self):
513          return self.filename          return self.filename
514    
515      def TreeInfo(self):      def TreeInfo(self):
516          items = []          items = []
517    
518            items.append(_("Filename: %s") % self.GetImageFilename())
519    
520          if self.Visible():          if self.Visible():
521              items.append(_("Shown"))              items.append(_("Shown"))
522          else:          else:
523              items.append(_("Hidden"))              items.append(_("Hidden"))
         items.append(_("Shapes: %d") % self.NumShapes())  
524    
525          bbox = self.LatLongBoundingBox()          bbox = self.LatLongBoundingBox()
526          if bbox is not None:          if bbox is not None:
Legend:
Removed from v.929  
changed lines
  Added in v.1452
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26