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