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

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

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

revision 2493 by nhueffme, Mon Dec 20 14:13:57 2004 UTC revision 2559 by nhueffme, Tue Feb 8 09:52:56 2005 UTC
# Line 26  from Thuban.Model import table Line 26  from Thuban.Model import table
26  from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT  from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
27  from Thuban.Model.data import RAW_PYTHON, RAW_SHAPEFILE, RAW_WKT  from Thuban.Model.data import RAW_PYTHON, RAW_SHAPEFILE, RAW_WKT
28    
29    SHAPETYPE_UNKNOWN = ogr.wkbUnknown
30    
31  def has_ogr_support():  def has_ogr_support():
32      """Return whether this Thuban instance supports ogr file formats      """Return whether this Thuban instance supports ogr file formats
# Line 39  if ogr is not None: Line 40  if ogr is not None:
40      # mapping from ogr-lib shapetype and table constants to our constants      # mapping from ogr-lib shapetype and table constants to our constants
41      ogrlib_shapetypes = {ogr.wkbPolygon: SHAPETYPE_POLYGON,      ogrlib_shapetypes = {ogr.wkbPolygon: SHAPETYPE_POLYGON,
42                  ogr.wkbLineString: SHAPETYPE_ARC,                  ogr.wkbLineString: SHAPETYPE_ARC,
43                  ogr.wkbPoint: SHAPETYPE_POINT}                  ogr.wkbPoint: SHAPETYPE_POINT,
44                    ogr.wkbUnknown: SHAPETYPE_UNKNOWN}
45    
46      fieldtype_map = {ogr.OFTString: table.FIELDTYPE_STRING,      fieldtype_map = {ogr.OFTString: table.FIELDTYPE_STRING,
47                  ogr.OFTInteger: table.FIELDTYPE_INT,                  ogr.OFTInteger: table.FIELDTYPE_INT,
# Line 52  class OGRShape: Line 54  class OGRShape:
54    
55      def __init__(self, ogrlayer, shapeid):      def __init__(self, ogrlayer, shapeid):
56          self.ogrlayer = ogrlayer          self.ogrlayer = ogrlayer
57            self.feature = self.ogrlayer.GetFeature(shapeid)
58          self.shapeid = shapeid          self.shapeid = shapeid
59            self.geom = self.feature.GetGeometryRef()
60            self.shapetype = self.geom.GetGeometryType()
61    
62      def compute_bbox(self):      def compute_bbox(self):
63          """          """
64          Return the bounding box of the shape as a tuple (minx,miny,maxx,maxy)          Return the bounding box of the shape as a tuple (minx,miny,maxx,maxy)
65          """          """
66          shape = self.ogrlayer.GetFeature(self.shapeid)          minx, maxx, miny, maxy = self.geom.GetEnvelope()
         geom = shape.GetGeometryRef()  
         minx, maxx, miny, maxy = geom.GetEnvelope()  
67          return (minx, miny, maxx, maxy)          return (minx, miny, maxx, maxy)
68    
69      def ShapeID(self):      def ShapeID(self):
70          return self.shapeid          return self.shapeid
71    
     # 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().---------  
72      def Points(self):      def Points(self):
73          """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()  
74          shape = []          shape = []
75            #spatialFilter = self.ogrlayer.GetSpatialFilter()
76    
77            #if spatialFilter is not None:
78            #self.ogrlayer.SetSpatialFilter(None)
79                #feature = self.ogrlayer.GetFeature(self.shapeid)
80                #self.ogrlayer.SetSpatialFilter(spatialFilter)
81            #else:
82            #feature = self.ogrlayer.GetFeature(self.shapeid)
83    
84            #if feature is None:
85             #   return shape.append([])
86            #geom = feature.GetGeometryRef()
87    
88            if self.geom is None:
89                return shape.append([])
90    
91          # if geometry object is of type point or line          # if geometry object is of type point or line
92          if geom.GetGeometryCount() == 0:          if self.geom.GetGeometryCount() == 0:
93              points =[]              points =[]
94              for point in range(geom.GetPointCount()):              for point in range(self.geom.GetPointCount()):
95                  x = geom.GetX(point)                  x = self.geom.GetX(point)
96                  y = geom.GetY(point)                  y = self.geom.GetY(point)
97                  points.append((x, y))                  points.append((x, y))
98              return [points]              return [points]
99          # if geometry object is of type polygon or multipolygon          # if geometry object is of type polygon or multipolygon
100          for i in range(geom.GetGeometryCount()):          for i in range(self.geom.GetGeometryCount()):
101              points = []              points = []
102              geometry = geom.GetGeometryRef(i)              geometry = self.geom.GetGeometryRef(i)
103              # if geometry object is polygon              # if geometry object is polygon
104              if geometry.GetGeometryCount() == 0:              if geometry.GetGeometryCount() == 0:
105                  for point in range(geometry.GetPointCount()):                  for point in range(geometry.GetPointCount()):
106                      x = geometry.GetX(point)                      x = geometry.GetX(point)
# Line 96  class OGRShape: Line 108  class OGRShape:
108                      points.append((x, y))                      points.append((x, y))
109                  shape.append(points)                  shape.append(points)
110              # if geometry object is of type multipolygon              # if geometry object is of type multipolygon
111              else:              else:
112                  for j in range(geometry.GetGeometryCount()):                  for j in range(geometry.GetGeometryCount()):
113                      points = []                      points = []
114                      subgeom = geometry.GetGeometryRef(j)                      subgeom = geometry.GetGeometryRef(j)
# Line 115  class OGRShape: Line 127  class OGRShape:
127          """Return the ogrlayer object"""          """Return the ogrlayer object"""
128          return self.ogrlayer          return self.ogrlayer
129    
130        def ShapeType(self):
131            return self.shapetype
132    
133    
134  class OGRShapeStore:  class OGRShapeStore:
135    
# Line 122  class OGRShapeStore: Line 137  class OGRShapeStore:
137         providing all methods Thuban needs.         providing all methods Thuban needs.
138      """      """
139    
140      def __init__(self, session, filename, layername):      def __init__(self, filename, layername, id_column = None):
141          # Make the filename absolute. The filename will be          # Make the filename absolute. The filename will be
142          # interpreted relative to that anyway, but when saving a          # interpreted relative to that anyway, but when saving a
143          # session we need to compare absolute paths and it's usually          # session we need to compare absolute paths and it's usually
144          # safer to always work with absolute paths.          # safer to always work with absolute paths.
145    
146          self.filename = os.path.abspath(filename)          self.filename = filename
147          self.layername = layername          self.layername = layername
148    
149          self.ogrdatasource = ogr.Open(self.filename)          self.ogrdatasource = ogr.Open(filename)
150          self.ogrlayer = (self.ogrdatasource).GetLayerByName(layername)          self.ogrlayer = (self.ogrdatasource).GetLayerByName(layername)
151          self.table = OGRTable(self.ogrdatasource, self.ogrlayer)  
152            driver = self.ogrdatasource.GetDriver().GetName()
153            if driver == 'PostgreSQL':
154                self.id_column = 'gid'
155            else:
156                self.id_column = 'fid'
157    
158            self.table = OGRTable(self.ogrdatasource, self.ogrlayer, self.id_column)
159    
160          self._open_ogrlayer(layername)          self._open_ogrlayer(layername)
161    
162      def _open_ogrlayer(self, layername):      def _open_ogrlayer(self, layername):
163          self.numshapes = self.ogrlayer.GetFeatureCount()          self.numshapes = self.ogrlayer.GetFeatureCount()
164          self.shapetype = self.ogrlayer.GetLayerDefn().GetGeomType()          self.shapetype = self.ogrlayer.GetLayerDefn().GetGeomType()
         extent = self.ogrlayer.GetExtent()  
165    
166            extent = self.ogrlayer.GetExtent()
167          if extent:          if extent:
168              self.bbox = [extent[0], extent[2], extent[1], extent[3]]              self.bbox = [extent[0], extent[2], extent[1], extent[3]]
169          else:          else:
170              self.bbox = None              self.bbox = None
171    
172          self.shapetype = ogrlib_shapetypes[self.shapetype]          if self.shapetype is not ogr.wkbUnknown:
173                self.shapetype = ogrlib_shapetypes[self.shapetype]
174            #else:
175                # this should be ogr.wkbUnknown, but Thuban does not know how
176                # to handle an unknown shapetype (e.g. Session Tree)
177                #self.shapetype = ogrlib_shapetypes[ogr.wkbPoint]
178    
179      def OGRLayer(self):      def OGRLayer(self):
180          """Return the OGRLayer object"""          """Return the OGRLayer object"""
# Line 195  class OGRShapeStore: Line 222  class OGRShapeStore:
222          ogrlayer = self.ogrlayer          ogrlayer = self.ogrlayer
223    
224          left, bottom, right, top = bbox          left, bottom, right, top = bbox
   
225          # create a geometry which can be passed to the layer as spatial filter          # create a geometry which can be passed to the layer as spatial filter
226          bboxpolygon = ogr.CreateGeometryFromWkt(          bboxpolygon = ogr.CreateGeometryFromWkt(
227                        ('Polygon((%s %s, %s %s, %s %s,%s %s, %s %s))'                        ('Polygon((%s %s, %s %s, %s %s,%s %s, %s %s))'
# Line 206  class OGRShapeStore: Line 232  class OGRShapeStore:
232              bboxpolygon.AssignSpatialReference(ogrlayer.GetSpatialRef())              bboxpolygon.AssignSpatialReference(ogrlayer.GetSpatialRef())
233    
234          ogrlayer.ResetReading()          ogrlayer.ResetReading()
235            #ogrlayer.SetSpatialFilterRect(left, bottom, right, top)
236          ogrlayer.SetSpatialFilter(bboxpolygon)          ogrlayer.SetSpatialFilter(bboxpolygon)
237    
238          numFeatures = ogrlayer.GetFeatureCount()          numFeatures = ogrlayer.GetFeatureCount()
239          for feature in range(numFeatures):          for feature in range(numFeatures):
240              nextFeature = ogrlayer.GetNextFeature()              nextFeature = ogrlayer.GetNextFeature()
241              yield cls(ogrlayer, nextFeature.GetFID())              yield cls(ogrlayer, nextFeature.GetFID())
242    
243          ogrlayer.SetSpatialFilter(None)          ogrlayer.SetSpatialFilter(None)
244          bboxpolygon.Destroy()          bboxpolygon.Destroy()
245    
246      def AllShapes(self):      def AllShapes(self):
247          """Return an iterable over the shapes in the shape store."""          """Return an iterable over the shapes in the shape store."""
248          for i in xrange(self.NumShapes()):          self.ogrlayer.ResetReading()
249              yield OGRShape(self.ogrlayer, i)          nextFeature = self.ogrlayer.GetNextFeature()
250            while nextFeature is not None:
251                yield OGRShape(self.ogrlayer, nextFeature.GetFID())
252                nextFeature = self.ogrlayer.GetNextFeature()
253    
254      def Shape(self, index):      def Shape(self, index):
255          """Return the shape with index index"""          """Return the shape with index index"""
# Line 235  class OGRShapeStore: Line 267  class OGRShapeStore:
267          """Return None."""          """Return None."""
268          return None          return None
269    
270        def Id_column(self):
271            """Return the id_column."""
272            return self.id_column
273    
274  class OGRTable:  class OGRTable:
275    
276      """A Table for an ogr file      """A Table for an ogr file
277      """      """
278    
279      def __init__(self, ds, layer):      def __init__(self, ds, layer, id_column):
280          """Initialize the OGRTable.          """Initialize the OGRTable.
281    
282          ds should be an instance of OGRDatasource.          ds should be an instance of OGRDatasource.
# Line 251  class OGRTable: Line 286  class OGRTable:
286          self.datasource = ds          self.datasource = ds
287          self.layer = layer          self.layer = layer
288          self.tablename = layer.GetName()          self.tablename = layer.GetName()
289            self.id_column = id_column
290    
291          # Map column names and indices to column objects.          # Map column names and indices to column objects.
292          self.column_map = {}          self.column_map = {}
293    
294            # Map feature ids to ordinals.
295            self._map_ords_and_ids()
296    
297          self._fetch_table_information()          self._fetch_table_information()
298    
299      def _fetch_table_information(self):      def _fetch_table_information(self):
# Line 275  class OGRTable: Line 314  class OGRTable:
314              self.column_map[col.name] = col              self.column_map[col.name] = col
315              self.column_map[col.index] = col              self.column_map[col.index] = col
316    
317        def _map_ords_and_ids(self):
318            self.ordinals = {}
319            self.ids = {}
320    
321            lay = self.datasource.ExecuteSQL(
322                    "SELECT %s from %s"
323                    %(self.id_column, self.tablename))
324            lay.ResetReading()
325            nextFeature = lay.GetNextFeature()
326            ord = 0
327            while nextFeature is not None:
328                id = nextFeature.GetFID()
329                self.ordinals[ord] = id
330                self.ids[id] = ord
331                nextFeature = lay.GetNextFeature()
332                ord = ord + 1
333            self.datasource.ReleaseResultSet(lay)
334    
335      def TableName(self):      def TableName(self):
336          """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"""
337          return self.tablename          return self.tablename
# Line 282  class OGRTable: Line 339  class OGRTable:
339      def Title(self):      def Title(self):
340          """Return the title of the table.          """Return the title of the table.
341    
342          The title is currently fixed and equal to the tablename          The title is currently
343          """          """
344          return self.tablename          return self.tablename
345    
# Line 316  class OGRTable: Line 373  class OGRTable:
373    
374      def RowIdToOrdinal(self, gid):      def RowIdToOrdinal(self, gid):
375          """Return the row ordinal given its id"""          """Return the row ordinal given its id"""
376          return self.layer.GetFeature(gid).GetFID()          if gid < 0:
377                return gid
378            else:
379                ord = self.ids[gid]
380                return ord
381    #        lay = self.datasource.ExecuteSQL(
382     #               "SELECT COUNT(%s) From %s where FID < %s"
383      #              %(self.id_column, self.tablename, gid))
384       #     ord = lay.GetFeature(0).GetField(0)
385        #    self.datasource.ReleaseResultSet(lay)
386     #       return ord
387    
388      def RowOrdinalToId(self, num):      def RowOrdinalToId(self, num):
389          """Return the rowid for given its ordinal"""          """Return the rowid for given its ordinal"""
390          return self.layer.GetFeature(num).GetFID()  #        lay = self.datasource.ExecuteSQL(
391     #               "SELECT FID From %s"
392      #              %(self.tablename))
393       #     for i in range(num):
394        #        lay.GetNextFeature()
395         #   id = lay.GetNextFeature().GetField(0)
396          #  self.datasource.ReleaseResultSet(lay)
397            if num >= 0:
398                id = self.ordinals[num]
399                return id
400            else:
401                return num
402    
403      def ReadRowAsDict(self, row, row_is_ordinal = 0):      def ReadRowAsDict(self, row, row_is_ordinal = 0):
404          """Return a dictionary which contains all the fields."""          """Return a dictionary which contains all the fields."""
405            if row_is_ordinal == 1:
406                rowId = self.RowOrdinalToId(row)
407            else:
408                rowId = row
409          layerdef = self.layer.GetLayerDefn()          layerdef = self.layer.GetLayerDefn()
410          feature = self.layer.GetFeature(row)          feature = self.layer.GetFeature(rowId)
411          result = {}          result = {}
412          for i in range(feature.GetFieldCount()):          for i in range(len(self.columns)):
413              fielddef = layerdef.GetFieldDefn(i)              fielddef = layerdef.GetFieldDefn(i)
414              result[fielddef.GetName()] = feature.GetField(i)              if feature is not None:
415                    result[self.columns[i].name] = feature.GetField(i)
416                else:
417                    result[fielddef.GetName()] = None
418          return result          return result
419    
420      def ReadValue(self, row, col, row_is_ordinal = 0):      def ReadValue(self, row, col, row_is_ordinal = 0):
# Line 383  class OGRTable: Line 468  class OGRTable:
468          else:          else:
469              right_template = right              right_template = right
470    
471          query = ("SELECT FID FROM %s WHERE '%s' %s %s ORDER BY FID"          query = ("SELECT %s FROM %s WHERE '%s' %s %s ORDER BY FID"
472                  % (self.tablename,left.name, comparison, right_template))                  % (self.id_column, self.tablename,left.name, comparison,
473                       right_template))
474    
475          lay = self.datasource.ExecuteSQL(query)          lay = self.datasource.ExecuteSQL(query)
476          result = []          result = []
# Line 393  class OGRTable: Line 479  class OGRTable:
479              if feature is None:              if feature is None:
480                  break                  break
481              result.append(feature.GetField(0))              result.append(feature.GetField(0))
482          self.datasource.ReleaseResultSet(lay)          if lay is not None:
483                self.datasource.ReleaseResultSet(lay)
484          return result          return result
485    
486        def Id_column(self):
487            """Return the id_column."""
488            return self.id_column
489    
490    
491  class OGRColumn:  class OGRColumn:
492    
Legend:
Removed from v.2493  
changed lines
  Added in v.2559
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26