/[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 1355 by jonathan, Wed Jul 2 09:37:23 2003 UTC revision 1587 by bh, Fri Aug 15 10:31:07 2003 UTC
# Line 8  Line 8 
8    
9  __version__ = "$Revision$"  __version__ = "$Revision$"
10    
 from math import log, ceil  
11  import warnings  import warnings
12    
13  from Thuban import _  from Thuban import _
 import shapelib, shptree  
14    
15  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \
16       LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED       LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED, CLASS_CHANGED
17    
18  import classification  import classification
19    
20  from color import Transparent, Black  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  import resource
25    
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  shapetype_names = {SHAPETYPE_POINT: "Point",  shapetype_names = {SHAPETYPE_POINT: "Point",
28                     SHAPETYPE_ARC: "Arc",                     SHAPETYPE_ARC: "Arc",
29                     SHAPETYPE_POLYGON: "Polygon"}                     SHAPETYPE_POLYGON: "Polygon"}
# Line 152  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.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)
# Line 190  class Layer(BaseLayer): Line 146  class Layer(BaseLayer):
146          return value          return value
147    
148      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)  
149          # Set the classification to None if there is a classification          # Set the classification to None if there is a classification
150          # and the new shapestore doesn't have a table with a suitable          # 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          # 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          # FIXME: Maybe we should keep it the same if the type is
153          # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT          # 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              fieldtype = self.__classification.GetFieldType()              columntype = self.GetFieldType(columnname)
157              table = self.store.Table()              table = store.Table()
158              if (fieldname is not None              if (columnname is not None
159                  and (not table.HasColumn(fieldname)                  and (not table.HasColumn(columnname)
160                       or table.Column(fieldname).type != fieldtype)):                       or table.Column(columnname).type != columntype)):
161                  self.SetClassification(None)                  self.SetClassification(None)
162    
163            self.store = store
164    
165          self.changed(LAYER_SHAPESTORE_REPLACED, self)          self.changed(LAYER_SHAPESTORE_REPLACED, self)
166    
167      def ShapeStore(self):      def ShapeStore(self):
# Line 235  class Layer(BaseLayer): Line 169  class Layer(BaseLayer):
169    
170      def Destroy(self):      def Destroy(self):
171          BaseLayer.Destroy(self)          BaseLayer.Destroy(self)
172          self.GetClassification()._set_layer(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 292  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          table = self.store.Table()          if self.store:
232          if table.HasColumn(fieldName):              table = self.store.Table()
233              return table.Column(fieldName).type              if table.HasColumn(fieldName):
234                    return table.Column(fieldName).type
235          return None          return None
236    
237      def HasShapes(self):      def HasShapes(self):
# Line 302  class Layer(BaseLayer): Line 239  class Layer(BaseLayer):
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.store.Shapefile().read_object(index)          return self.store.Shape(index)
255    
256          if self.shapetype == SHAPETYPE_POINT:      def ShapesInRegion(self, bbox):
             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)  
   
     def ShapesInRegion(self, box):  
257          """Return the ids of the shapes that overlap the box.          """Return the ids of the shapes that overlap the box.
258    
259          Box is a tuple (left, bottom, right, top) in unprojected coordinates.          Box is a tuple (left, bottom, right, top) in unprojected coordinates.
260          """          """
         left, bottom, right, top = box  
   
261          if self.projection is not None:          if self.projection is not None:
262              left,  bottom = self.projection.Forward(left, bottom)              left, bottom, right, top = bbox
263              right, top    = self.projection.Forward(right, top)              xs = []; ys = []
264                for x, y in [(left, bottom), (left, top), (right, top),
265          return self.shapetree.find_shapes((left, bottom), (right, top))                           (right, bottom)]:
266                    x, y = self.projection.Forward(x, y)
267                    xs.append(x)
268                    ys.append(y)
269                bbox = (min(xs), min(ys), max(xs), max(ys))
270    
271            return self.store.ShapesInRegion(bbox)
272    
273        def GetClassificationColumn(self):
274            return self.classification_column
275    
276        def SetClassificationColumn(self, column):
277            """Set the column to classifiy on, or None. If column is not None
278            and the column does not exist in the table, raise a ValueError.
279            """
280            if column:
281                columnType = self.GetFieldType(column)
282                if columnType is None:
283                    raise ValueError()
284            changed = self.classification_column != column
285            self.classification_column = column
286            if changed:
287                self.changed(LAYER_CHANGED, self)
288    
289      def HasClassification(self):      def HasClassification(self):
290          return True          return True
# Line 349  class Layer(BaseLayer): Line 297  class Layer(BaseLayer):
297    
298          If 'clazz' is None a default classification is created.          If 'clazz' is None a default classification is created.
299    
300          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.  
301          """          """
302    
303          old_class = self.__classification          if self.__classification is not None:
304                self.__classification.Unsubscribe(CLASS_CHANGED,
305                                                  self._classification_changed)
306    
307          if clazz is None:          if clazz is None:
308              clazz = classification.Classification()              clazz = classification.Classification()
309    
310          try:          self.__classification = clazz
311              self.__classification = clazz          self.__classification.Subscribe(CLASS_CHANGED,
312              clazz._set_layer(self)                                          self._classification_changed)
313    
314              # only change things after a successful call          self._classification_changed()
             if old_class is not None:  
                 old_class._set_layer(None)  
         except ValueError:  
             self.__classification = old_class  
             raise ValueError  
   
         # we don't need this since a message will be sent  
         # after calling _set_layer()  
         #self.changed(LAYER_CHANGED, self)  
315    
316      def ClassChanged(self):      def _classification_changed(self):
317          """Called from the classification object when it has changed."""          """Called from the classification object when it has changed."""
318          self.changed(LAYER_CHANGED, self)          self.changed(LAYER_CHANGED, self)
319    
Legend:
Removed from v.1355  
changed lines
  Added in v.1587
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26