/[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 701 by bh, Thu Apr 17 16:18:48 2003 UTC revision 2614 by jonathan, Fri May 6 14:16:38 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.
# Line 9  Line 10 
10  __version__ = "$Revision$"  __version__ = "$Revision$"
11    
12  import os  import os
13  from math import log, ceil  import warnings
14    
15  from Thuban import _  from Thuban import _
16    
 import shapelib, shptree  
   
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 table import Table  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  class Shape:  import resource
   
     """Represent one shape"""  
   
     def __init__(self, points):  
         self.points = points  
         #self.compute_bbox()  
   
     def compute_bbox(self):  
         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)  
   
     def Points(self):  
         return self.points  
27    
28    from color import Color
   
 # 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 68  class BaseLayer(TitledObject, Modifiable Line 35  class BaseLayer(TitledObject, Modifiable
35    
36      """Base class for the layers."""      """Base class for the layers."""
37    
38      def __init__(self, title, visible = 1):      def __init__(self, title, visible = True, projection = None):
39          """Initialize the layer.          """Initialize the layer.
40    
41          title -- the title          title -- the title
# Line 77  class BaseLayer(TitledObject, Modifiable Line 44  class BaseLayer(TitledObject, Modifiable
44          TitledObject.__init__(self, title)          TitledObject.__init__(self, title)
45          Modifiable.__init__(self)          Modifiable.__init__(self)
46          self.visible = visible          self.visible = visible
47            self.projection = projection
48    
49      def Visible(self):      def Visible(self):
50          """Return true if layer is visible"""          """Return true if layer is visible"""
# Line 87  class BaseLayer(TitledObject, Modifiable Line 55  class BaseLayer(TitledObject, Modifiable
55          self.visible = visible          self.visible = visible
56          self.issue(LAYER_VISIBILITY_CHANGED, self)          self.issue(LAYER_VISIBILITY_CHANGED, self)
57    
58        def HasClassification(self):
59            """Determine if this layer supports classifications."""
60            return False
61    
62        def HasShapes(self):
63            """Determine if this layer supports shapes."""
64            return False
65    
66        def GetProjection(self):
67            """Return the layer's projection."""
68            return self.projection
69    
70        def SetProjection(self, projection):
71            """Set the layer's projection."""
72            self.projection = projection
73            self.changed(LAYER_PROJECTION_CHANGED, self)
74    
75        def Type(self):
76            return "Unknown"
77    
78  class Layer(BaseLayer):  class Layer(BaseLayer):
79    
# Line 95  class Layer(BaseLayer): Line 82  class Layer(BaseLayer):
82      All children of the layer have the same type.      All children of the layer have the same type.
83    
84      A layer has fill and stroke colors. Colors should be instances of      A layer has fill and stroke colors. Colors should be instances of
85      Color. They can also be None, indicating no fill or no stroke.      Color. They can also be Transparent, indicating no fill or no stroke.
86    
87      The layer objects send the following events, all of which have the      The layer objects send the following events, all of which have the
88      layer object as parameter:      layer object as parameter:
# Line 104  class Layer(BaseLayer): Line 91  class Layer(BaseLayer):
91          LAYER_PROJECTION_CHANGED -- the projection has changed.          LAYER_PROJECTION_CHANGED -- the projection has changed.
92      """      """
93    
94      def __init__(self, title, filename, projection = None,      def __init__(self, title, data, projection = None,
95                   fill = Color.Transparent,                   fill = Transparent,
96                   stroke = Color.Black,                   stroke = Black,
97                   lineWidth = 1,                   lineWidth = 1,
98                   visible = 1):                   visible = True):
99          """Initialize the layer.          """Initialize the layer.
100    
101          title -- the title          title -- the title
102          filename -- the name of the shapefile          data -- datastore object for the shape data shown by the layer
103          projection -- the projection object. Its Inverse method is          projection -- the projection object. Its Inverse method is
104                 assumed to map the layer's coordinates to lat/long                 assumed to map the layer's coordinates to lat/long
105                 coordinates                 coordinates
106          fill -- the fill color or Color.Transparent if the shapes are          fill -- the fill color or Transparent if the shapes are
107                  not filled                  not filled
108          stroke -- the stroke color or Color.Transparent if the shapes          stroke -- the stroke color or Transparent if the shapes
109                  are not stroked                  are not stroked
110          visible -- boolean. If true the layer is visible.          visible -- boolean. If true the layer is visible.
111    
112          colors are expected to be instances of Color class          colors are expected to be instances of Color class
113          """          """
114          BaseLayer.__init__(self, title, visible = visible)          BaseLayer.__init__(self, title,
115                                     visible = visible,
116                                     projection = projection)
117    
118          # Make the filename absolute. The filename will be          self.__classification = None
119          # interpreted relative to that anyway, but when saving a          self.store = None
         # session we need to compare absolute paths and it's usually  
         # safer to always work with absolute paths.  
         self.filename = os.path.abspath(filename)  
   
         self.projection = projection  
         self.shapefile = None  
         self.shapetree = None  
         self.open_shapefile()  
         # shapetable is the table associated with the shapefile, while  
         # table is the default table used to look up attributes for  
         # display  
         self.shapetable = Table(filename)  
         self.table = self.shapetable  
   
         #  
         # this is really important so that when the classification class  
         # tries to set its parent layer the variable will exist  
         #  
         self.__classification = None  
         self.__setClassLock = False  
120    
121            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)
128          self.__classification.SetDefaultLineWidth(lineWidth)          self.__classification.SetDefaultLineWidth(lineWidth)
129          self.__classification.SetDefaultFill(fill)          self.__classification.SetDefaultFill(fill)
         self.__classification.SetLayer(self)  
130    
131          self.UnsetModified()          self.UnsetModified()
132    
133      def open_shapefile(self):      def SetShapeStore(self, store):
134          if self.shapefile is None:          # Set the classification to None if there is a classification
135              self.shapefile = shapelib.ShapeFile(self.filename)          # and the new shapestore doesn't have a table with a suitable
136              numshapes, shapetype, mins, maxs = self.shapefile.info()          # column, i.e one with the same name and type as before
137              self.numshapes = numshapes          # FIXME: Maybe we should keep it the same if the type is
138              self.shapetype = shapelib_shapetypes[shapetype]          # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT
139            if self.__classification is not None:
140              # if there are shapes, set the bbox accordinly. Otherwise              columnname = self.classification_column
141              # set it to None.              columntype = self.GetFieldType(columnname)
142              if self.numshapes:              table = store.Table()
143                  self.bbox = mins[:2] + maxs[:2]              if (columnname is not None
144              else:                  and (not table.HasColumn(columnname)
145                  self.bbox = None                       or table.Column(columnname).type != columntype)):
146                    self.SetClassification(None)
147    
148              # estimate a good depth for the quad tree. Each depth          self.store = store
149              # multiplies the number of nodes by four, therefore we  
150              # basically take the base 4 logarithm of the number of          self.changed(LAYER_SHAPESTORE_REPLACED, self)
             # shapes.  
             if self.numshapes < 4:  
                 maxdepth = 1  
             else:  
                 maxdepth = int(ceil(log(self.numshapes / 4.0) / log(4)))  
151    
152              self.shapetree = shptree.SHPTree(self.shapefile.cobject(), 2,      def ShapeStore(self):
153                                               maxdepth)          return self.store
154    
155      def Destroy(self):      def Destroy(self):
156          BaseLayer.Destroy(self)          BaseLayer.Destroy(self)
157          if self.shapefile is not None:          if self.__classification is not None:
158              self.shapefile.close()              self.__classification.Unsubscribe(CLASS_CHANGED,
159              self.shapefile = None                                                self._classification_changed)
             self.shapetree = None  
         self.SetClassification(None)  
         self.table.Destroy()  
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 207  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            return bbox
177    
178        def Type(self):
179            return self.ShapeType();
180    
181        def ShapesBoundingBox(self, shapes):
182            """Return a bounding box in lat/long coordinates for the given
183            list of shape ids.
184    
185            If shapes is None or empty, return None.
186            """
187    
188            if shapes is None or len(shapes) == 0: return None
189    
190            xs = []
191            ys = []
192    
193            for id in shapes:
194                bbox = self.Shape(id).compute_bbox()
195              if self.projection is not None:              if self.projection is not None:
196                  llx, lly = self.projection.Inverse(llx, lly)                  bbox = self.projection.InverseBBox(bbox)
197                  urx, ury = self.projection.Inverse(urx, ury)              left, bottom, right, top = bbox
198              return llx, lly, urx, ury              xs.append(left); xs.append(right)
199          else:              ys.append(bottom); ys.append(top)
200              return None  
201            return (min(xs), min(ys), max(xs), max(ys))
202    
203    
204      def GetFieldType(self, fieldName):      def GetFieldType(self, fieldName):
205          info = self.table.field_info_by_name(fieldName)          if self.store:
206          if info is not None:              table = self.store.Table()
207              return info[0]              if table.HasColumn(fieldName):
208          else:                  return table.Column(fieldName).type
209              return None          return None
210    
211        def HasShapes(self):
212            return True
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.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)  
229    
230      def ShapesInRegion(self, box):      def ShapesInRegion(self, bbox):
231          """Return the ids of the shapes that overlap the box.          """Return an iterable over the shapes that overlap the bounding box.
232    
233          Box is a tuple (left, bottom, right, top) in the coordinate          The bbox parameter should be the bounding box as a tuple in the
234          system used by the layer's shapefile.          form (minx, miny, maxx, maxy) in unprojected coordinates.
235            """
236            if self.projection is not None:
237                # Ensure that region lies within the layer's bounding box
238                # Otherwise projection of the region would lead to incorrect
239                # values.
240                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          left, bottom, right, top = box          if column:
252          return self.shapetree.find_shapes((left, bottom), (right, top))              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 SetProjection(self, projection):      def HasClassification(self):
261          """Set the layer's projection"""          return True
         self.projection = projection  
         self.changed(LAYER_PROJECTION_CHANGED, self)  
262    
263      def GetClassification(self):      def GetClassification(self):
264          return self.__classification          return self.__classification
265    
266      def SetClassification(self, clazz):      def SetClassification(self, clazz):
267          """Set the classification to 'clazz'          """Set the classification used by this layer to 'clazz'
268    
269          If 'clazz' is None a default classification is created          If 'clazz' is None a default classification is created.
         """  
270    
271          # prevent infinite recursion when calling SetLayer()          This issues a LAYER_CHANGED event.
272          if self.__setClassLock: return          """
273    
274          self.__setClassLock = True          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              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  
280    
281          self.changed(LAYER_CHANGED, self)          self.__classification = clazz
282            self.__classification.Subscribe(CLASS_CHANGED,
283                                            self._classification_changed)
284    
285          self.__setClassLock = False          self._classification_changed()
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    
291      def TreeInfo(self):      def TreeInfo(self):
292          items = []          items = []
293    
294            items.append(_("Filename: %s") % self.ShapeStore().FileName())
295    
296          if self.Visible():          if self.Visible():
297              items.append(_("Shown"))              items.append(_("Shown"))
298          else:          else:
# Line 307  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()])
308    
309            if self.projection and len(self.projection.params) > 0:
310                items.append((_("Projection"),
311                            [str(param) for param in self.projection.params]))
312    
313          items.append(self.__classification)          items.append(self.__classification)
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():
342        import gdal
343        from gdalconst import GA_ReadOnly
344    
345    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,
352                     visible = True, opacity = 1, masktype = MASK_BIT):
353            """Initialize the Raster Layer.
354    
355            title -- title for the layer.
356    
357            filename -- file name of the source image.
358    
359            projection -- Projection object describing the projection which
360                          the source image is in.
361    
362            visible -- True is the layer should initially be visible.
363    
364            Throws IOError if the filename is invalid or points to a file that
365            is not in a format GDAL can use.
366            """
367    
368            BaseLayer.__init__(self, title, visible = visible)
369    
370            self.projection = projection
371            self.filename = os.path.abspath(filename)
372    
373            self.bbox = -1
374    
375            self.mask_type = masktype
376            self.opacity = opacity
377    
378            self.image_info = None
379    
380            if resource.has_gdal_support():
381                #
382                # temporarily open the file so that GDAL can test if it's valid.
383                #
384                dataset = gdal.Open(self.filename, GA_ReadOnly)
385    
386                if dataset is None:
387                    raise IOError()
388    
389                #
390                # while we have the file, extract some basic information
391                # that we can display later
392                #
393                self.image_info = {}
394    
395                self.image_info["nBands"] = dataset.RasterCount
396                self.image_info["Size"] = (dataset.RasterXSize, dataset.RasterYSize)
397                self.image_info["Driver"] = dataset.GetDriver().ShortName
398    
399                # store some information about the individual bands
400                # [min_value, max_value]
401                a = self.image_info["BandData"] = []
402    
403                for i in range(1, dataset.RasterCount+1):
404                    band = dataset.GetRasterBand(i)
405                    a.append(band.ComputeRasterMinMax())
406    
407            self.UnsetModified()
408    
409        def BoundingBox(self):
410            """Return the layer's bounding box in the intrinsic coordinate system.
411    
412            If the there is no support for images, or the file cannot
413            be read, or there is no geographics information available, return None.
414            """
415            if not resource.has_gdal_support():
416                return None
417    
418            if self.bbox == -1:
419                dataset = gdal.Open(self.filename, GA_ReadOnly)
420                if dataset is None:
421                    self.bbox = None
422                else:
423                    geotransform = dataset.GetGeoTransform()
424                    if geotransform is None:
425                        return None
426    
427                    x = 0
428                    y = dataset.RasterYSize
429                    left = geotransform[0] +        \
430                           geotransform[1] * x +    \
431                           geotransform[2] * y
432    
433                    bottom = geotransform[3] +      \
434                             geotransform[4] * x +  \
435                             geotransform[5] * y
436    
437                    x = dataset.RasterXSize
438                    y = 0
439                    right = geotransform[0] +       \
440                            geotransform[1] * x +   \
441                            geotransform[2] * y
442    
443                    top = geotransform[3] +         \
444                          geotransform[4] * x +     \
445                          geotransform[5] * y
446    
447                    self.bbox = (left, bottom, right, top)
448    
449            return self.bbox
450    
451        def LatLongBoundingBox(self):
452            bbox = self.BoundingBox()
453            if bbox is None:
454                return None
455    
456            if self.projection is not None:
457                bbox = self.projection.InverseBBox(bbox)
458    
459            return bbox
460    
461        def Type(self):
462            return "Image"
463    
464        def GetImageFilename(self):
465            return self.filename
466    
467        def MaskType(self):
468            """Return True if the mask should be used when rendering the layer."""
469            return self.mask_type
470    
471        def SetMaskType(self, type):
472            """Set the type of mask to use.
473    
474            type can be one of MASK_NONE, MASK_BIT, MASK_ALPHA
475    
476            If the state changes, a LAYER_CHANGED message is sent.
477            """
478            if type not in (self.MASK_NONE, self.MASK_BIT, self.MASK_ALPHA):
479                raise ValueError("type is invalid")
480    
481            if type != self.mask_type:
482                self.mask_type = type
483                self.changed(LAYER_CHANGED, self)
484    
485        def Opacity(self):
486            """Return the level of opacity used in alpha blending.
487            """
488            return self.opacity
489    
490        def SetOpacity(self, op):
491            """Set the level of alpha opacity.
492    
493            0 <= op <= 1.
494    
495            The layer is fully opaque when op = 1.
496            """
497            if not (0 <= op <= 1):
498                raise ValueError("op out of range")
499    
500            if op != self.opacity:
501                self.opacity = op
502                self.changed(LAYER_CHANGED, self)
503    
504        def ImageInfo(self):
505            return self.image_info
506    
507        def TreeInfo(self):
508            items = []
509    
510            items.append(_("Filename: %s") % self.GetImageFilename())
511    
512            if self.Visible():
513                items.append(_("Shown"))
514            else:
515                items.append(_("Hidden"))
516    
517            bbox = self.LatLongBoundingBox()
518            if bbox is not None:
519                items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % bbox)
520            else:
521                items.append(_("Extent (lat-lon):"))
522    
523            if self.projection and len(self.projection.params) > 0:
524                items.append((_("Projection"),
525                            [str(param) for param in self.projection.params]))
526    
527            return (_("Layer '%s'") % self.Title(), items)
528    
Legend:
Removed from v.701  
changed lines
  Added in v.2614
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26