/[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 1978 by bh, Tue Nov 25 14:30:34 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 SetShapeStore(self, store):      def SetShapeStore(self, store):
129          self.store = store          # Set the classification to None if there is a classification
130          self.shapefile = self.store.Shapefile()          # and the new shapestore doesn't have a table with a suitable
131          self.shapetable = self.store.Table()          # column, i.e one with the same name and type as before
132          self.filename = self.store.filename          # FIXME: Maybe we should keep it the same if the type is
133          self.table = self.shapetable          # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT
   
         numshapes, shapetype, mins, maxs = self.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(self.shapefile.cobject(), 2,  
                                          maxdepth)  
134          if self.__classification is not None:          if self.__classification is not None:
135              fieldname = self.__classification.GetField()              columnname = self.classification_column
136              if fieldname is not None and \              columntype = self.GetFieldType(columnname)
137                 not self.store.Table().HasColumn(fieldname):              table = store.Table()
138                if (columnname is not None
139                    and (not table.HasColumn(columnname)
140                         or table.Column(columnname).type != columntype)):
141                  self.SetClassification(None)                  self.SetClassification(None)
142          self.changed(LAYER_CHANGED, self)  
143            self.store = store
144    
145            self.changed(LAYER_SHAPESTORE_REPLACED, self)
146    
147      def ShapeStore(self):      def ShapeStore(self):
148          return self.store          return self.store
149    
150      def Destroy(self):      def Destroy(self):
151          BaseLayer.Destroy(self)          BaseLayer.Destroy(self)
152          self.SetClassification(None)          if self.__classification is not None:
153                self.__classification.Unsubscribe(CLASS_CHANGED,
154                                                  self._classification_changed)
155    
156      def BoundingBox(self):      def BoundingBox(self):
157          """Return the layer's bounding box in the intrinsic coordinate system.          """Return the layer's bounding box in the intrinsic coordinate system.
158    
159          If the layer has no shapes, return None.          If the layer has no shapes, return None.
160          """          """
161          return self.bbox          return self.store.BoundingBox()
162    
163      def LatLongBoundingBox(self):      def LatLongBoundingBox(self):
164          """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 208  class Layer(BaseLayer):
208          return (min(llx), min(lly), max(urx), max(ury))          return (min(llx), min(lly), max(urx), max(ury))
209    
210      def GetFieldType(self, fieldName):      def GetFieldType(self, fieldName):
211          if self.table.HasColumn(fieldName):          if self.store:
212              return self.table.Column(fieldName).type              table = self.store.Table()
213                if table.HasColumn(fieldName):
214                    return table.Column(fieldName).type
215          return None          return None
216    
217        def HasShapes(self):
218            return True
219    
220      def NumShapes(self):      def NumShapes(self):
221          """Return the number of shapes in the layer"""          """Return the number of shapes in the layer"""
222          return self.numshapes          return self.store.NumShapes()
223    
224      def ShapeType(self):      def ShapeType(self):
225          """Return the type of the shapes in the layer.          """Return the type of the shapes in the layer.
226          This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.  
227            The return value is one of the SHAPETYPE_* constants defined in
228            Thuban.Model.data.
229          """          """
230          return self.shapetype          return self.store.ShapeType()
231    
232      def Shape(self, index):      def Shape(self, index):
233          """Return the shape with index index"""          """Return the shape with index index"""
234          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)  
235    
236      def ShapesInRegion(self, box):      def ShapesInRegion(self, bbox):
237          """Return the ids of the shapes that overlap the box.          """Return an iterable over the shapes that overlap the bounding box.
238    
239          Box is a tuple (left, bottom, right, top) in unprojected coordinates.          The bbox parameter should be the bounding box as a tuple in the
240            form (minx, miny, maxx, maxy) in unprojected coordinates.
241          """          """
         left, bottom, right, top = box  
   
242          if self.projection is not None:          if self.projection is not None:
243              left,  bottom = self.projection.Forward(left, bottom)              left, bottom, right, top = bbox
244              right, top    = self.projection.Forward(right, top)              xs = []; ys = []
245                for x, y in [(left, bottom), (left, top), (right, top),
246          return self.shapetree.find_shapes((left, bottom), (right, top))                           (right, bottom)]:
247                    x, y = self.projection.Forward(x, y)
248                    xs.append(x)
249                    ys.append(y)
250                bbox = (min(xs), min(ys), max(xs), max(ys))
251    
252            return self.store.ShapesInRegion(bbox)
253    
254        def GetClassificationColumn(self):
255            return self.classification_column
256    
257        def SetClassificationColumn(self, column):
258            """Set the column to classifiy on, or None. If column is not None
259            and the column does not exist in the table, raise a ValueError.
260            """
261            if column:
262                columnType = self.GetFieldType(column)
263                if columnType is None:
264                    raise ValueError()
265            changed = self.classification_column != column
266            self.classification_column = column
267            if changed:
268                self.changed(LAYER_CHANGED, self)
269    
270      def HasClassification(self):      def HasClassification(self):
271          return True          return True
# Line 316  class Layer(BaseLayer): Line 274  class Layer(BaseLayer):
274          return self.__classification          return self.__classification
275    
276      def SetClassification(self, clazz):      def SetClassification(self, clazz):
277          """Set the classification to 'clazz'          """Set the classification used by this layer to 'clazz'
278    
279          If 'clazz' is None a default classification is created          If 'clazz' is None a default classification is created.
         """  
280    
281          # prevent infinite recursion when calling SetLayer()          This issues a LAYER_CHANGED event.
282          if self.__setClassLock: return          """
283    
284          self.__setClassLock = True          if self.__classification is not None:
285                self.__classification.Unsubscribe(CLASS_CHANGED,
286                                                  self._classification_changed)
287    
288          if clazz is None:          if clazz is None:
289              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  
290    
291          self.changed(LAYER_CHANGED, self)          self.__classification = clazz
292            self.__classification.Subscribe(CLASS_CHANGED,
293                                            self._classification_changed)
294    
295          self.__setClassLock = False          self._classification_changed()
296    
297      def ClassChanged(self):      def _classification_changed(self):
298          """Called from the classification object when it has changed."""          """Called from the classification object when it has changed."""
299          self.changed(LAYER_CHANGED, self)          self.changed(LAYER_CHANGED, self)
300    
301      def TreeInfo(self):      def TreeInfo(self):
302          items = []          items = []
303    
304            items.append(_("Filename: %s") % self.ShapeStore().FileName())
305    
306          if self.Visible():          if self.Visible():
307              items.append(_("Shown"))              items.append(_("Shown"))
308          else:          else:
# Line 371  class Layer(BaseLayer): Line 325  class Layer(BaseLayer):
325          return (_("Layer '%s'") % self.Title(), items)          return (_("Layer '%s'") % self.Title(), items)
326    
327    
328    if resource.has_gdal_support():
329        import gdal
330        from gdalconst import GA_ReadOnly
331    
332  class RasterLayer(BaseLayer):  class RasterLayer(BaseLayer):
333    
334      def __init__(self, title, filename, projection = None, visible = True):      def __init__(self, title, filename, projection = None, visible = True):
# Line 384  class RasterLayer(BaseLayer): Line 342  class RasterLayer(BaseLayer):
342                        the source image is in.                        the source image is in.
343    
344          visible -- True is the layer should initially be visible.          visible -- True is the layer should initially be visible.
345    
346            Throws IOError if the filename is invalid or points to a file that
347            is not in a format GDAL can use.
348          """          """
349    
350          BaseLayer.__init__(self, title, visible = visible)          BaseLayer.__init__(self, title, visible = visible)
351    
352          self.projection = projection          self.projection = projection
353          self.filename = filename          self.filename = os.path.abspath(filename)
354    
355          self.bbox = -1          self.bbox = -1
356    
357          self.UnsetModified()          if resource.has_gdal_support():
358                #
359                # temporarily open the file so that GDAL can test if it's valid.
360                #
361                dataset = gdal.Open(self.filename, GA_ReadOnly)
362    
363                if dataset is None:
364                    raise IOError()
365    
366            self.UnsetModified()
367    
368      def BoundingBox(self):      def BoundingBox(self):
369          """Return the layer's bounding box in the intrinsic coordinate system.          """Return the layer's bounding box in the intrinsic coordinate system.
370    
371          If the layer has no shapes, return None.          If the there is no support for images, or the file cannot
372            be read, or there is no geographics information available, return None.
373          """          """
374            if not resource.has_gdal_support():
375                return None
376    
377          if self.bbox == -1:          if self.bbox == -1:
378              dataset = gdal.Open(self.filename, GA_ReadOnly)              dataset = gdal.Open(self.filename, GA_ReadOnly)
379              if dataset is None:              if dataset is None:
380                  self.bbox = None                  self.bbox = None
381              else:              else:
382                  left, bottom = self.__CalcCorner(dataset,                  geotransform = dataset.GetGeoTransform()
383                                                   0, dataset.RasterYSize)                  if geotransform is None:
384                  right, top   = self.__CalcCorner(dataset,                      return None
385                                                   dataset.RasterXSize, 0)  
386                    x = 0
387                    y = dataset.RasterYSize
388                    left = geotransform[0] +        \
389                           geotransform[1] * x +    \
390                           geotransform[2] * y
391    
392                    bottom = geotransform[3] +      \
393                             geotransform[4] * x +  \
394                             geotransform[5] * y
395    
396                    x = dataset.RasterXSize
397                    y = 0
398                    right = geotransform[0] +       \
399                            geotransform[1] * x +   \
400                            geotransform[2] * y
401    
402                    top = geotransform[3] +         \
403                          geotransform[4] * x +     \
404                          geotransform[5] * y
405    
406                  self.bbox = (left, bottom, right, top)                  self.bbox = (left, bottom, right, top)
407    
408          return self.bbox          return self.bbox
409    
     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  
   
410      def LatLongBoundingBox(self):      def LatLongBoundingBox(self):
411          bbox = self.BoundingBox()          bbox = self.BoundingBox()
412          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:  
413              return None              return None
414    
415            llx, lly, urx, ury = bbox
416            if self.projection is not None:
417                llx, lly = self.projection.Inverse(llx, lly)
418                urx, ury = self.projection.Inverse(urx, ury)
419    
420            return llx, lly, urx, ury
421    
422      def GetImageFilename(self):      def GetImageFilename(self):
423          return self.filename          return self.filename
424    
425      def TreeInfo(self):      def TreeInfo(self):
426          items = []          items = []
427    
428            items.append(_("Filename: %s") % self.GetImageFilename())
429    
430          if self.Visible():          if self.Visible():
431              items.append(_("Shown"))              items.append(_("Shown"))
432          else:          else:
433              items.append(_("Hidden"))              items.append(_("Hidden"))
         items.append(_("Shapes: %d") % self.NumShapes())  
434    
435          bbox = self.LatLongBoundingBox()          bbox = self.LatLongBoundingBox()
436          if bbox is not None:          if bbox is not None:
Legend:
Removed from v.929  
changed lines
  Added in v.1978
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26