/[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 1338 by jonathan, Tue Jul 1 16:10:00 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  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 Transparent, Black  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 152  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.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)
# Line 168  class Layer(BaseLayer): Line 125  class Layer(BaseLayer):
125    
126          self.UnsetModified()          self.UnsetModified()
127    
     def __getattr__(self, attr):  
         """Access to some attributes for backwards compatibility  
   
         The attributes implemented here are now held by the shapestore  
         if at all. For backwards compatibility pretend that they are  
         still there but issue a DeprecationWarning when they are  
         accessed.  
         """  
         if attr in ("table", "shapetable"):  
             value = self.store.Table()  
         elif attr == "shapefile":  
             value = self.store.Shapefile()  
         elif attr == "filename":  
             value = self.store.FileName()  
         else:  
             raise AttributeError, attr  
         warnings.warn("The Layer attribute %r is deprecated."  
                       " It's value can be accessed through the shapestore"  
                       % attr, DeprecationWarning, stacklevel = 2)  
         return value  
   
128      def SetShapeStore(self, store):      def SetShapeStore(self, store):
         self.store = store  
         shapefile = self.store.Shapefile()  
   
         numshapes, shapetype, mins, maxs = 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(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 235  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.GetClassification()._set_layer(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 292  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          table = self.store.Table()          if self.store:
212          if table.HasColumn(fieldName):              table = self.store.Table()
213              return table.Column(fieldName).type              if table.HasColumn(fieldName):
214                    return table.Column(fieldName).type
215          return None          return None
216    
217      def HasShapes(self):      def HasShapes(self):
# Line 302  class Layer(BaseLayer): Line 219  class Layer(BaseLayer):
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.store.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 349  class Layer(BaseLayer): Line 278  class Layer(BaseLayer):
278    
279          If 'clazz' is None a default classification is created.          If 'clazz' is None a default classification is created.
280    
281          ValueError is raised if the classification's field name          This issues a LAYER_CHANGED event.
         and type are different (if they aren't None) than what  
         is in the shapestore. The Layer will not be changed in  
         this case.  
282          """          """
283    
284          old_class = self.__classification          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              clazz = classification.Classification()              clazz = classification.Classification()
290    
291          try:          self.__classification = clazz
292              clazz._set_layer(self)          self.__classification.Subscribe(CLASS_CHANGED,
293                                            self._classification_changed)
294    
295              # only change things after a successful call          self._classification_changed()
             if old_class is not None:  
                 old_class._set_layer(None)  
             self.__classification = clazz  
         except ValueError:  
             raise ValueError  
   
         # we don't need this since a message will be sent  
         # after calling _set_layer()  
         #self.changed(LAYER_CHANGED, self)  
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    
# Line 430  class RasterLayer(BaseLayer): Line 350  class RasterLayer(BaseLayer):
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    
Legend:
Removed from v.1338  
changed lines
  Added in v.1978
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26