/[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 723 by bh, Thu Apr 24 15:31:53 2003 UTC revision 1088 by bh, Wed May 28 12:42:23 2003 UTC
# Line 14  from Thuban import _ Line 14  from Thuban import _
14    
15  import shapelib, shptree  import shapelib, shptree
16    
17    import gdal
18    from gdalconst import GA_ReadOnly
19    
20  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \  from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \
21       LAYER_CHANGED       LAYER_CHANGED
22    
# Line 31  class Shape: Line 34  class Shape:
34      def __init__(self, points):      def __init__(self, points):
35          self.points = points          self.points = points
36          #self.compute_bbox()          #self.compute_bbox()
37            self.bbox = None
38    
39      def compute_bbox(self):      def compute_bbox(self):
40            if self.bbox is not None:
41                return self.bbox
42    
43          xs = []          xs = []
44          ys = []          ys = []
45          for x, y in self.points:          for x, y in self.points:
# Line 43  class Shape: Line 50  class Shape:
50          self.urx = max(xs)          self.urx = max(xs)
51          self.ury = max(ys)          self.ury = max(ys)
52    
53            self.bbox = (self.llx, self.lly, self.urx, self.ury)
54    
55            return self.bbox
56    
57      def Points(self):      def Points(self):
58          return self.points          return self.points
59    
# Line 66  class BaseLayer(TitledObject, Modifiable Line 77  class BaseLayer(TitledObject, Modifiable
77    
78      """Base class for the layers."""      """Base class for the layers."""
79    
80      def __init__(self, title, visible = 1):      def __init__(self, title, visible = True, projection = None):
81          """Initialize the layer.          """Initialize the layer.
82    
83          title -- the title          title -- the title
# Line 75  class BaseLayer(TitledObject, Modifiable Line 86  class BaseLayer(TitledObject, Modifiable
86          TitledObject.__init__(self, title)          TitledObject.__init__(self, title)
87          Modifiable.__init__(self)          Modifiable.__init__(self)
88          self.visible = visible          self.visible = visible
89            self.projection = projection
90    
91      def Visible(self):      def Visible(self):
92          """Return true if layer is visible"""          """Return true if layer is visible"""
# Line 85  class BaseLayer(TitledObject, Modifiable Line 97  class BaseLayer(TitledObject, Modifiable
97          self.visible = visible          self.visible = visible
98          self.issue(LAYER_VISIBILITY_CHANGED, self)          self.issue(LAYER_VISIBILITY_CHANGED, self)
99    
100        def HasClassification(self):
101            """Determine if this layer support classifications."""
102            return False
103    
104        def GetProjection(self):
105            """Return the layer's projection."""
106            return self.projection
107    
108        def SetProjection(self, projection):
109            """Set the layer's projection"""
110            self.projection = projection
111            self.changed(LAYER_PROJECTION_CHANGED, self)
112    
113  class Layer(BaseLayer):  class Layer(BaseLayer):
114    
# Line 106  class Layer(BaseLayer): Line 130  class Layer(BaseLayer):
130                   fill = Color.Transparent,                   fill = Color.Transparent,
131                   stroke = Color.Black,                   stroke = Color.Black,
132                   lineWidth = 1,                   lineWidth = 1,
133                   visible = 1):                   visible = True):
134          """Initialize the layer.          """Initialize the layer.
135    
136          title -- the title          title -- the title
# Line 122  class Layer(BaseLayer): Line 146  class Layer(BaseLayer):
146    
147          colors are expected to be instances of Color class          colors are expected to be instances of Color class
148          """          """
149          BaseLayer.__init__(self, title, visible = visible)          BaseLayer.__init__(self, title,
150                                     visible = visible,
151          self.projection = projection                                   projection = projection)
152    
153          #          #
154          # this is really important so that when the classification class          # this is really important so that when the classification class
# Line 149  class Layer(BaseLayer): Line 173  class Layer(BaseLayer):
173          self.store = store          self.store = store
174          self.shapefile = self.store.Shapefile()          self.shapefile = self.store.Shapefile()
175          self.shapetable = self.store.Table()          self.shapetable = self.store.Table()
176          self.filename = self.store.filename          if hasattr(self.store, "FileName"):
177                self.filename = self.store.FileName()
178          self.table = self.shapetable          self.table = self.shapetable
179    
180          numshapes, shapetype, mins, maxs = self.shapefile.info()          numshapes, shapetype, mins, maxs = self.shapefile.info()
# Line 174  class Layer(BaseLayer): Line 199  class Layer(BaseLayer):
199    
200          self.shapetree = shptree.SHPTree(self.shapefile.cobject(), 2,          self.shapetree = shptree.SHPTree(self.shapefile.cobject(), 2,
201                                           maxdepth)                                           maxdepth)
202            # Set the classification to None if there is a classification
203            # and the new shapestore doesn't have a table with a suitable
204            # column, i.e one with the same name and type as before
205            # FIXME: Maybe we should keep it the same if the type is
206            # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT
207          if self.__classification is not None:          if self.__classification is not None:
208              fieldname = self.__classification.GetField()              fieldname = self.__classification.GetField()
209              if not self.store.Table().field_info_by_name(fieldname):              fieldtype = self.__classification.GetFieldType()
210                table = self.store.Table()
211                if (fieldname is not None
212                    and (not table.HasColumn(fieldname)
213                         or table.Column(fieldname).type != fieldtype)):
214                  self.SetClassification(None)                  self.SetClassification(None)
215          self.changed(LAYER_CHANGED, self)          self.changed(LAYER_CHANGED, self)
216    
# Line 209  class Layer(BaseLayer): Line 243  class Layer(BaseLayer):
243          else:          else:
244              return None              return None
245    
246      def GetFieldType(self, fieldName):      def ShapesBoundingBox(self, shapes):
247          info = self.table.field_info_by_name(fieldName)          """Return a bounding box in lat/long coordinates for the given
248          if info is not None:          list of shape ids.
249              return info[0]  
250            If shapes is None or empty, return None.
251            """
252    
253            if shapes is None or len(shapes) == 0: return None
254    
255            llx = []
256            lly = []
257            urx = []
258            ury = []
259    
260            if self.projection is not None:
261                inverse = lambda x, y: self.projection.Inverse(x, y)
262          else:          else:
263              return None              inverse = lambda x, y: (x, y)
264    
265            for id in shapes:
266                left, bottom, right, top = self.Shape(id).compute_bbox()
267    
268                left, bottom = inverse(left, bottom)
269                right, top   = inverse(right, top)
270    
271                llx.append(left)
272                lly.append(bottom)
273                urx.append(right)
274                ury.append(top)
275    
276            return (min(llx), min(lly), max(urx), max(ury))
277    
278        def GetFieldType(self, fieldName):
279            if self.table.HasColumn(fieldName):
280                return self.table.Column(fieldName).type
281            return None
282    
283      def NumShapes(self):      def NumShapes(self):
284          """Return the number of shapes in the layer"""          """Return the number of shapes in the layer"""
# Line 244  class Layer(BaseLayer): Line 308  class Layer(BaseLayer):
308      def ShapesInRegion(self, box):      def ShapesInRegion(self, box):
309          """Return the ids of the shapes that overlap the box.          """Return the ids of the shapes that overlap the box.
310    
311          Box is a tuple (left, bottom, right, top) in the coordinate          Box is a tuple (left, bottom, right, top) in unprojected coordinates.
         system used by the layer's shapefile.  
312          """          """
313          left, bottom, right, top = box          left, bottom, right, top = box
314    
315            if self.projection is not None:
316                left,  bottom = self.projection.Forward(left, bottom)
317                right, top    = self.projection.Forward(right, top)
318    
319          return self.shapetree.find_shapes((left, bottom), (right, top))          return self.shapetree.find_shapes((left, bottom), (right, top))
320    
321      def SetProjection(self, projection):      def HasClassification(self):
322          """Set the layer's projection"""          return True
         self.projection = projection  
         self.changed(LAYER_PROJECTION_CHANGED, self)  
323    
324      def GetClassification(self):      def GetClassification(self):
325          return self.__classification          return self.__classification
# Line 292  class Layer(BaseLayer): Line 358  class Layer(BaseLayer):
358      def TreeInfo(self):      def TreeInfo(self):
359          items = []          items = []
360    
361            if hasattr(self, 'filename'):
362                items.append(_("Filename: %s") % self.filename)
363    
364          if self.Visible():          if self.Visible():
365              items.append(_("Shown"))              items.append(_("Shown"))
366          else:          else:
# Line 305  class Layer(BaseLayer): Line 374  class Layer(BaseLayer):
374              items.append(_("Extent (lat-lon):"))              items.append(_("Extent (lat-lon):"))
375          items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])          items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])
376    
377            if self.projection and len(self.projection.params) > 0:
378                items.append((_("Projection"),
379                            [str(param) for param in self.projection.params]))
380    
381          items.append(self.__classification)          items.append(self.__classification)
382    
383          return (_("Layer '%s'") % self.Title(), items)          return (_("Layer '%s'") % self.Title(), items)
384    
385    
386    class RasterLayer(BaseLayer):
387    
388        def __init__(self, title, filename, projection = None, visible = True):
389            """Initialize the Raster Layer.
390    
391            title -- title for the layer.
392    
393            filename -- file name of the source image.
394    
395            projection -- Projection object describing the projection which
396                          the source image is in.
397    
398            visible -- True is the layer should initially be visible.
399    
400            Throws IOError if the filename is invalid or points to a file that
401            is not in a format GDAL can use.
402            """
403    
404            BaseLayer.__init__(self, title, visible = visible)
405    
406            self.projection = projection
407            self.filename = filename
408    
409            self.bbox = -1
410    
411            #
412            # temporarily open the file so that GDAL can test if it's valid.
413            #
414            dataset = gdal.Open(self.filename, GA_ReadOnly)
415    
416            if dataset is None:
417                raise IOError()
418    
419            self.UnsetModified()
420    
421        def BoundingBox(self):
422            """Return the layer's bounding box in the intrinsic coordinate system.
423    
424            If the layer has no shapes, return None.
425            """
426            if self.bbox == -1:
427                dataset = gdal.Open(self.filename, GA_ReadOnly)
428                if dataset is None:
429                    self.bbox = None
430                else:
431                    geotransform = dataset.GetGeoTransform()
432                    if geotransform is None:
433                        return None
434    
435                    x = 0
436                    y = dataset.RasterYSize
437                    left = geotransform[0] +        \
438                           geotransform[1] * x +    \
439                           geotransform[2] * y
440    
441                    bottom = geotransform[3] +      \
442                             geotransform[4] * x +  \
443                             geotransform[5] * y
444    
445                    x = dataset.RasterXSize
446                    y = 0
447                    right = geotransform[0] +       \
448                            geotransform[1] * x +   \
449                            geotransform[2] * y
450    
451                    top = geotransform[3] +         \
452                          geotransform[4] * x +     \
453                          geotransform[5] * y
454    
455                    self.bbox = (left, bottom, right, top)
456    
457            return self.bbox
458    
459        def LatLongBoundingBox(self):
460            bbox = self.BoundingBox()
461            if bbox is None:
462                return None
463    
464            llx, lly, urx, ury = bbox
465            if self.projection is not None:
466                llx, lly = self.projection.Inverse(llx, lly)
467                urx, ury = self.projection.Inverse(urx, ury)
468    
469            return llx, lly, urx, ury
470    
471        def GetImageFilename(self):
472            return self.filename
473    
474        def TreeInfo(self):
475            items = []
476    
477            if self.Visible():
478                items.append(_("Shown"))
479            else:
480                items.append(_("Hidden"))
481            items.append(_("Shapes: %d") % self.NumShapes())
482    
483            bbox = self.LatLongBoundingBox()
484            if bbox is not None:
485                items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % bbox)
486            else:
487                items.append(_("Extent (lat-lon):"))
488    
489            if self.projection and len(self.projection.params) > 0:
490                items.append((_("Projection"),
491                            [str(param) for param in self.projection.params]))
492    
493            return (_("Layer '%s'") % self.Title(), items)
494    
Legend:
Removed from v.723  
changed lines
  Added in v.1088
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26