/[thuban]/branches/WIP-pyshapelib-bramz/Extensions/ogr/ogrshapes.py

Diff of /branches/WIP-pyshapelib-bramz/Extensions/ogr/ogrshapes.py

Parent Directory | Revision Log | View Patch Patch

-revision 2493 by nhueffme,
Mon Dec 20 14:13:57 2004 UTC
+revision 2577 by nhueffme,
Fri Mar  4 15:07:59 2005 UTC
 Line 17 
 except ImportError:
      ogr = None
  import os
- import weakref
- from math import ceil, log
  from Thuban import _
  from Thuban.Model import table
+ from Thuban.Model import transientdb
+ from Thuban.Model.transientdb import  TransientDatabase
  from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
  from Thuban.Model.data import RAW_PYTHON, RAW_SHAPEFILE, RAW_WKT
  def has_ogr_support():
      """Return whether this Thuban instance supports ogr file formats
-Line 36 
 def has_ogr_support():
+Line 35 
 def has_ogr_support():
      return ogr is not None
  if ogr is not None:
-     # mapping from ogr-lib shapetype and table constants to our constants
+     SHAPETYPE_UNKNOWN = ogr.wkbUnknown
+     SHAPETYPE_GEOMCOLL = ogr.wkbGeometryCollection
+     SHAPETYPE_NONE = ogr.wkbNone
+     # mapping from ogr-lib shapetypes and table constants to our constants
      ogrlib_shapetypes = {ogr.wkbPolygon: SHAPETYPE_POLYGON,
                  ogr.wkbLineString: SHAPETYPE_ARC,
-                 ogr.wkbPoint: SHAPETYPE_POINT}
+                 ogr.wkbPoint: SHAPETYPE_POINT,
+                 ogr.wkbUnknown: SHAPETYPE_UNKNOWN,
+                 ogr.wkbNone: SHAPETYPE_NONE,
+                 ogr.wkbGeometryCollection: SHAPETYPE_GEOMCOLL}
      fieldtype_map = {ogr.OFTString: table.FIELDTYPE_STRING,
                  ogr.OFTInteger: table.FIELDTYPE_INT,
                  ogr.OFTReal: table.FIELDTYPE_DOUBLE}
+ else:
+     ogrlib_shapetypes = {}
+     fieldtype_map = {}
+     SHAPETYPE_UNKNOWN = 0
+     SHAPETYPE_GEOMCOLL = 7
+     SHAPETYPE_NONE = 100
  class OGRShape:
+     """Represent one shape of an OGRShapeStore
+     """
-     """Represent one shape of an OGRShapeStore"""
+     def __init__(self, shapestore, shape):
+         """Initialize the shape object.
+         shapestore should be an instance of OGRShapeStore,
+         shape should be an instance of an OGRFeature.
+         """
+         self.ogrlayer = shapestore.ogrlayer
+         id_column = shapestore.Id_column()
+         self.feature = shape
+         if id_column is None:
+             self.shapeid = self.feature.GetFID()
+         else:
+             self.shapeid = self.feature.GetField(id_column)
+         self.geom = self.feature.GetGeometryRef()
+         if self.geom:
+             self.shapetype = self.geom.GetGeometryType()
+             self.bbox = self._compute_bbox()
+             self.points = self._points()
+         else:
+             self.shapetype = ogr.wkbNone
+             self.bbox = None
+             self.points = [[]]
+         try:
+             self.shapetype = ogrlib_shapetypes[self.shapetype]
+         except:
+             self.shapetype = ogrlib_shapetypes[ogr.wkbUnknown]
+         self.geoms = self._geoms()
+     def _geoms(self):
+         """Return a list of geometry objects.
+         If the shape is a geometry collection, all contained geometry
+         objects are stored to the list as OGRGeometry objects.
+         """
+         geoms = []
+         if self.shapetype == SHAPETYPE_GEOMCOLL:
+             for i in range(self.geom.GetGeometryCount()):
+                 geoms.append(OGRGeometry(self, self.geom, i))
+         return geoms
-     def __init__(self, ogrlayer, shapeid):
+     def _compute_bbox(self):
-         self.ogrlayer = ogrlayer
+         """
-         self.shapeid = shapeid
+         Compute the bounding box of the shape as a tuple (minx,miny,maxx,maxy)
+         """
+         minx, maxx, miny, maxy = self.geom.GetEnvelope()
+         return (minx, miny, maxx, maxy)
      def compute_bbox(self):
          """
          Return the bounding box of the shape as a tuple (minx,miny,maxx,maxy)
          """
-         shape = self.ogrlayer.GetFeature(self.shapeid)
+         return self.bbox
-         geom = shape.GetGeometryRef()
-         minx, maxx, miny, maxy = geom.GetEnvelope()
-         return (minx, miny, maxx, maxy)
      def ShapeID(self):
+         """Return the feature id of this shape.
+         """
          return self.shapeid
-     # diese Methode funktioniert vielleicht noch nicht f�r andere Formate
-     #als shp
-     #(wenn ein polygon aus mehreren
-     # Ringen besteht o.�., hat ein Geometry-Objekt mehr als einen
-     #GeometryRef().---------
      def Points(self):
-         """Return the coordinates of the shape as a list of lists of pairs"""
+         """Return the coordinates of the shape as a list of lists of pairs
-         feature = self.ogrlayer.GetFeature(self.shapeid)
+         """
-         geom = feature.GetGeometryRef()
+         return self.points
+     def _points(self):
+         """Get the coordinates of the shape as a list of lists of pairs
+         """
          shape = []
+         if self.geom is None:
+             return shape.append([])
          # if geometry object is of type point or line
-         if geom.GetGeometryCount() == 0:
+         if self.geom.GetGeometryCount() == 0:
              points =[]
-             for point in range(geom.GetPointCount()):
+             for point in range(self.geom.GetPointCount()):
-                 x = geom.GetX(point)
+                 x = self.geom.GetX(point)
-                 y = geom.GetY(point)
+                 y = self.geom.GetY(point)
                  points.append((x, y))
              return [points]
          # if geometry object is of type polygon or multipolygon
-         for i in range(geom.GetGeometryCount()):
+         for i in range(self.geom.GetGeometryCount()):
              points = []
-             geometry = geom.GetGeometryRef(i)
+             geometry = self.geom.GetGeometryRef(i)
              # if geometry object is polygon
              if geometry.GetGeometryCount() == 0:
                  for point in range(geometry.GetPointCount()):
                      x = geometry.GetX(point)
                      y = geometry.GetY(point)
                      points.append((x, y))
                  shape.append(points)
-             # if geometry object is of type multipolygon
+             # if geometry object is of type multipolygon or geometry collection
              else:
                  for j in range(geometry.GetGeometryCount()):
                      points = []
                      subgeom = geometry.GetGeometryRef(j)
-Line 108 
 class OGRShape:
+Line 167 
 class OGRShape:
          return shape
      def RawData(self):
-         """Return the shape id to use with the shapestore"""
+         """Return the shape id to use with the shapestore
+         """
          return self.shapeid
      def OGRLayer(self):
-         """Return the ogrlayer object"""
+         """Return the ogrlayer object
+         """
          return self.ogrlayer
+     def ShapeType(self):
+         """Return the shapetype of this shape (may differ from the layer's
+         shapetype)
+         """
+         return self.shapetype
+     def GetGeoms(self):
+         """Return the list of geometries of this feature.
- class OGRShapeStore:
+         If this feature is a geometry collection, all contained geometries
+         are given. Else the returned list is empty.
+         """
+         return self.geoms
+     def GetGeom(self, index):
+         """Return the OGRGeometry object at the specified index.
+         This is not none only if the shape is a geometry collection.
+         """
+         if index < len(self.geoms):
+             return self.geoms[index]
+         else:
+             return None
+ class OGRGeometry:
+     """This class represents a geometry belonging to a specified feature.
+     """
+     def __init__(self, shape, geom, index):
+         """Initialize the geometry object.
+         shape should be an OGRShape, which this geometry belongs to.
+         geom is the base geometry, index is the ReferenceID.
+         """
+         self.shape = shape
+         self.index = index
-     """Corresponds to an OGRLayer object, containing features/shapes and
+         self.geom = geom.GetGeometryRef(index)
-        providing all methods Thuban needs.
+         try:
+             self.shapetype = ogrlib_shapetypes[self.geom.GetGeometryType()]
+         except:
+             self.shapetype = ogrlib_shapetypes[ogr.wkbUnknown]
+     def ShapeType(self):
+         """Return the shapetype of this geometry object."""
+         return self.shapetype
+ class OGRShapeStore:
+     """Corresponds to an OGRLayer object, containing features/shapes and
+        providing the same methods like ShapefileStore.
      """
-     def __init__(self, session, filename, layername):
+     def __init__(self, session, filename, layername, id_column = None):
-         # Make the filename absolute. The filename will be
+         """Initialize the shapestore.
-         # interpreted relative to that anyway, but when saving a
-         # session we need to compare absolute paths and it's usually
-         # safer to always work with absolute paths.
-         self.filename = os.path.abspath(filename)
+         All required information is loaded from the datasource.
+         """
+         # if id_column is None, data is loaded from file, so we need path
+         # if id_column is not None, data is loaded from database
+         if id_column is None:
+             self.filename = os.path.abspath(filename)
+         else:
+             self.filename = filename
          self.layername = layername
-         self.ogrdatasource = ogr.Open(self.filename)
+         self.ogrdatasource = ogr.Open(filename)
          self.ogrlayer = (self.ogrdatasource).GetLayerByName(layername)
-         self.table = OGRTable(self.ogrdatasource, self.ogrlayer)
+         if id_column is not None:
+             self.id_column = id_column
+         else:
+             self.id_column = None
+         self.table = OGRTable(session, self.ogrdatasource, self.ogrlayer,
+                                 self.id_column)
          self._open_ogrlayer(layername)
      def _open_ogrlayer(self, layername):
+         """Get all required information from the datasource.
+         """
          self.numshapes = self.ogrlayer.GetFeatureCount()
          self.shapetype = self.ogrlayer.GetLayerDefn().GetGeomType()
-         extent = self.ogrlayer.GetExtent()
+         extent = self.ogrlayer.GetExtent()
          if extent:
              self.bbox = [extent[0], extent[2], extent[1], extent[3]]
          else:
              self.bbox = None
-         self.shapetype = ogrlib_shapetypes[self.shapetype]
+         try:
+             self.shapetype = ogrlib_shapetypes[self.shapetype]
+         except:
+             # if shapetype is not contained in ogrlib_shapetypes
+             # treat it like SHAPETYPE_UNKNOWN
+             self.shapetype = ogrlib_shapetypes[ogr.wkbUnknown]
+         self.shapes = self.shapes()
+     def shapes(self):
+         """Return a collection of all features as OGRShape objects.
+         """
+         shapes = {}
+         self.ogrlayer.ResetReading()
+         if self.id_column is None:
+             nextFeature = self.ogrlayer.GetNextFeature()
+             while nextFeature is not None:
+                 fid = nextFeature.GetFID()
+                 shape = OGRShape(self, nextFeature)
+                 shapes[shape.ShapeID()] = shape
+                 nextFeature = self.ogrlayer.GetNextFeature()
+         else:
+             lay = self.ogrdatasource.ExecuteSQL("SELECT %s, * from %s"
+                                     % (self.id_column, self.layername))
+             if lay is not None:
+                 lay.ResetReading()
+                 nextFeature = lay.GetNextFeature()
+                 while nextFeature is not None:
+                     fid = nextFeature.GetField(0)
+                     shape = OGRShape(self, nextFeature)
+                     shapes[shape.ShapeID()] = shape
+                     nextFeature = lay.GetNextFeature()
+                 self.ogrdatasource.ReleaseResultSet(lay)
+         return shapes
      def OGRLayer(self):
-         """Return the OGRLayer object"""
+         """Return the OGRLayer object
+         """
          return self.ogrlayer
      def FileName(self):
-         """Return the filename used to open the file"""
+         """Return the filename used to open the file
+         """
          return self.filename
      def FileType(self):
-         """Return the filetype. This is always the string 'ogr-file'"""
+         """Return the filetype. This is depending on the driver used to open
-         return "ogr-file"
+         the file.
+         """
+         return self.ogrdatasource.GetDriver().GetName()
      def ShapeType(self):
          """Return the type of the shapes in the shapestore.
-         This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.
+         This is either SHAPETYPE_POINT, SHAPETYPE_ARC, SHAPETYPE_POLYGON,
+         SHAEPTYPE_GEOMCOLL, SHAPETYPE_NONE or SHAPETYPE_UNKNOWN.
          """
          return self.shapetype
      def RawShapeFormat(self):
-         """Return the raw data format of the shape data, i.e. RAW_PYTHON"""
+         """Return the raw data format of the shape data, i.e. RAW_PYTHON
+         """
          return RAW_PYTHON
      def NumShapes(self):
-         """Return the number of shapes in the shape store"""
+         """Return the number of shapes in the shape store
+         """
          return self.numshapes
      def BoundingBox(self):
-Line 187 
 class OGRShapeStore:
+Line 349 
 class OGRShapeStore:
          The bbox parameter should be the bounding box as a tuple in the
          form (minx, miny, maxx, maxy) in the coordinate system of the
          shape store.
-         The method GetFID() returns feature IDs starting from 0.
          """
-         # Bind a few globals to locals to make it a bit faster
-         cls = OGRShape
-         ogrlayer = self.ogrlayer
          left, bottom, right, top = bbox
          # create a geometry which can be passed to the layer as spatial filter
          bboxpolygon = ogr.CreateGeometryFromWkt(
                        ('Polygon((%s %s, %s %s, %s %s,%s %s, %s %s))'
                                   %(left, bottom, left, top, right, top,
                                    right, bottom, left, bottom)))
-         if ogrlayer.GetSpatialRef():
+         if self.ogrlayer.GetSpatialRef():
-             bboxpolygon.AssignSpatialReference(ogrlayer.GetSpatialRef())
+             bboxpolygon.AssignSpatialReference(self.ogrlayer.GetSpatialRef())
-         ogrlayer.ResetReading()
+         self.ogrlayer.ResetReading()
-         ogrlayer.SetSpatialFilter(bboxpolygon)
+         #ogrlayer.SetSpatialFilterRect(left, bottom, right, top)
-         numFeatures = ogrlayer.GetFeatureCount()
+         self.ogrlayer.SetSpatialFilter(bboxpolygon)
+         numFeatures = self.ogrlayer.GetFeatureCount()
+         # if no features are in bbox, return all features as shapesInRegion
+         # (PostGIS sometimes returns no features even if they are within
+         #  the bounding box)
+         if numFeatures == 0:
+             self.ogrlayer.SetSpatialFilter(None)
+             numFeatures = self.ogrlayer.GetFeatureCount()
          for feature in range(numFeatures):
-             nextFeature = ogrlayer.GetNextFeature()
+             nextFeature = self.ogrlayer.GetNextFeature()
-             yield cls(ogrlayer, nextFeature.GetFID())
+             if self.id_column is None:
-         ogrlayer.SetSpatialFilter(None)
+                 yield self.shapes[nextFeature.GetFID()]
+             else:
+                 yield self.shapes[nextFeature.GetField(self.id_column)]
+         self.ogrlayer.SetSpatialFilter(None)
          bboxpolygon.Destroy()
      def AllShapes(self):
-         """Return an iterable over the shapes in the shape store."""
+         """Return an iterable over the shapes in the shape store.
-         for i in xrange(self.NumShapes()):
+         """
-             yield OGRShape(self.ogrlayer, i)
+         for id in range(len(self.shapes)):
+             yield self.shapes[id]
-     def Shape(self, index):
-         """Return the shape with index index"""
+     def Shape(self, fid):
-         return OGRShape(self.ogrlayer, index)
+         """Return the shape with fid = fid
+         """
+         if fid in self.table.ids.keys():
+             return self.shapes[fid]
+         else:
+             return None
      def Table(self):
-         """Return the table containing the attribute data"""
+         """Return the table containing the attribute data
+         """
          return self.table
      def Dependencies(self):
-         """Return the empty tuple."""
+         """Return the empty tuple.
+         """
          return ()
      def OrigShapeStore(self):
          """Return None."""
          return None
+     def Id_column(self):
+         """Return the id_column.
+         """
+         return self.id_column
- class OGRTable:
+ class OGRTable(transientdb.AutoTransientTable):
+     """A Table for an ogr datasource.
-     """A Table for an ogr file
      """
-     def __init__(self, ds, layer):
+     def __init__(self, session, ds, layer, id_column):
          """Initialize the OGRTable.
-         ds should be an instance of OGRDatasource.
+         session   - should be the current session.
-         layer should be an instance of OGRLayer.
+         ds        - should be an instance of OGRDatasource.
+         layer     - should be an instance of OGRLayer.
+         id_column - should be the name of the column used as ID column
          """
          self.datasource = ds
          self.layer = layer
-         self.tablename = layer.GetName()
+         self.tablename = self.layer.GetName()
+         self.id_column = id_column
          # Map column names and indices to column objects.
          self.column_map = {}
+         # Map feature ids to ordinals.
+         self._map_ords_and_ids()
          self._fetch_table_information()
+         self._fetch_table_content()
+         transientdb.AutoTransientTable.__init__(self, session.TransientDB(),
+                                                 self)
      def _fetch_table_information(self):
-         """Internal: Update information about the table"""
+         """Internal: Update information about the table
+         """
          self.columns = []
          layerdefn = self.layer.GetLayerDefn()
+         # if FID column is of interest
+         #col = OGRColumn("FID", table.FIELDTYPE_INT, layerdefn.GetFieldCount())
+         #self.columns.append(col)
          for i in range(layerdefn.GetFieldCount()):
              fielddef = layerdefn.GetFieldDefn(i)
              fieldname = fielddef.GetName()
-Line 275 
 class OGRTable:
+Line 466 
 class OGRTable:
              self.column_map[col.name] = col
              self.column_map[col.index] = col
+     def _fetch_table_content(self):
+         """Internal: Update information contained in the table
+         """
+         self.content = []
+         layerdefn = self.layer.GetLayerDefn()
+         self.layer.ResetReading()
+         for i in range(self.layer.GetFeatureCount()):
+             nextFeature = self.layer.GetNextFeature()
+             row = []
+             for j in range(layerdefn.GetFieldCount()):
+                 row.append(nextFeature.GetField(j))
+             # if FID should be listed in the table
+             #if self.id_column is None:
+             #    row.append(nextFeature.GetFID())
+             #else:
+             #    row.append(nextFeature.GetField(self.id_column))
+             self.content.append(row)
+     def _map_ords_and_ids(self):
+         """Create collections which map ordinals to ids and verse visa.
+         """
+         self.ordinals = {}
+         self.ids = {}
+         if self.id_column is not None:
+             lay = self.datasource.ExecuteSQL("SELECT %s from %s"
+                     %(self.id_column, self.tablename))
+             lay.ResetReading()
+             nextFeature = lay.GetNextFeature()
+         else:
+             self.layer.ResetReading()
+             nextFeature = self.layer.GetNextFeature()
+         ord = 0
+         while nextFeature is not None:
+             if self.id_column is not None:
+                 id = nextFeature.GetField(self.id_column)
+                 nextFeature = lay.GetNextFeature()
+             else:
+                 id = nextFeature.GetFID()
+                 nextFeature = self.layer.GetNextFeature()
+             self.ordinals[ord] = id
+             self.ids[id] = ord
+             ord = ord + 1
+         if self.id_column is not None:
+             self.datasource.ReleaseResultSet(lay)
      def TableName(self):
-         """Return the name of the table, which is the name of the layer"""
+         """Return the name of the table, which is the name of the layer
+         """
          return self.tablename
      def Title(self):
          """Return the title of the table.
-         The title is currently fixed and equal to the tablename
          """
          return self.tablename
      def Dependencies(self):
-         """Return an empty tuple."""
+         """Return an empty tuple.
+         """
          return ()
      def NumColumns(self):
-         """Return the number of columns."""
+         """Return the number of columns.
+         """
          return len(self.columns)
      def Columns(self):
-         """Return all columns."""
+         """Return all columns.
+         """
          return self.columns
      def Column(self, col):
-         """Return the column col. col can be either a string or an integer."""
+         """Return the column col. col can be either a string or an integer.
+         """
          return self.column_map[col]
      def HasColumn(self, col):
          """Return if column col exists. col can be either a string or an
          integer.
          """
          return self.column_map.has_key(col)
      def NumRows(self):
          """Return the number of rows in the table, which equals the number of
          features in the layer.
          """
-         return self.layer.GetFeatureCount()
+         return len(self.ids)
      def RowIdToOrdinal(self, gid):
-         """Return the row ordinal given its id"""
+         """Return the row ordinal given its id
-         return self.layer.GetFeature(gid).GetFID()
+         """
+         if gid < 0:
+             return gid
+         else:
+             ord = self.ids[gid]
+             return ord
      def RowOrdinalToId(self, num):
-         """Return the rowid for given its ordinal"""
+         """Return the rowid for given its ordinal
-         return self.layer.GetFeature(num).GetFID()
+         """
+         if num >= 0:
+             id = self.ordinals[num]
+             return id
+         else:
+             return num
      def ReadRowAsDict(self, row, row_is_ordinal = 0):
-         """Return a dictionary which contains all the fields."""
+         """Return a dictionary which contains all the fields.
-         layerdef = self.layer.GetLayerDefn()
+         """
-         feature = self.layer.GetFeature(row)
+         if row_is_ordinal == 0:
+             rowId = self.RowIdToOrdinal(row)
+         else:
+             rowId = row
          result = {}
-         for i in range(feature.GetFieldCount()):
+         for i in range(self.NumColumns()):
-             fielddef = layerdef.GetFieldDefn(i)
+             result[self.Column(i).name] = self.content[rowId][i]
-             result[fielddef.GetName()] = feature.GetField(i)
          return result
      def ReadValue(self, row, col, row_is_ordinal = 0):
-         """Return the requested value."""
+         """Return the requested value.
-         if col is None:
+         """
-             return None
+         if row_is_ordinal == 0:
+             rowId = self.RowIdToOrdinal(row)
          else:
-             feature = self.layer.GetFeature(row)
+             rowId = row
-         return feature.GetField(col)
+         colIndex = self.column_map[col].index
+         return self.content[rowId][colIndex]
      def ValueRange(self, col):
-         """Return the value range of the given column (given as string)."""
+         """Return the value range of the given column (given as string).
+         """
          result = self.datasource.ExecuteSQL("SELECT min(%s), max(%s) FROM %s"
                  %(col, col, self.layer.GetName()))
          result.ResetReading()
-Line 371 
 class OGRTable:
+Line 629 
 class OGRTable:
          return values
      def SimpleQuery(self, left, comparison, right):
-         """Return the FIDs resulting from the given query."""
+         """Return the FIDs resulting from the given query.
+         """
          if comparison not in ("==", "!=", "<", "<=", ">=", ">"):
              raise ValueError("Comparison operator %r not allowed" %comparison)
-Line 383 
 class OGRTable:
+Line 643 
 class OGRTable:
          else:
              right_template = right
-         query = ("SELECT FID FROM %s WHERE '%s' %s %s ORDER BY FID"
+         if self.id_column is None:
-                 % (self.tablename,left.name, comparison, right_template))
+             id = "FID"
+         else:
+             id = self.id_column
+         query = ("SELECT %s FROM %s WHERE %s %s %s ORDER BY %s"
+                 % (id, self.tablename,left.name, comparison,
+                    right_template, id))
          lay = self.datasource.ExecuteSQL(query)
          result = []
-Line 393 
 class OGRTable:
+Line 658 
 class OGRTable:
              if feature is None:
                  break
              result.append(feature.GetField(0))
-         self.datasource.ReleaseResultSet(lay)
+         if lay is not None:
+             self.datasource.ReleaseResultSet(lay)
          return result
+     def Id_column(self):
+         """Return the id_column.
+         """
+         return self.id_column
- class OGRColumn:
+ class OGRColumn:
      """Column description for a table for an ogr file
      """

 Legend:



Removed from v.2493
 


changed lines


 
Added in v.2577
 Legend:



Removed from v.2493
 


changed lines


 
Added in v.2577
-Removed from v.2493
+Added in v.2577

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26