/[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 1158 by jonathan, Thu Jun 12 12:40:11 2003 UTC revision 2228 by bh, Thu Jun 3 15:17:54 2004 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]>
# 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 _
 import shapelib, shptree  
15    
16  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \
17       LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED       LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED, CLASS_CHANGED
18    
19  import classification  import classification
20    
21  from color import Color  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  import resource
26    
27    
 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}  
   
28  shapetype_names = {SHAPETYPE_POINT: "Point",  shapetype_names = {SHAPETYPE_POINT: "Point",
29                     SHAPETYPE_ARC: "Arc",                     SHAPETYPE_ARC: "Arc",
30                     SHAPETYPE_POLYGON: "Polygon"}                     SHAPETYPE_POLYGON: "Polygon"}
# Line 98  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 114  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 124  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 135  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 147  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):
         self.store = store  
         self.shapefile = self.store.Shapefile()  
         self.shapetable = self.store.Table()  
         if hasattr(self.store, "FileName"):  
             self.filename = self.store.FileName()  
         self.table = self.shapetable  
   
         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)  
129          # Set the classification to None if there is a classification          # Set the classification to None if there is a classification
130          # and the new shapestore doesn't have a table with a suitable          # and the new shapestore doesn't have a table with a suitable
131          # column, i.e one with the same name and type as before          # column, i.e one with the same name and type as before
132          # FIXME: Maybe we should keep it the same if the type is          # FIXME: Maybe we should keep it the same if the type is
133          # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT          # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT
134          if self.__classification is not None:          if self.__classification is not None:
135              fieldname = self.__classification.GetField()              columnname = self.classification_column
136              fieldtype = self.__classification.GetFieldType()              columntype = self.GetFieldType(columnname)
137              table = self.store.Table()              table = store.Table()
138              if (fieldname is not None              if (columnname is not None
139                  and (not table.HasColumn(fieldname)                  and (not table.HasColumn(columnname)
140                       or table.Column(fieldname).type != fieldtype)):                       or table.Column(columnname).type != columntype)):
141                  self.SetClassification(None)                  self.SetClassification(None)
142    
143            self.store = store
144    
145          self.changed(LAYER_SHAPESTORE_REPLACED, self)          self.changed(LAYER_SHAPESTORE_REPLACED, self)
146    
147      def ShapeStore(self):      def ShapeStore(self):
# Line 216  class Layer(BaseLayer): Line 149  class Layer(BaseLayer):
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.store = self.shapetree = None              self.__classification.Unsubscribe(CLASS_CHANGED,
154          self.table = self.shapefile = self.shapetable = None                                                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 233  class Layer(BaseLayer): Line 166  class Layer(BaseLayer):
166          Return None, if the layer doesn't contain any shapes.          Return None, if the layer doesn't contain any shapes.
167          """          """
168          bbox = self.BoundingBox()          bbox = self.BoundingBox()
169          if bbox is not None:          if bbox is not None and self.projection is not None:
170              llx, lly, urx, ury = bbox              bbox = self.projection.InverseBBox(bbox)
171              if self.projection is not None:          return bbox
                 llx, lly = self.projection.Inverse(llx, lly)  
                 urx, ury = self.projection.Inverse(urx, ury)  
             return llx, lly, urx, ury  
         else:  
             return None  
172    
173      def ShapesBoundingBox(self, shapes):      def ShapesBoundingBox(self, shapes):
174          """Return a bounding box in lat/long coordinates for the given          """Return a bounding box in lat/long coordinates for the given
# Line 251  class Layer(BaseLayer): Line 179  class Layer(BaseLayer):
179    
180          if shapes is None or len(shapes) == 0: return None          if shapes is None or len(shapes) == 0: return None
181    
182          llx = []          xs = []
183          lly = []          ys = []
         urx = []  
         ury = []  
   
         if self.projection is not None:  
             inverse = lambda x, y: self.projection.Inverse(x, y)  
         else:  
             inverse = lambda x, y: (x, y)  
184    
185          for id in shapes:          for id in shapes:
186              left, bottom, right, top = self.Shape(id).compute_bbox()              bbox = self.Shape(id).compute_bbox()
187                if self.projection is not None:
188              left, bottom = inverse(left, bottom)                  bbox = self.projection.InverseBBox(bbox)
189              right, top   = inverse(right, top)              left, bottom, right, top = bbox
190                xs.append(left); xs.append(right)
191                ys.append(bottom); ys.append(top)
192    
193              llx.append(left)          return (min(xs), min(ys), max(xs), max(ys))
             lly.append(bottom)  
             urx.append(right)  
             ury.append(top)  
194    
         return (min(llx), min(lly), max(urx), max(ury))  
195    
196      def GetFieldType(self, fieldName):      def GetFieldType(self, fieldName):
197          if self.table.HasColumn(fieldName):          if self.store:
198              return self.table.Column(fieldName).type              table = self.store.Table()
199                if table.HasColumn(fieldName):
200                    return table.Column(fieldName).type
201          return None          return None
202    
203        def HasShapes(self):
204            return True
205    
206      def NumShapes(self):      def NumShapes(self):
207          """Return the number of shapes in the layer"""          """Return the number of shapes in the layer"""
208          return self.numshapes          return self.store.NumShapes()
209    
210      def ShapeType(self):      def ShapeType(self):
211          """Return the type of the shapes in the layer.          """Return the type of the shapes in the layer.
212          This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.  
213            The return value is one of the SHAPETYPE_* constants defined in
214            Thuban.Model.data.
215          """          """
216          return self.shapetype          return self.store.ShapeType()
217    
218      def Shape(self, index):      def Shape(self, index):
219          """Return the shape with index index"""          """Return the shape with index index"""
220          shape = self.shapefile.read_object(index)          return self.store.Shape(index)
221    
222          if self.shapetype == SHAPETYPE_POINT:      def ShapesInRegion(self, bbox):
223              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))  
   
         return Shape(points)  
224    
225      def ShapesInRegion(self, box):          The bbox parameter should be the bounding box as a tuple in the
226          """Return the ids of the shapes that overlap the box.          form (minx, miny, maxx, maxy) in unprojected coordinates.
   
         Box is a tuple (left, bottom, right, top) in unprojected coordinates.  
227          """          """
         left, bottom, right, top = box  
   
228          if self.projection is not None:          if self.projection is not None:
229              left,  bottom = self.projection.Forward(left, bottom)              bbox = self.projection.ForwardBBox(bbox)
230              right, top    = self.projection.Forward(right, top)          return self.store.ShapesInRegion(bbox)
231    
232          return self.shapetree.find_shapes((left, bottom), (right, top))      def GetClassificationColumn(self):
233            return self.classification_column
234    
235        def SetClassificationColumn(self, column):
236            """Set the column to classifiy on, or None. If column is not None
237            and the column does not exist in the table, raise a ValueError.
238            """
239            if column:
240                columnType = self.GetFieldType(column)
241                if columnType is None:
242                    raise ValueError()
243            changed = self.classification_column != column
244            self.classification_column = column
245            if changed:
246                self.changed(LAYER_CHANGED, self)
247    
248      def HasClassification(self):      def HasClassification(self):
249          return True          return True
# Line 324  class Layer(BaseLayer): Line 252  class Layer(BaseLayer):
252          return self.__classification          return self.__classification
253    
254      def SetClassification(self, clazz):      def SetClassification(self, clazz):
255          """Set the classification to 'clazz'          """Set the classification used by this layer to 'clazz'
256    
257          If 'clazz' is None a default classification is created          If 'clazz' is None a default classification is created.
         """  
258    
259          # prevent infinite recursion when calling SetLayer()          This issues a LAYER_CHANGED event.
260          if self.__setClassLock: return          """
261    
262          self.__setClassLock = True          if self.__classification is not None:
263                self.__classification.Unsubscribe(CLASS_CHANGED,
264                                                  self._classification_changed)
265    
266          if clazz is None:          if clazz is None:
267              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  
268    
269          self.changed(LAYER_CHANGED, self)          self.__classification = clazz
270            self.__classification.Subscribe(CLASS_CHANGED,
271                                            self._classification_changed)
272    
273          self.__setClassLock = False          self._classification_changed()
274    
275      def ClassChanged(self):      def _classification_changed(self):
276          """Called from the classification object when it has changed."""          """Called from the classification object when it has changed."""
277          self.changed(LAYER_CHANGED, self)          self.changed(LAYER_CHANGED, self)
278    
279      def TreeInfo(self):      def TreeInfo(self):
280          items = []          items = []
281    
282          if hasattr(self, 'filename'):          items.append(_("Filename: %s") % self.ShapeStore().FileName())
             items.append(_("Filename: %s") % self.filename)  
283    
284          if self.Visible():          if self.Visible():
285              items.append(_("Shown"))              items.append(_("Shown"))
# Line 368  class Layer(BaseLayer): Line 289  class Layer(BaseLayer):
289    
290          bbox = self.LatLongBoundingBox()          bbox = self.LatLongBoundingBox()
291          if bbox is not None:          if bbox is not None:
292              items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % bbox)              items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % tuple(bbox))
293          else:          else:
294              items.append(_("Extent (lat-lon):"))              items.append(_("Extent (lat-lon):"))
295          items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])          items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])
# Line 407  class RasterLayer(BaseLayer): Line 328  class RasterLayer(BaseLayer):
328          BaseLayer.__init__(self, title, visible = visible)          BaseLayer.__init__(self, title, visible = visible)
329    
330          self.projection = projection          self.projection = projection
331          self.filename = filename          self.filename = os.path.abspath(filename)
332    
333          self.bbox = -1          self.bbox = -1
334    
# Line 425  class RasterLayer(BaseLayer): Line 346  class RasterLayer(BaseLayer):
346      def BoundingBox(self):      def BoundingBox(self):
347          """Return the layer's bounding box in the intrinsic coordinate system.          """Return the layer's bounding box in the intrinsic coordinate system.
348    
349          If the layer has no shapes, return None.          If the there is no support for images, or the file cannot
350            be read, or there is no geographics information available, return None.
351          """          """
352          if not resource.has_gdal_support():          if not resource.has_gdal_support():
353              return None              return None
# Line 468  class RasterLayer(BaseLayer): Line 390  class RasterLayer(BaseLayer):
390          if bbox is None:          if bbox is None:
391              return None              return None
392    
         llx, lly, urx, ury = bbox  
393          if self.projection is not None:          if self.projection is not None:
394              llx, lly = self.projection.Inverse(llx, lly)              bbox = self.projection.InverseBBox(bbox)
             urx, ury = self.projection.Inverse(urx, ury)  
395    
396          return llx, lly, urx, ury          return bbox
397    
398      def GetImageFilename(self):      def GetImageFilename(self):
399          return self.filename          return self.filename
# Line 481  class RasterLayer(BaseLayer): Line 401  class RasterLayer(BaseLayer):
401      def TreeInfo(self):      def TreeInfo(self):
402          items = []          items = []
403    
404            items.append(_("Filename: %s") % self.GetImageFilename())
405    
406          if self.Visible():          if self.Visible():
407              items.append(_("Shown"))              items.append(_("Shown"))
408          else:          else:
409              items.append(_("Hidden"))              items.append(_("Hidden"))
         items.append(_("Shapes: %d") % self.NumShapes())  
410    
411          bbox = self.LatLongBoundingBox()          bbox = self.LatLongBoundingBox()
412          if bbox is not None:          if bbox is not None:
Legend:
Removed from v.1158  
changed lines
  Added in v.2228
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26