/[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 1427 by jonathan, Wed Jul 16 13:22:48 2003 UTC revision 1599 by bh, Mon Aug 18 12:45:28 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, CLASS_CHANGED       LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED, CLASS_CHANGED
# Line 21  import classification Line 20  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 157  class Layer(BaseLayer): Line 115  class Layer(BaseLayer):
115    
116          self.SetShapeStore(data)          self.SetShapeStore(data)
117    
118          self.SetClassificationField(None)          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 194  class Layer(BaseLayer): Line 153  class Layer(BaseLayer):
153          # FIXME: Maybe we should keep it the same if the type is          # FIXME: Maybe we should keep it the same if the type is
154          # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT          # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT
155          if self.__classification is not None:          if self.__classification is not None:
156              fieldname = self.classificationField              columnname = self.classification_column
157              fieldtype = self.GetFieldType(fieldname)              columntype = self.GetFieldType(columnname)
158              table = store.Table()              table = store.Table()
159              if (fieldname is not None              if (columnname is not None
160                  and (not table.HasColumn(fieldname)                  and (not table.HasColumn(columnname)
161                       or table.Column(fieldname).type != fieldtype)):                       or table.Column(columnname).type != columntype)):
162                  self.SetClassification(None)                  self.SetClassification(None)
163    
164          self.store = store          self.store = store
         shapefile = self.store.Shapefile()  
165    
         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)  
166          self.changed(LAYER_SHAPESTORE_REPLACED, self)          self.changed(LAYER_SHAPESTORE_REPLACED, self)
167    
168      def ShapeStore(self):      def ShapeStore(self):
# Line 235  class Layer(BaseLayer): Line 171  class Layer(BaseLayer):
171      def Destroy(self):      def Destroy(self):
172          BaseLayer.Destroy(self)          BaseLayer.Destroy(self)
173          if self.__classification is not None:          if self.__classification is not None:
174              self.__classification.Unsubscribe(CLASS_CHANGED, self.ClassChanged)              self.__classification.Unsubscribe(CLASS_CHANGED,
175                                                  self._classification_changed)
176    
177      def BoundingBox(self):      def BoundingBox(self):
178          """Return the layer's bounding box in the intrinsic coordinate system.          """Return the layer's bounding box in the intrinsic coordinate system.
179    
180          If the layer has no shapes, return None.          If the layer has no shapes, return None.
181          """          """
182          return self.bbox          return self.store.BoundingBox()
183    
184      def LatLongBoundingBox(self):      def LatLongBoundingBox(self):
185          """Return the layer's bounding box in lat/long coordinates.          """Return the layer's bounding box in lat/long coordinates.
# Line 303  class Layer(BaseLayer): Line 240  class Layer(BaseLayer):
240    
241      def NumShapes(self):      def NumShapes(self):
242          """Return the number of shapes in the layer"""          """Return the number of shapes in the layer"""
243          return self.numshapes          return self.store.NumShapes()
244    
245      def ShapeType(self):      def ShapeType(self):
246          """Return the type of the shapes in the layer.          """Return the type of the shapes in the layer.
247          This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.  
248            The return value is one of the SHAPETYPE_* constants defined in
249            Thuban.Model.data.
250          """          """
251          return self.shapetype          return self.store.ShapeType()
252    
253      def Shape(self, index):      def Shape(self, index):
254          """Return the shape with index index"""          """Return the shape with index index"""
255          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))  
256    
257          return Shape(points)      def ShapesInRegion(self, bbox):
258            """Return an iterable over the shapes that overlap the bounding box.
259    
260      def ShapesInRegion(self, box):          The bbox parameter should be the bounding box as a tuple in the
261          """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.  
262          """          """
         left, bottom, right, top = box  
   
263          if self.projection is not None:          if self.projection is not None:
264              left,  bottom = self.projection.Forward(left, bottom)              left, bottom, right, top = bbox
265              right, top    = self.projection.Forward(right, top)              xs = []; ys = []
266                for x, y in [(left, bottom), (left, top), (right, top),
267          return self.shapetree.find_shapes((left, bottom), (right, top))                           (right, bottom)]:
268                    x, y = self.projection.Forward(x, y)
269      def GetClassificationField(self):                  xs.append(x)
270          return self.classificationField                  ys.append(y)
271                bbox = (min(xs), min(ys), max(xs), max(ys))
272      def SetClassificationField(self, field):  
273          """Set the field to classifiy on, or None. If field is not None          return self.store.ShapesInRegion(bbox)
274          and the field does not exist in the table, raise a ValueError.  
275          """      def GetClassificationColumn(self):
276          if field:          return self.classification_column
277              fieldType = self.GetFieldType(field)  
278              if fieldType is None:      def SetClassificationColumn(self, column):
279            """Set the column to classifiy on, or None. If column is not None
280            and the column does not exist in the table, raise a ValueError.
281            """
282            if column:
283                columnType = self.GetFieldType(column)
284                if columnType is None:
285                  raise ValueError()                  raise ValueError()
286          self.classificationField = field          changed = self.classification_column != column
287            self.classification_column = column
288            if changed:
289                self.changed(LAYER_CHANGED, self)
290    
291      def HasClassification(self):      def HasClassification(self):
292          return True          return True
# Line 367  class Layer(BaseLayer): Line 303  class Layer(BaseLayer):
303          """          """
304    
305          if self.__classification is not None:          if self.__classification is not None:
306              self.__classification.Unsubscribe(CLASS_CHANGED, self.ClassChanged)              self.__classification.Unsubscribe(CLASS_CHANGED,
307                                                  self._classification_changed)
308    
309          if clazz is None:          if clazz is None:
310              clazz = classification.Classification()              clazz = classification.Classification()
311    
312          self.__classification = clazz          self.__classification = clazz
313          self.__classification.Subscribe(CLASS_CHANGED, self.ClassChanged)          self.__classification.Subscribe(CLASS_CHANGED,
314                                            self._classification_changed)
315    
316          self.ClassChanged()          self._classification_changed()
317    
318      def ClassChanged(self):      def _classification_changed(self):
319          """Called from the classification object when it has changed."""          """Called from the classification object when it has changed."""
320          self.changed(LAYER_CHANGED, self)          self.changed(LAYER_CHANGED, self)
321    
# Line 433  class RasterLayer(BaseLayer): Line 371  class RasterLayer(BaseLayer):
371          BaseLayer.__init__(self, title, visible = visible)          BaseLayer.__init__(self, title, visible = visible)
372    
373          self.projection = projection          self.projection = projection
374          self.filename = filename          self.filename = os.path.abspath(filename)
375    
376          self.bbox = -1          self.bbox = -1
377    
Legend:
Removed from v.1427  
changed lines
  Added in v.1599
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26