/[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 1593 by bh, Fri Aug 15 14:10:27 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, CLASS_CHANGED       LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED, CLASS_CHANGED
# Line 21  import classification Line 19  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 157  class Layer(BaseLayer): Line 114  class Layer(BaseLayer):
114    
115          self.SetShapeStore(data)          self.SetShapeStore(data)
116    
117          self.SetClassificationField(None)          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 194  class Layer(BaseLayer): Line 152  class Layer(BaseLayer):
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.classificationField              columnname = self.classification_column
156              fieldtype = self.GetFieldType(fieldname)              columntype = self.GetFieldType(columnname)
157              table = 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          self.store = store
         shapefile = self.store.Shapefile()  
164    
         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)  
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 170  class Layer(BaseLayer):
170      def Destroy(self):      def Destroy(self):
171          BaseLayer.Destroy(self)          BaseLayer.Destroy(self)
172          if self.__classification is not None:          if self.__classification is not None:
173              self.__classification.Unsubscribe(CLASS_CHANGED, self.ClassChanged)              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 303  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)
   
         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)  
255    
256      def ShapesInRegion(self, box):      def ShapesInRegion(self, bbox):
257          """Return the ids of the shapes that overlap the box.          """Return an iterable over the shapes that overlap the bounding box.
258    
259          Box is a tuple (left, bottom, right, top) in unprojected coordinates.          The bbox parameter should be the bounding box as a tuple in the
260            form (minx, miny, maxx, maxy) in unprojected coordinates.
261          """          """
         left, bottom, right, top = box  
   
262          if self.projection is not None:          if self.projection is not None:
263              left,  bottom = self.projection.Forward(left, bottom)              left, bottom, right, top = bbox
264              right, top    = self.projection.Forward(right, top)              xs = []; ys = []
265                for x, y in [(left, bottom), (left, top), (right, top),
266          return self.shapetree.find_shapes((left, bottom), (right, top))                           (right, bottom)]:
267                    x, y = self.projection.Forward(x, y)
268      def GetClassificationField(self):                  xs.append(x)
269          return self.classificationField                  ys.append(y)
270                bbox = (min(xs), min(ys), max(xs), max(ys))
271      def SetClassificationField(self, field):  
272          """Set the field to classifiy on, or None. If field is not None          return self.store.ShapesInRegion(bbox)
273          and the field does not exist in the table, raise a ValueError.  
274        def GetClassificationColumn(self):
275            return self.classification_column
276    
277        def SetClassificationColumn(self, column):
278            """Set the column to classifiy on, or None. If column is not None
279            and the column does not exist in the table, raise a ValueError.
280          """          """
281          if field:          if column:
282              fieldType = self.GetFieldType(field)              columnType = self.GetFieldType(column)
283              if fieldType is None:              if columnType is None:
284                  raise ValueError()                  raise ValueError()
285          self.classificationField = field          changed = self.classification_column != column
286            self.classification_column = column
287            if changed:
288                self.changed(LAYER_CHANGED, self)
289    
290      def HasClassification(self):      def HasClassification(self):
291          return True          return True
# Line 367  class Layer(BaseLayer): Line 302  class Layer(BaseLayer):
302          """          """
303    
304          if self.__classification is not None:          if self.__classification is not None:
305              self.__classification.Unsubscribe(CLASS_CHANGED, self.ClassChanged)              self.__classification.Unsubscribe(CLASS_CHANGED,
306                                                  self._classification_changed)
307    
308          if clazz is None:          if clazz is None:
309              clazz = classification.Classification()              clazz = classification.Classification()
310    
311          self.__classification = clazz          self.__classification = clazz
312          self.__classification.Subscribe(CLASS_CHANGED, self.ClassChanged)          self.__classification.Subscribe(CLASS_CHANGED,
313                                            self._classification_changed)
314    
315          self.ClassChanged()          self._classification_changed()
316    
317      def ClassChanged(self):      def _classification_changed(self):
318          """Called from the classification object when it has changed."""          """Called from the classification object when it has changed."""
319          self.changed(LAYER_CHANGED, self)          self.changed(LAYER_CHANGED, self)
320    
Legend:
Removed from v.1427  
changed lines
  Added in v.1593
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26