Extensions/ogr/ogrshapes.py

# Copyright (C) 2004 by Intevation GmbH
# Authors:
# Nina Hueffmeyer <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

__version__ = "$Revision$"
# $Source$
# $Id$

from __future__ import generators

try:
    import ogr
except ImportError:
    ogr = None

import os
import weakref
from math import ceil, log

from Thuban import _
from Thuban.Model import table

from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
from Thuban.Model.data import RAW_PYTHON, RAW_SHAPEFILE, RAW_WKT

SHAPETYPE_UNKNOWN = "unknown"

def has_ogr_support():
    """Return whether this Thuban instance supports ogr file formats

    Having OGR support means that the ogr module can be
    imported.
    """
    return ogr is not None

if ogr is not None:
    # mapping from ogr-lib shapetype and table constants to our constants
    ogrlib_shapetypes = {ogr.wkbPolygon: SHAPETYPE_POLYGON,
                ogr.wkbLineString: SHAPETYPE_ARC,
                ogr.wkbPoint: SHAPETYPE_POINT,
                ogr.wkbUnknown: SHAPETYPE_UNKNOWN}

    fieldtype_map = {ogr.OFTString: table.FIELDTYPE_STRING,
                ogr.OFTInteger: table.FIELDTYPE_INT,
                ogr.OFTReal: table.FIELDTYPE_DOUBLE}


class OGRShape:

    """Represent one shape of an OGRShapeStore"""

    def __init__(self, ogrlayer, shapeid):
        self.ogrlayer = ogrlayer
        self.shapeid = shapeid

    def compute_bbox(self):
        """
        Return the bounding box of the shape as a tuple (minx,miny,maxx,maxy)
        """
        shape = self.ogrlayer.GetFeature(self.shapeid)
        geom = shape.GetGeometryRef()
        minx, maxx, miny, maxy = geom.GetEnvelope()
        return (minx, miny, maxx, maxy)

    def ShapeID(self):
        return self.shapeid

    def Points(self):
        """Return the coordinates of the shape as a list of lists of pairs"""
        print "FID: %s" %(self.shapeid)
        shape = []
        #spatialFilter = self.ogrlayer.GetSpatialFilter()
        
#        if spatialFilter is not None:
        self.ogrlayer.SetSpatialFilter(None)
  #          feature = self.ogrlayer.GetFeature(self.shapeid)
   #         self.ogrlayer.SetSpatialFilter(spatialFilter)
    #    else:
        feature = self.ogrlayer.GetFeature(self.shapeid)
      
        if feature is None:
            print "feature is none.........................."
            return shape.append([])
        geom = feature.GetGeometryRef()

        if geom is None:
            print "geom is none................................"
            return shape.append([])

        # if geometry object is of type point or line
        if geom.GetGeometryCount() == 0:
            points =[]
            for point in range(geom.GetPointCount()):
                x = geom.GetX(point)
                y = geom.GetY(point)
                points.append((x, y))
            print points
            return [points]
        # if geometry object is of type polygon or multipolygon
        for i in range(geom.GetGeometryCount()):
            points = []
            geometry = 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
            else:
                for j in range(geometry.GetGeometryCount()):
                    points = []
                    subgeom = geometry.GetGeometryRef(j)
                    for point in range(subgeom.GetPointCount()):
                        x = subgeom.GetX(point)
                        y = subgeom.GetY(point)
                        points.append((x, y))
                    shape.append(points)
        print shape
        return shape

    def RawData(self):
        """Return the shape id to use with the shapestore"""
        return self.shapeid

    def OGRLayer(self):
        """Return the ogrlayer object"""
        return self.ogrlayer


class OGRShapeStore:

    """Corresponds to an OGRLayer object, containing features/shapes and 
       providing all methods Thuban needs.
    """

    def __init__(self, session, filename, layername):
        # Make the filename absolute. The filename will be
        # 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 = filename
        self.layername = layername

        self.ogrdatasource = ogr.Open(filename)
        self.ogrlayer = (self.ogrdatasource).GetLayerByName(layername)

        driver = self.ogrdatasource.GetDriver().GetName()
        if driver == 'PostgreSQL':
            self.id_column = 'gid'
        else:
            self.id_column = 'fid'

        self.table = OGRTable(self.ogrdatasource, self.ogrlayer, self.id_column)

        self._open_ogrlayer(layername)

    def _open_ogrlayer(self, layername):
        self.numshapes = self.ogrlayer.GetFeatureCount()
        self.shapetype = self.ogrlayer.GetLayerDefn().GetGeomType()

        extent = self.ogrlayer.GetExtent()
        if extent:
            self.bbox = [extent[0], extent[2], extent[1], extent[3]]
        else:
            self.bbox = None

        if self.shapetype is not ogr.wkbUnknown:
            self.shapetype = ogrlib_shapetypes[self.shapetype]
        #else:
            # this should be ogr.wkbUnknown, but Thuban does not know how 
            # to handle an unknown shapetype (e.g. Session Tree)
            #self.shapetype = ogrlib_shapetypes[ogr.wkbPoint]

    def OGRLayer(self):
        """Return the OGRLayer object"""
        return self.ogrlayer

    def FileName(self):
        """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 "ogr-file"

    def ShapeType(self):
        """Return the type of the shapes in the shapestore.

        This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.
        """
        return self.shapetype

    def RawShapeFormat(self):
        """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 self.numshapes

    def BoundingBox(self):
        """Return the bounding box of the shapes in the shapestore.
        """
        return self.bbox

    def ShapesInRegion(self, bbox):
        """Return an iterable over the shapes that overlap the bounding box.

        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
        print "features in bbox: "
        print ('Polygon((%s %s, %s %s, %s %s,%s %s, %s %s))'
                                 %(left, bottom, left, top, right, top, 
                                  right, bottom, left, bottom))
        # 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():
            bboxpolygon.AssignSpatialReference(ogrlayer.GetSpatialRef())

        ogrlayer.ResetReading()
        #ogrlayer.SetSpatialFilterRect(left, bottom, right, top)
        ogrlayer.SetSpatialFilter(bboxpolygon)
        numFeatures = ogrlayer.GetFeatureCount()
        print numFeatures
        for feature in range(numFeatures):
            nextFeature = ogrlayer.GetNextFeature()
            yield cls(ogrlayer, nextFeature.GetFID())
        ogrlayer.SetSpatialFilter(None)
        bboxpolygon.Destroy()

    def AllShapes(self):
        """Return an iterable over the shapes in the shape store."""
        self.ogrlayer.ResetReading()
        nextFeature = self.ogrlayer.GetNextFeature()
        while nextFeature is not None:
            yield OGRShape(self.ogrlayer, nextFeature.GetFID())
            nextFeature = self.ogrlayer.GetNextFeature()

    def Shape(self, index):
        """Return the shape with index index"""
        return OGRShape(self.ogrlayer, index)

    def Table(self):
        """Return the table containing the attribute data"""
        return self.table

    def Dependencies(self):
        """Return the empty tuple."""
        return ()

    def OrigShapeStore(self):
        """Return None."""
        return None


class OGRTable:

    """A Table for an ogr file
    """

    def __init__(self, ds, layer, id_column):
        """Initialize the OGRTable.

        ds should be an instance of OGRDatasource.
        layer should be an instance of OGRLayer.
        """

        self.datasource = ds
        self.layer = layer
        self.tablename = 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()

    def _fetch_table_information(self):
        """Internal: Update information about the table"""
        self.columns = []

        layerdefn = self.layer.GetLayerDefn()
        for i in range(layerdefn.GetFieldCount()):
            fielddef = layerdefn.GetFieldDefn(i)
            fieldname = fielddef.GetName()
            fieldtype = fieldtype_map[fielddef.GetType()]
            fieldindex = layerdefn.GetFieldIndex(fieldname)
            col = OGRColumn(fieldname, fieldtype, fieldindex)
            if col is not None:
                self.columns.append(col)

        for col in self.columns:
            self.column_map[col.name] = col
            self.column_map[col.index] = col

    def _map_ords_and_ids(self):
        self.ordinals = {}
        self.ids = {}

        lay = self.datasource.ExecuteSQL(
                "SELECT %s from %s"
                %(self.id_column, self.tablename))
        lay.ResetReading()
        nextFeature = lay.GetNextFeature()
        ord = 0
        while nextFeature is not None:
            id = nextFeature.GetFID()
            self.ordinals[ord] = id
            self.ids[id] = ord
            nextFeature = lay.GetNextFeature()
            ord = ord + 1
        self.datasource.ReleaseResultSet(lay)

    def TableName(self):
        """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
        """
        return self.tablename

    def Dependencies(self):
        """Return an empty tuple."""
        return ()

    def NumColumns(self):
        """Return the number of columns."""
        return len(self.columns)

    def Columns(self):
        """Return all columns."""
        return self.columns

    def Column(self, col):
        """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()

    def RowIdToOrdinal(self, gid):
        """Return the row ordinal given its id"""
        if gid < 0:
            return gid
        else:
            ord = self.ids[gid]
            return ord
#        lay = self.datasource.ExecuteSQL(
 #               "SELECT COUNT(%s) From %s where FID < %s"
  #              %(self.id_column, self.tablename, gid))
   #     ord = lay.GetFeature(0).GetField(0)
    #    self.datasource.ReleaseResultSet(lay)
 #       return ord

    def RowOrdinalToId(self, num):
        """Return the rowid for given its ordinal"""
#        lay = self.datasource.ExecuteSQL(
 #               "SELECT FID From %s"
  #              %(self.tablename))
   #     for i in range(num):
    #        lay.GetNextFeature()
     #   id = lay.GetNextFeature().GetField(0)
      #  self.datasource.ReleaseResultSet(lay)
        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."""
        if row_is_ordinal == 1:
            rowId = self.RowOrdinalToId(row)
        else:
            rowId = row
        layerdef = self.layer.GetLayerDefn()
        feature = self.layer.GetFeature(rowId)
        result = {}
        for i in range(len(self.columns)):
            fielddef = layerdef.GetFieldDefn(i)
            if feature is not None:
                result[self.columns[i].name] = feature.GetField(i)
            else:
                result[fielddef.GetName()] = None
        return result

    def ReadValue(self, row, col, row_is_ordinal = 0):
        """Return the requested value."""
        if col is None:
            return None
        else:
            feature = self.layer.GetFeature(row)
        return feature.GetField(col)

    def ValueRange(self, col):
        """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()
        feature = result.GetNextFeature()
        try:
            min = feature.GetField(0)
            max = feature.GetField(1)
        except:
            min = 0
            max = 0
        self.datasource.ReleaseResultSet(result)
        return (min, max)

    def UniqueValues(self, col):
        """Return all the values being found in the column (given as string).
        """
        result = self.datasource.ExecuteSQL((
                    "SELECT DISTINCT %s FROM %s ORDER BY %s"
                     %(col,self.layer.GetName(),col)))
        values = []
        while 1:
            feature = result.GetNextFeature()
            if feature is None:
                break
            values.append(feature.GetField(0))
        self.datasource.ReleaseResultSet(result)
        return values

    def SimpleQuery(self, left, comparison, right):
        """Return the FIDs resulting from the given query."""
        if comparison not in ("==", "!=", "<", "<=", ">=", ">"):
            raise ValueError("Comparison operator %r not allowed" %comparison)

        if comparison == "==":
            comparison = "="

        if isinstance(right, OGRColumn):
            right_template = right.name
        else:
            right_template = right

        query = ("SELECT %s FROM %s WHERE '%s' %s %s ORDER BY FID"
                % (self.id_column, self.tablename,left.name, comparison, 
                   right_template))

        lay = self.datasource.ExecuteSQL(query)
        result = []
        while lay is not None:
            feature = lay.GetNextFeature()
            if feature is None:
                break
            result.append(feature.GetField(0))
        if lay is not None:
            self.datasource.ReleaseResultSet(lay)
        return result


class OGRColumn:

    """Column description for a table for an ogr file
    """

    def __init__(self, name, type, index):
        self.name = name
        self.type = type
        self.index = index
1	nhueffme	2435	# Copyright (C) 2004 by Intevation GmbH
2			# Authors:
3	nhueffme	2493	# Nina Hueffmeyer <[email protected]>
4	nhueffme	2435	#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with the software for details.
7
8			__version__ = "$Revision$"
9			# $Source$
10			# $Id$
11
12			from __future__ import generators
13
14			try:
15			import ogr
16			except ImportError:
17			ogr = None
18
19			import os
20			import weakref
21			from math import ceil, log
22
23			from Thuban import _
24			from Thuban.Model import table
25
26			from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
27			from Thuban.Model.data import RAW_PYTHON, RAW_SHAPEFILE, RAW_WKT
28
29	nhueffme	2549	SHAPETYPE_UNKNOWN = "unknown"
30	nhueffme	2435
31			def has_ogr_support():
32			"""Return whether this Thuban instance supports ogr file formats
33
34			Having OGR support means that the ogr module can be
35			imported.
36			"""
37			return ogr is not None
38
39			if ogr is not None:
40			# mapping from ogr-lib shapetype and table constants to our constants
41			ogrlib_shapetypes = {ogr.wkbPolygon: SHAPETYPE_POLYGON,
42	nhueffme	2493	ogr.wkbLineString: SHAPETYPE_ARC,
43	nhueffme	2549	ogr.wkbPoint: SHAPETYPE_POINT,
44			ogr.wkbUnknown: SHAPETYPE_UNKNOWN}
45	nhueffme	2435
46			fieldtype_map = {ogr.OFTString: table.FIELDTYPE_STRING,
47	nhueffme	2493	ogr.OFTInteger: table.FIELDTYPE_INT,
48			ogr.OFTReal: table.FIELDTYPE_DOUBLE}
49	nhueffme	2435
50
51			class OGRShape:
52
53			"""Represent one shape of an OGRShapeStore"""
54
55			def __init__(self, ogrlayer, shapeid):
56			self.ogrlayer = ogrlayer
57			self.shapeid = shapeid
58
59			def compute_bbox(self):
60			"""
61			Return the bounding box of the shape as a tuple (minx,miny,maxx,maxy)
62			"""
63	nhueffme	2493	shape = self.ogrlayer.GetFeature(self.shapeid)
64			geom = shape.GetGeometryRef()
65			minx, maxx, miny, maxy = geom.GetEnvelope()
66			return (minx, miny, maxx, maxy)
67	nhueffme	2435
68			def ShapeID(self):
69			return self.shapeid
70
71			def Points(self):
72			"""Return the coordinates of the shape as a list of lists of pairs"""
73	nhueffme	2549	print "FID: %s" %(self.shapeid)
74			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	nhueffme	2435	feature = self.ogrlayer.GetFeature(self.shapeid)
83	nhueffme	2549
84			if feature is None:
85			print "feature is none.........................."
86			return shape.append([])
87	nhueffme	2493	geom = feature.GetGeometryRef()
88	nhueffme	2549
89			if geom is None:
90			print "geom is none................................"
91			return shape.append([])
92
93	nhueffme	2493	# if geometry object is of type point or line
94			if geom.GetGeometryCount() == 0:
95			points =[]
96			for point in range(geom.GetPointCount()):
97			x = geom.GetX(point)
98			y = geom.GetY(point)
99			points.append((x, y))
100	nhueffme	2549	print points
101	nhueffme	2493	return [points]
102			# if geometry object is of type polygon or multipolygon
103			for i in range(geom.GetGeometryCount()):
104			points = []
105	nhueffme	2549	geometry = geom.GetGeometryRef(i)
106			# if geometry object is polygon
107	nhueffme	2493	if geometry.GetGeometryCount() == 0:
108			for point in range(geometry.GetPointCount()):
109			x = geometry.GetX(point)
110			y = geometry.GetY(point)
111			points.append((x, y))
112			shape.append(points)
113			# if geometry object is of type multipolygon
114	nhueffme	2549	else:
115	nhueffme	2493	for j in range(geometry.GetGeometryCount()):
116			points = []
117			subgeom = geometry.GetGeometryRef(j)
118			for point in range(subgeom.GetPointCount()):
119			x = subgeom.GetX(point)
120			y = subgeom.GetY(point)
121			points.append((x, y))
122			shape.append(points)
123	nhueffme	2549	print shape
124	nhueffme	2493	return shape
125	nhueffme	2435
126			def RawData(self):
127			"""Return the shape id to use with the shapestore"""
128			return self.shapeid
129
130			def OGRLayer(self):
131			"""Return the ogrlayer object"""
132			return self.ogrlayer
133
134
135			class OGRShapeStore:
136
137	nhueffme	2493	"""Corresponds to an OGRLayer object, containing features/shapes and
138			providing all methods Thuban needs.
139			"""
140	nhueffme	2435
141			def __init__(self, session, filename, layername):
142			# Make the filename absolute. The filename will be
143			# interpreted relative to that anyway, but when saving a
144			# session we need to compare absolute paths and it's usually
145			# safer to always work with absolute paths.
146
147	nhueffme	2549	self.filename = filename
148	nhueffme	2493	self.layername = layername
149	nhueffme	2435
150	nhueffme	2549	self.ogrdatasource = ogr.Open(filename)
151	nhueffme	2493	self.ogrlayer = (self.ogrdatasource).GetLayerByName(layername)
152	nhueffme	2435
153	nhueffme	2549	driver = self.ogrdatasource.GetDriver().GetName()
154			if driver == 'PostgreSQL':
155			self.id_column = 'gid'
156			else:
157			self.id_column = 'fid'
158
159			self.table = OGRTable(self.ogrdatasource, self.ogrlayer, self.id_column)
160
161	nhueffme	2435	self._open_ogrlayer(layername)
162
163			def _open_ogrlayer(self, layername):
164	nhueffme	2493	self.numshapes = self.ogrlayer.GetFeatureCount()
165			self.shapetype = self.ogrlayer.GetLayerDefn().GetGeomType()
166	nhueffme	2549
167	nhueffme	2493	extent = self.ogrlayer.GetExtent()
168			if extent:
169			self.bbox = [extent[0], extent[2], extent[1], extent[3]]
170			else:
171			self.bbox = None
172	nhueffme	2435
173	nhueffme	2549	if self.shapetype is not ogr.wkbUnknown:
174			self.shapetype = ogrlib_shapetypes[self.shapetype]
175			#else:
176			# this should be ogr.wkbUnknown, but Thuban does not know how
177			# to handle an unknown shapetype (e.g. Session Tree)
178			#self.shapetype = ogrlib_shapetypes[ogr.wkbPoint]
179	nhueffme	2435
180			def OGRLayer(self):
181			"""Return the OGRLayer object"""
182			return self.ogrlayer
183
184			def FileName(self):
185			"""Return the filename used to open the file"""
186			return self.filename
187
188			def FileType(self):
189			"""Return the filetype. This is always the string 'ogr-file'"""
190			return "ogr-file"
191
192			def ShapeType(self):
193			"""Return the type of the shapes in the shapestore.
194
195			This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.
196			"""
197			return self.shapetype
198
199			def RawShapeFormat(self):
200	nhueffme	2493	"""Return the raw data format of the shape data, i.e. RAW_PYTHON"""
201			return RAW_PYTHON
202	nhueffme	2435
203			def NumShapes(self):
204			"""Return the number of shapes in the shape store"""
205			return self.numshapes
206
207			def BoundingBox(self):
208			"""Return the bounding box of the shapes in the shapestore.
209			"""
210			return self.bbox
211
212			def ShapesInRegion(self, bbox):
213			"""Return an iterable over the shapes that overlap the bounding box.
214
215			The bbox parameter should be the bounding box as a tuple in the
216			form (minx, miny, maxx, maxy) in the coordinate system of the
217			shape store.
218
219	nhueffme	2493	The method GetFID() returns feature IDs starting from 0.
220	nhueffme	2435	"""
221			# Bind a few globals to locals to make it a bit faster
222			cls = OGRShape
223			ogrlayer = self.ogrlayer
224
225			left, bottom, right, top = bbox
226	nhueffme	2549	print "features in bbox: "
227			print ('Polygon((%s %s, %s %s, %s %s,%s %s, %s %s))'
228			%(left, bottom, left, top, right, top,
229			right, bottom, left, bottom))
230	nhueffme	2493	# create a geometry which can be passed to the layer as spatial filter
231			bboxpolygon = ogr.CreateGeometryFromWkt(
232			('Polygon((%s %s, %s %s, %s %s,%s %s, %s %s))'
233			%(left, bottom, left, top, right, top,
234			right, bottom, left, bottom)))
235	nhueffme	2435
236	nhueffme	2493	if ogrlayer.GetSpatialRef():
237			bboxpolygon.AssignSpatialReference(ogrlayer.GetSpatialRef())
238	nhueffme	2435
239	nhueffme	2493	ogrlayer.ResetReading()
240	nhueffme	2549	#ogrlayer.SetSpatialFilterRect(left, bottom, right, top)
241	nhueffme	2493	ogrlayer.SetSpatialFilter(bboxpolygon)
242			numFeatures = ogrlayer.GetFeatureCount()
243	nhueffme	2549	print numFeatures
244	nhueffme	2493	for feature in range(numFeatures):
245			nextFeature = ogrlayer.GetNextFeature()
246			yield cls(ogrlayer, nextFeature.GetFID())
247			ogrlayer.SetSpatialFilter(None)
248			bboxpolygon.Destroy()
249	nhueffme	2435
250			def AllShapes(self):
251			"""Return an iterable over the shapes in the shape store."""
252	nhueffme	2549	self.ogrlayer.ResetReading()
253			nextFeature = self.ogrlayer.GetNextFeature()
254			while nextFeature is not None:
255			yield OGRShape(self.ogrlayer, nextFeature.GetFID())
256			nextFeature = self.ogrlayer.GetNextFeature()
257	nhueffme	2435
258			def Shape(self, index):
259			"""Return the shape with index index"""
260			return OGRShape(self.ogrlayer, index)
261
262			def Table(self):
263			"""Return the table containing the attribute data"""
264			return self.table
265
266			def Dependencies(self):
267			"""Return the empty tuple."""
268			return ()
269
270			def OrigShapeStore(self):
271			"""Return None."""
272			return None
273
274
275			class OGRTable:
276
277			"""A Table for an ogr file
278			"""
279
280	nhueffme	2549	def __init__(self, ds, layer, id_column):
281	nhueffme	2435	"""Initialize the OGRTable.
282
283	nhueffme	2493	ds should be an instance of OGRDatasource.
284			layer should be an instance of OGRLayer.
285	nhueffme	2435	"""
286
287			self.datasource = ds
288			self.layer = layer
289	nhueffme	2493	self.tablename = layer.GetName()
290	nhueffme	2549	self.id_column = id_column
291	nhueffme	2435
292			# Map column names and indices to column objects.
293			self.column_map = {}
294
295	nhueffme	2549	# Map feature ids to ordinals.
296			self._map_ords_and_ids()
297
298	nhueffme	2435	self._fetch_table_information()
299
300			def _fetch_table_information(self):
301			"""Internal: Update information about the table"""
302			self.columns = []
303
304	nhueffme	2493	layerdefn = self.layer.GetLayerDefn()
305			for i in range(layerdefn.GetFieldCount()):
306			fielddef = layerdefn.GetFieldDefn(i)
307			fieldname = fielddef.GetName()
308			fieldtype = fieldtype_map[fielddef.GetType()]
309			fieldindex = layerdefn.GetFieldIndex(fieldname)
310			col = OGRColumn(fieldname, fieldtype, fieldindex)
311			if col is not None:
312			self.columns.append(col)
313	nhueffme	2435
314			for col in self.columns:
315			self.column_map[col.name] = col
316			self.column_map[col.index] = col
317
318	nhueffme	2549	def _map_ords_and_ids(self):
319			self.ordinals = {}
320			self.ids = {}
321
322			lay = self.datasource.ExecuteSQL(
323			"SELECT %s from %s"
324			%(self.id_column, self.tablename))
325			lay.ResetReading()
326			nextFeature = lay.GetNextFeature()
327			ord = 0
328			while nextFeature is not None:
329			id = nextFeature.GetFID()
330			self.ordinals[ord] = id
331			self.ids[id] = ord
332			nextFeature = lay.GetNextFeature()
333			ord = ord + 1
334			self.datasource.ReleaseResultSet(lay)
335
336	nhueffme	2435	def TableName(self):
337			"""Return the name of the table, which is the name of the layer"""
338			return self.tablename
339
340			def Title(self):
341			"""Return the title of the table.
342
343	nhueffme	2549	The title is currently
344	nhueffme	2435	"""
345			return self.tablename
346
347			def Dependencies(self):
348			"""Return an empty tuple."""
349			return ()
350
351			def NumColumns(self):
352	nhueffme	2493	"""Return the number of columns."""
353	nhueffme	2435	return len(self.columns)
354
355			def Columns(self):
356	nhueffme	2493	"""Return all columns."""
357	nhueffme	2435	return self.columns
358
359			def Column(self, col):
360	nhueffme	2493	"""Return the column col. col can be either a string or an integer."""
361	nhueffme	2435	return self.column_map[col]
362
363			def HasColumn(self, col):
364	nhueffme	2493	"""Return if column col exists. col can be either a string or an
365			integer.
366			"""
367	nhueffme	2435	return self.column_map.has_key(col)
368
369			def NumRows(self):
370	nhueffme	2493	"""Return the number of rows in the table, which equals the number of
371			features in the layer.
372			"""
373			return self.layer.GetFeatureCount()
374	nhueffme	2435
375			def RowIdToOrdinal(self, gid):
376			"""Return the row ordinal given its id"""
377	nhueffme	2549	if gid < 0:
378			return gid
379			else:
380			ord = self.ids[gid]
381			return ord
382			# lay = self.datasource.ExecuteSQL(
383			# "SELECT COUNT(%s) From %s where FID < %s"
384			# %(self.id_column, self.tablename, gid))
385			# ord = lay.GetFeature(0).GetField(0)
386			# self.datasource.ReleaseResultSet(lay)
387			# return ord
388	nhueffme	2435
389			def RowOrdinalToId(self, num):
390			"""Return the rowid for given its ordinal"""
391	nhueffme	2549	# lay = self.datasource.ExecuteSQL(
392			# "SELECT FID From %s"
393			# %(self.tablename))
394			# for i in range(num):
395			# lay.GetNextFeature()
396			# id = lay.GetNextFeature().GetField(0)
397			# self.datasource.ReleaseResultSet(lay)
398			if num >= 0:
399			id = self.ordinals[num]
400			return id
401			else:
402			return num
403	nhueffme	2435
404			def ReadRowAsDict(self, row, row_is_ordinal = 0):
405	nhueffme	2493	"""Return a dictionary which contains all the fields."""
406	nhueffme	2549	if row_is_ordinal == 1:
407			rowId = self.RowOrdinalToId(row)
408			else:
409			rowId = row
410	nhueffme	2493	layerdef = self.layer.GetLayerDefn()
411	nhueffme	2549	feature = self.layer.GetFeature(rowId)
412	nhueffme	2493	result = {}
413	nhueffme	2549	for i in range(len(self.columns)):
414	nhueffme	2493	fielddef = layerdef.GetFieldDefn(i)
415	nhueffme	2549	if feature is not None:
416			result[self.columns[i].name] = feature.GetField(i)
417			else:
418			result[fielddef.GetName()] = None
419	nhueffme	2435	return result
420
421			def ReadValue(self, row, col, row_is_ordinal = 0):
422	nhueffme	2493	"""Return the requested value."""
423			if col is None:
424			return None
425			else:
426			feature = self.layer.GetFeature(row)
427			return feature.GetField(col)
428	nhueffme	2435
429			def ValueRange(self, col):
430	nhueffme	2493	"""Return the value range of the given column (given as string)."""
431			result = self.datasource.ExecuteSQL("SELECT min(%s), max(%s) FROM %s"
432			%(col, col, self.layer.GetName()))
433			result.ResetReading()
434			feature = result.GetNextFeature()
435			try:
436			min = feature.GetField(0)
437			max = feature.GetField(1)
438			except:
439			min = 0
440			max = 0
441			self.datasource.ReleaseResultSet(result)
442	nhueffme	2435	return (min, max)
443
444			def UniqueValues(self, col):
445	nhueffme	2493	"""Return all the values being found in the column (given as string).
446			"""
447			result = self.datasource.ExecuteSQL((
448			"SELECT DISTINCT %s FROM %s ORDER BY %s"
449			%(col,self.layer.GetName(),col)))
450			values = []
451			while 1:
452			feature = result.GetNextFeature()
453			if feature is None:
454			break
455			values.append(feature.GetField(0))
456			self.datasource.ReleaseResultSet(result)
457	nhueffme	2435	return values
458
459			def SimpleQuery(self, left, comparison, right):
460	nhueffme	2493	"""Return the FIDs resulting from the given query."""
461	nhueffme	2435	if comparison not in ("==", "!=", "<", "<=", ">=", ">"):
462	nhueffme	2493	raise ValueError("Comparison operator %r not allowed" %comparison)
463	nhueffme	2435
464			if comparison == "==":
465			comparison = "="
466
467			if isinstance(right, OGRColumn):
468			right_template = right.name
469			else:
470			right_template = right
471
472	nhueffme	2549	query = ("SELECT %s FROM %s WHERE '%s' %s %s ORDER BY FID"
473			% (self.id_column, self.tablename,left.name, comparison,
474			right_template))
475	nhueffme	2435
476			lay = self.datasource.ExecuteSQL(query)
477	nhueffme	2493	result = []
478			while lay is not None:
479	nhueffme	2435	feature = lay.GetNextFeature()
480			if feature is None:
481			break
482			result.append(feature.GetField(0))
483	nhueffme	2549	if lay is not None:
484			self.datasource.ReleaseResultSet(lay)
485	nhueffme	2435	return result
486
487
488			class OGRColumn:
489
490			"""Column description for a table for an ogr file
491			"""
492
493			def __init__(self, name, type, index):
494			self.name = name
495			self.type = type
496			self.index = index
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision