/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/Model/layer.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/Thuban/Model/layer.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1593 by bh, Fri Aug 15 14:10:27 2003 UTC revision 2614 by jonathan, Fri May 6 14:16:38 2005 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001, 2002, 2003 by Intevation GmbH  # Copyright (c) 2001, 2002, 2003, 2004 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]>
4  # Jonathan Coles <[email protected]>  # Jonathan Coles <[email protected]>
5    # Silke Reimer <[email protected]>
6  #  #
7  # This program is free software under the GPL (>=v2)  # This program is free software under the GPL (>=v2)
8  # Read the file COPYING coming with Thuban for details.  # Read the file COPYING coming with Thuban for details.
9    
10  __version__ = "$Revision$"  __version__ = "$Revision$"
11    
12    import os
13  import warnings  import warnings
14    
15  from Thuban import _  from Thuban import _
# Line 23  from data import SHAPETYPE_POLYGON, SHAP Line 25  from data import SHAPETYPE_POLYGON, SHAP
25    
26  import resource  import resource
27    
28    from color import Color
29    
30  shapetype_names = {SHAPETYPE_POINT: "Point",  shapetype_names = {SHAPETYPE_POINT: "Point",
31                     SHAPETYPE_ARC: "Arc",                     SHAPETYPE_ARC: "Arc",
# Line 53  class BaseLayer(TitledObject, Modifiable Line 56  class BaseLayer(TitledObject, Modifiable
56          self.issue(LAYER_VISIBILITY_CHANGED, self)          self.issue(LAYER_VISIBILITY_CHANGED, self)
57    
58      def HasClassification(self):      def HasClassification(self):
59          """Determine if this layer support classifications."""          """Determine if this layer supports classifications."""
60          return False          return False
61    
62      def HasShapes(self):      def HasShapes(self):
# Line 65  class BaseLayer(TitledObject, Modifiable Line 68  class BaseLayer(TitledObject, Modifiable
68          return self.projection          return self.projection
69    
70      def SetProjection(self, projection):      def SetProjection(self, projection):
71          """Set the layer's projection"""          """Set the layer's projection."""
72          self.projection = projection          self.projection = projection
73          self.changed(LAYER_PROJECTION_CHANGED, self)          self.changed(LAYER_PROJECTION_CHANGED, self)
74    
75        def Type(self):
76            return "Unknown"
77    
78  class Layer(BaseLayer):  class Layer(BaseLayer):
79    
80      """Represent the information of one geodata file (currently a shapefile)      """Represent the information of one geodata file (currently a shapefile)
# Line 124  class Layer(BaseLayer): Line 130  class Layer(BaseLayer):
130    
131          self.UnsetModified()          self.UnsetModified()
132    
     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  
   
133      def SetShapeStore(self, store):      def SetShapeStore(self, store):
134          # Set the classification to None if there is a classification          # Set the classification to None if there is a classification
135          # and the new shapestore doesn't have a table with a suitable          # and the new shapestore doesn't have a table with a suitable
# Line 186  class Layer(BaseLayer): Line 171  class Layer(BaseLayer):
171          Return None, if the layer doesn't contain any shapes.          Return None, if the layer doesn't contain any shapes.
172          """          """
173          bbox = self.BoundingBox()          bbox = self.BoundingBox()
174          if bbox is not None:          if bbox is not None and self.projection is not None:
175              llx, lly, urx, ury = bbox              bbox = self.projection.InverseBBox(bbox)
176              if self.projection is not None:          return bbox
177                  llx, lly = self.projection.Inverse(llx, lly)  
178                  urx, ury = self.projection.Inverse(urx, ury)      def Type(self):
179              return llx, lly, urx, ury          return self.ShapeType();
         else:  
             return None  
180    
181      def ShapesBoundingBox(self, shapes):      def ShapesBoundingBox(self, shapes):
182          """Return a bounding box in lat/long coordinates for the given          """Return a bounding box in lat/long coordinates for the given
# Line 204  class Layer(BaseLayer): Line 187  class Layer(BaseLayer):
187    
188          if shapes is None or len(shapes) == 0: return None          if shapes is None or len(shapes) == 0: return None
189    
190          llx = []          xs = []
191          lly = []          ys = []
         urx = []  
         ury = []  
   
         if self.projection is not None:  
             inverse = lambda x, y: self.projection.Inverse(x, y)  
         else:  
             inverse = lambda x, y: (x, y)  
192    
193          for id in shapes:          for id in shapes:
194              left, bottom, right, top = self.Shape(id).compute_bbox()              bbox = self.Shape(id).compute_bbox()
195                if self.projection is not None:
196              left, bottom = inverse(left, bottom)                  bbox = self.projection.InverseBBox(bbox)
197              right, top   = inverse(right, top)              left, bottom, right, top = bbox
198                xs.append(left); xs.append(right)
199                ys.append(bottom); ys.append(top)
200    
201              llx.append(left)          return (min(xs), min(ys), max(xs), max(ys))
             lly.append(bottom)  
             urx.append(right)  
             ury.append(top)  
202    
         return (min(llx), min(lly), max(urx), max(ury))  
203    
204      def GetFieldType(self, fieldName):      def GetFieldType(self, fieldName):
205          if self.store:          if self.store:
# Line 260  class Layer(BaseLayer): Line 234  class Layer(BaseLayer):
234          form (minx, miny, maxx, maxy) in unprojected coordinates.          form (minx, miny, maxx, maxy) in unprojected coordinates.
235          """          """
236          if self.projection is not None:          if self.projection is not None:
237              left, bottom, right, top = bbox              # Ensure that region lies within the layer's bounding box
238              xs = []; ys = []              # Otherwise projection of the region would lead to incorrect
239              for x, y in [(left, bottom), (left, top), (right, top),              # values.
240                           (right, bottom)]:              clipbbox = self.ClipBoundingBox(bbox)
241                  x, y = self.projection.Forward(x, y)              bbox = self.projection.ForwardBBox(clipbbox)
                 xs.append(x)  
                 ys.append(y)  
             bbox = (min(xs), min(ys), max(xs), max(ys))  
   
242          return self.store.ShapesInRegion(bbox)          return self.store.ShapesInRegion(bbox)
243    
244      def GetClassificationColumn(self):      def GetClassificationColumn(self):
# Line 331  class Layer(BaseLayer): Line 301  class Layer(BaseLayer):
301    
302          bbox = self.LatLongBoundingBox()          bbox = self.LatLongBoundingBox()
303          if bbox is not None:          if bbox is not None:
304              items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % bbox)              items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % tuple(bbox))
305          else:          else:
306              items.append(_("Extent (lat-lon):"))              items.append(_("Extent (lat-lon):"))
307          items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])          items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])
# Line 344  class Layer(BaseLayer): Line 314  class Layer(BaseLayer):
314    
315          return (_("Layer '%s'") % self.Title(), items)          return (_("Layer '%s'") % self.Title(), items)
316    
317        def ClipBoundingBox(self, bbox):
318            """ Clip bbox to layer's bounding box.
319    
320            Returns that part of bbox that lies within the layers bounding box.
321            If bbox is completely outside of the layers bounding box, bbox is
322            returned.  It is assumed that bbox has sensible values, i.e. bminx
323            < bmaxx and bminy < bmaxy.
324            """
325            bminx, bminy, bmaxx, bmaxy = bbox
326            lminx, lminy, lmaxx, lmaxy = self.LatLongBoundingBox()
327            if bminx > lmaxx or bmaxx < lminx:
328                left, right = bminx, bmaxx
329            else:
330                left = max(lminx, bminx)
331                right = min(lmaxx, bmaxx)
332            if bminy > lmaxy or bmaxy < lminy:
333                bottom, top = bminy, bmaxy
334            else:
335                bottom = max(lminy, bminy)
336                top = min(lmaxy, bmaxy)
337            
338            return (left, bottom, right, top)
339    
340    
341  if resource.has_gdal_support():  if resource.has_gdal_support():
342      import gdal      import gdal
# Line 351  if resource.has_gdal_support(): Line 344  if resource.has_gdal_support():
344    
345  class RasterLayer(BaseLayer):  class RasterLayer(BaseLayer):
346    
347      def __init__(self, title, filename, projection = None, visible = True):      MASK_NONE  = 0
348        MASK_BIT   = 1
349        MASK_ALPHA = 2
350    
351        def __init__(self, title, filename, projection = None,
352                     visible = True, opacity = 1, masktype = MASK_BIT):
353          """Initialize the Raster Layer.          """Initialize the Raster Layer.
354    
355          title -- title for the layer.          title -- title for the layer.
# Line 370  class RasterLayer(BaseLayer): Line 368  class RasterLayer(BaseLayer):
368          BaseLayer.__init__(self, title, visible = visible)          BaseLayer.__init__(self, title, visible = visible)
369    
370          self.projection = projection          self.projection = projection
371          self.filename = filename          self.filename = os.path.abspath(filename)
372    
373          self.bbox = -1          self.bbox = -1
374    
375            self.mask_type = masktype
376            self.opacity = opacity
377    
378            self.image_info = None
379    
380          if resource.has_gdal_support():          if resource.has_gdal_support():
381              #              #
382              # temporarily open the file so that GDAL can test if it's valid.              # temporarily open the file so that GDAL can test if it's valid.
# Line 383  class RasterLayer(BaseLayer): Line 386  class RasterLayer(BaseLayer):
386              if dataset is None:              if dataset is None:
387                  raise IOError()                  raise IOError()
388    
389                #
390                # while we have the file, extract some basic information
391                # that we can display later
392                #
393                self.image_info = {}
394    
395                self.image_info["nBands"] = dataset.RasterCount
396                self.image_info["Size"] = (dataset.RasterXSize, dataset.RasterYSize)
397                self.image_info["Driver"] = dataset.GetDriver().ShortName
398    
399                # store some information about the individual bands
400                # [min_value, max_value]
401                a = self.image_info["BandData"] = []
402    
403                for i in range(1, dataset.RasterCount+1):
404                    band = dataset.GetRasterBand(i)
405                    a.append(band.ComputeRasterMinMax())
406    
407          self.UnsetModified()          self.UnsetModified()
408    
409      def BoundingBox(self):      def BoundingBox(self):
# Line 432  class RasterLayer(BaseLayer): Line 453  class RasterLayer(BaseLayer):
453          if bbox is None:          if bbox is None:
454              return None              return None
455    
         llx, lly, urx, ury = bbox  
456          if self.projection is not None:          if self.projection is not None:
457              llx, lly = self.projection.Inverse(llx, lly)              bbox = self.projection.InverseBBox(bbox)
458              urx, ury = self.projection.Inverse(urx, ury)  
459            return bbox
460    
461          return llx, lly, urx, ury      def Type(self):
462            return "Image"
463    
464      def GetImageFilename(self):      def GetImageFilename(self):
465          return self.filename          return self.filename
466    
467        def MaskType(self):
468            """Return True if the mask should be used when rendering the layer."""
469            return self.mask_type
470    
471        def SetMaskType(self, type):
472            """Set the type of mask to use.
473    
474            type can be one of MASK_NONE, MASK_BIT, MASK_ALPHA
475    
476            If the state changes, a LAYER_CHANGED message is sent.
477            """
478            if type not in (self.MASK_NONE, self.MASK_BIT, self.MASK_ALPHA):
479                raise ValueError("type is invalid")
480    
481            if type != self.mask_type:
482                self.mask_type = type
483                self.changed(LAYER_CHANGED, self)
484    
485        def Opacity(self):
486            """Return the level of opacity used in alpha blending.
487            """
488            return self.opacity
489    
490        def SetOpacity(self, op):
491            """Set the level of alpha opacity.
492    
493            0 <= op <= 1.
494    
495            The layer is fully opaque when op = 1.
496            """
497            if not (0 <= op <= 1):
498                raise ValueError("op out of range")
499    
500            if op != self.opacity:
501                self.opacity = op
502                self.changed(LAYER_CHANGED, self)
503    
504        def ImageInfo(self):
505            return self.image_info
506    
507      def TreeInfo(self):      def TreeInfo(self):
508          items = []          items = []
509    
Legend:
Removed from v.1593  
changed lines
  Added in v.2614
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26