def ogr_basic_7():
feat_defn = ogr.FeatureDefn()
feat = ogr.Feature(feat_defn)
if not feat.Equal(feat):
return 'fail'
try:
feat.SetFieldIntegerList
except:
return 'skip'
feat_clone = feat.Clone()
if not feat.Equal(feat_clone):
return 'fail'
# We MUST delete now as we are changing the feature defn afterwards!
# Crash guaranteed otherwise
feat = None
feat_clone = None
field_defn = ogr.FieldDefn('field1', ogr.OFTInteger)
feat_defn.AddFieldDefn(field_defn)
field_defn = ogr.FieldDefn('field2', ogr.OFTReal)
feat_defn.AddFieldDefn(field_defn)
field_defn = ogr.FieldDefn('field3', ogr.OFTString)
feat_defn.AddFieldDefn(field_defn)
field_defn = ogr.FieldDefn('field4', ogr.OFTIntegerList)
feat_defn.AddFieldDefn(field_defn)
field_defn = ogr.FieldDefn('field5', ogr.OFTRealList)
feat_defn.AddFieldDefn(field_defn)
field_defn = ogr.FieldDefn('field6', ogr.OFTStringList)
feat_defn.AddFieldDefn(field_defn)
field_defn = ogr.FieldDefn('field7', ogr.OFTDate)
feat_defn.AddFieldDefn(field_defn)
field_defn = ogr.FieldDefn('field8', ogr.OFTTime)
feat_defn.AddFieldDefn(field_defn)
field_defn = ogr.FieldDefn('field9', ogr.OFTDateTime)
feat_defn.AddFieldDefn(field_defn)
field_defn = ogr.FieldDefn('field10', ogr.OFTBinary)
feat_defn.AddFieldDefn(field_defn)
field_defn = ogr.FieldDefn('field11', ogr.OFTInteger64)
feat_defn.AddFieldDefn(field_defn)
feat = ogr.Feature(feat_defn)
feat.SetFID(100)
feat.SetField(0, 1)
feat.SetField(1, 1.2)
feat.SetField(2, "A")
feat.SetFieldIntegerList(3, [1, 2])
feat.SetFieldDoubleList(4, [1.2, 3.4])
feat.SetFieldStringList(5, ["A", "B"])
feat.SetField(6, 2010, 1, 8, 22, 48, 15, 4)
feat.SetField(7, 2010, 1, 8, 22, 48, 15, 4)
feat.SetField(8, 2010, 1, 8, 22, 48, 15, 4)
feat.SetFieldBinaryFromHexString(9, '012345678ABCDEF')
feat.SetField(10, 1234567890123)
feat_clone = feat.Clone()
if not feat.Equal(feat_clone):
feat.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
geom = ogr.CreateGeometryFromWkt('POINT(0 1)')
feat_almost_clone.SetGeometry(geom)
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
geom = ogr.CreateGeometryFromWkt('POINT(0 1)')
feat.SetGeometry(geom)
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_clone = feat.Clone()
if not feat.Equal(feat_clone):
feat.DumpReadable()
feat_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetFID(99)
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetField(0, 2)
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetField(1, 2.2)
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetField(2, "B")
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetFieldIntegerList(3, [1, 2, 3])
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetFieldIntegerList(3, [1, 3])
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetFieldDoubleList(4, [1.2, 3.4, 5.6])
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetFieldDoubleList(4, [1.2, 3.5])
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetFieldStringList(5, ["A", "B", "C"])
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetFieldStringList(5, ["A", "D"])
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
for num_field in [6, 7, 8]:
for i in range(7):
feat_almost_clone = feat.Clone()
feat_almost_clone.SetField(num_field, 2010+(i==0), 1+(i==1),
8+(i==2), 22+(i==3), 48+(i==4),
15+(i==5), 4+(i==6))
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetFieldBinaryFromHexString(9, '00')
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetField(10, 2)
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
feat_almost_clone = feat.Clone()
feat_almost_clone.SetField(10, 2)
if feat.Equal(feat_almost_clone):
feat.DumpReadable()
feat_almost_clone.DumpReadable()
return 'fail'
return 'success'
def ogr_basic_12():
# boolean integer
feat_def = ogr.FeatureDefn()
if ogr.GetFieldSubTypeName(ogr.OFSTBoolean) != 'Boolean':
gdaltest.post_reason('fail')
return 'fail'
field_def = ogr.FieldDefn( 'fld', ogr.OFTInteger )
field_def.SetSubType( ogr.OFSTBoolean )
if field_def.GetSubType() != ogr.OFSTBoolean:
gdaltest.post_reason('fail')
return 'fail'
feat_def.AddFieldDefn( field_def )
f = ogr.Feature(feat_def)
f.SetField('fld', 0)
f.SetField('fld', 1)
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetField('fld', 2)
gdal.PopErrorHandler()
if gdal.GetLastErrorMsg() == '':
gdaltest.post_reason('fail')
return 'fail'
if f.GetField('fld') != 1:
gdaltest.post_reason('fail')
return 'fail'
f.SetField('fld', '0')
f.SetField('fld', '1')
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetField('fld', '2')
gdal.PopErrorHandler()
if gdal.GetLastErrorMsg() == '':
gdaltest.post_reason('fail')
return 'fail'
if f.GetField('fld') != 1:
gdaltest.post_reason('fail')
return 'fail'
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
field_def = ogr.FieldDefn( 'fld', ogr.OFTString )
field_def.SetSubType( ogr.OFSTBoolean )
gdal.PopErrorHandler()
if gdal.GetLastErrorMsg() == '':
gdaltest.post_reason('fail')
return 'fail'
if field_def.GetSubType() != ogr.OFSTNone:
gdaltest.post_reason('fail')
return 'fail'
# boolean list
feat_def = ogr.FeatureDefn()
field_def = ogr.FieldDefn( 'fld', ogr.OFTIntegerList )
field_def.SetSubType( ogr.OFSTBoolean )
if field_def.GetSubType() != ogr.OFSTBoolean:
gdaltest.post_reason('fail')
return 'fail'
feat_def.AddFieldDefn( field_def )
f = ogr.Feature(feat_def)
f.SetFieldIntegerList(0, [0,1])
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetFieldIntegerList(0, [0,1,2,1])
gdal.PopErrorHandler()
if gdal.GetLastErrorMsg() == '':
gdaltest.post_reason('fail')
return 'fail'
if f.GetField('fld') != [0,1,1,1]:
print(f.GetField('fld'))
gdaltest.post_reason('fail')
return 'fail'
# int16 integer
feat_def = ogr.FeatureDefn()
if ogr.GetFieldSubTypeName(ogr.OFSTInt16) != 'Int16':
gdaltest.post_reason('fail')
return 'fail'
field_def = ogr.FieldDefn( 'fld', ogr.OFTInteger )
field_def.SetSubType( ogr.OFSTInt16 )
if field_def.GetSubType() != ogr.OFSTInt16:
gdaltest.post_reason('fail')
return 'fail'
feat_def.AddFieldDefn( field_def )
f = ogr.Feature(feat_def)
f.SetField('fld', -32768)
f.SetField('fld', 32767)
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetField('fld', -32769)
gdal.PopErrorHandler()
if gdal.GetLastErrorMsg() == '':
gdaltest.post_reason('fail')
return 'fail'
if f.GetField('fld') != -32768:
gdaltest.post_reason('fail')
return 'fail'
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetField('fld', 32768)
gdal.PopErrorHandler()
if gdal.GetLastErrorMsg() == '':
gdaltest.post_reason('fail')
return 'fail'
if f.GetField('fld') != 32767:
gdaltest.post_reason('fail')
return 'fail'
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
field_def = ogr.FieldDefn( 'fld', ogr.OFTString )
field_def.SetSubType( ogr.OFSTInt16 )
gdal.PopErrorHandler()
if gdal.GetLastErrorMsg() == '':
gdaltest.post_reason('fail')
return 'fail'
if field_def.GetSubType() != ogr.OFSTNone:
gdaltest.post_reason('fail')
return 'fail'
# float32
feat_def = ogr.FeatureDefn()
if ogr.GetFieldSubTypeName(ogr.OFSTFloat32) != 'Float32':
gdaltest.post_reason('fail')
return 'fail'
field_def = ogr.FieldDefn( 'fld', ogr.OFTReal )
field_def.SetSubType( ogr.OFSTFloat32 )
if field_def.GetSubType() != ogr.OFSTFloat32:
gdaltest.post_reason('fail')
return 'fail'
feat_def.AddFieldDefn( field_def )
if False:
f = ogr.Feature(feat_def)
gdal.ErrorReset()
f.SetField('fld', '1.23')
if gdal.GetLastErrorMsg() != '':
gdaltest.post_reason('fail')
return 'fail'
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetField('fld', 1.230000000001)
gdal.PopErrorHandler()
if gdal.GetLastErrorMsg() == '':
gdaltest.post_reason('fail')
return 'fail'
if abs(f.GetField('fld') - 1.23) < 1e-8:
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
field_def = ogr.FieldDefn( 'fld', ogr.OFSTFloat32 )
field_def.SetSubType( ogr.OFSTInt16 )
gdal.PopErrorHandler()
if gdal.GetLastErrorMsg() == '':
gdaltest.post_reason('fail')
return 'fail'
if field_def.GetSubType() != ogr.OFSTNone:
gdaltest.post_reason('fail')
return 'fail'
return 'success'
def clipped_raster(dlg, feature, merged_array, downloader, TN_l_tot, TN_b_tot,
nr_of_tiles_x_tot, nr_of_tiles_y_tot):
################################################################
# STEP 1 -- PREPARE THE GDAL-FEATURE-LAYER
################################################################
# remove the Z-dimension and M-dimension, if present
abs_geom = feature.geometry().constGet()
abs_geom.dropZValue()
abs_geom.dropMValue()
# represent feature as WellKnownText-format so we can import it in ogr
feat_wkt = abs_geom.asWkt()
# create a memory vector driver and datasource for the feature
driver = ogr.GetDriverByName('Memory')
ds = driver.CreateDataSource('out')
# set srs
spa = SpatialReference()
spa.ImportFromEPSG(31287)
# create a layer
layer = ds.CreateLayer('selected_feature', srs=spa)
# create a gdal feature from the wkt-repr. of the qgis feature
geom = ogr.CreateGeometryFromWkt(feat_wkt)
gdal_feat = ogr.Feature(ogr.FeatureDefn())
gdal_feat.SetGeometryDirectly(geom)
# add it to the layer
layer.SetFeature(gdal_feat)
################################################################
# STEP 2 -- determine, download and process the necessary tiles
################################################################
# get the coordinate bounding box
x_totin, x_totax, y_totin, y_totax = layer.GetExtent()
# and from it the tile bounding box
TN_l, TN_r, TN_b, TN_t = compute_tile_bb(x_totin, x_totax, y_totin,
y_totax)
# initialize the return values
vals = list()
nodata_pt = []
# iterate through all the tiles needed to cover the bounding box of the feature
for ix in range(TN_r - TN_l + 1):
for iy in range(TN_t - TN_b + 1):
##########
# STEP 2.1
##########
# check if the tile (ix,iy) really intersects the feature:
# create a rectangle of the size of the tile
# to be on safe side, make rectangle slightly smaller than tile
x_left = TD['XLL'] + (
(ix + TN_l) * TD['NCOLS'] + 1) * TD['CELLSIZE']
x_right = TD['XLL'] + (
(ix + TN_l) + 1) * TD['NCOLS'] * TD['CELLSIZE']
y_bottom = TD['YLL'] + (
(iy + TN_b) * TD['NROWS'] + 1) * TD['CELLSIZE']
y_top = TD['YLL'] + (
(iy + TN_b) + 1) * TD['NROWS'] * TD['CELLSIZE']
rect = ogr.Geometry(ogr.wkbLinearRing)
rect.AddPoint(x_left, y_bottom)
rect.AddPoint(x_right, y_bottom)
rect.AddPoint(x_right, y_top)
rect.AddPoint(x_left, y_top)
rect.AddPoint(x_left, y_bottom)
poly = ogr.Geometry(ogr.wkbPolygon)
poly.AddGeometry(rect)
# only download and process the tile if it intersects the feature (geom)
# and if no no-data points have been found yet
if poly.Intersects(geom) and len(nodata_pt) == 0:
##########
# STEP 2.2, download, unzip and open the tile with gdal
##########
ds_www = downloader(TN_l + ix, TN_b + iy) # open .asc file
# save its GeoTransform
geo_trafo = ds_www.GetGeoTransform()
##########
# STEP 2.3, rasterize the polygon feature. "_m" means "mask".
##########
dr_m = gdal.GetDriverByName('MEM')
ds_m = dr_m.Create('', TD['NCOLS'], TD['NROWS'], 1,
gdal.GDT_Int16)
ds_m.SetGeoTransform(geo_trafo)
# burn the mask values: 1 inside polygon feature, 0 outside
gdal.RasterizeLayer(ds_m, [1], layer, burn_values=[1])
#gdal.Rasterize(ds_m, ds)#, burnValues = [1], allTouched = True)
##########
# STEP 2.3, multiply the rasterized polygon with the downloaded tile, thereby creating clipped_array
##########
array_m = ds_m.ReadAsArray()
array_www = ds_www.ReadAsArray()
shp = array_www.shape
# iterate over the elements of the array
for i in range(shp[0]):
for j in range(shp[1]):
if array_m[i, j] == 1: # if "(i,j)" is inside polygon:
if array_www[i, j] == TD[
'NODATA']: # if point is nodata point
nodata_pt = gdal.ApplyGeoTransform(
geo_trafo, j + 0.5, i + 0.5)
else:
vals.append(array_www[i, j])
# if raster should be saved
if dlg.rasterFilePath.text(
) != '' and dlg.rasterCheck.isChecked():
# fill the merged array
I = (nr_of_tiles_y_tot -
(TN_b - TN_b_tot + iy +
1)) * TD['NROWS'] + i
J = (TN_l - TN_l_tot +
ix) * TD['NCOLS'] + j
merged_array[I, J] = array_www[i, j]
else:
# this is the case that either we have already found a no data point inside the polygon
# or the tile doesn't intersect the polygon
pass
dlg.setProgressValue(dlg.progressBar.value() + 1)
QCoreApplication.processEvents()
return vals, nodata_pt
def ogr_rfc41_5():
feature_defn = ogr.FeatureDefn()
field_defn = ogr.FieldDefn('strfield', ogr.OFTString)
feature_defn.AddFieldDefn(field_defn)
feature_defn.GetGeomFieldDefn(0).SetName('geomfield')
f = ogr.Feature(feature_defn)
if f['strfield'] != None:
gdaltest.post_reason('fail')
return 'fail'
if f.strfield != None:
gdaltest.post_reason('fail')
return 'fail'
if f['geomfield'] != None:
gdaltest.post_reason('fail')
return 'fail'
if f.geomfield != None:
gdaltest.post_reason('fail')
return 'fail'
try:
a = f['inexisting_field']
gdaltest.post_reason('fail')
return 'fail'
except:
pass
try:
a = f.inexisting_field
gdaltest.post_reason('fail')
return 'fail'
except:
pass
try:
f['inexisting_field'] = 'foo'
gdaltest.post_reason('fail')
return 'fail'
except:
pass
# This works. Default Python behaviour. Stored in a dictionnary
f.inexisting_field = 'bar'
if f.inexisting_field != 'bar':
gdaltest.post_reason('fail')
return 'fail'
f['strfield'] = 'foo'
if f['strfield'] != 'foo':
gdaltest.post_reason('fail')
return 'fail'
if f.strfield != 'foo':
gdaltest.post_reason('fail')
return 'fail'
f.strfield = 'bar'
if f['strfield'] != 'bar':
gdaltest.post_reason('fail')
return 'fail'
if f.strfield != 'bar':
gdaltest.post_reason('fail')
return 'fail'
wkt = 'POINT EMPTY'
f['geomfield'] = ogr.CreateGeometryFromWkt(wkt)
if f['geomfield'].ExportToWkt() != wkt:
gdaltest.post_reason('fail')
return 'fail'
if f.geomfield.ExportToWkt() != wkt:
gdaltest.post_reason('fail')
return 'fail'
wkt2 = 'POLYGON EMPTY'
f.geomfield = ogr.CreateGeometryFromWkt(wkt2)
if f['geomfield'].ExportToWkt() != wkt2:
gdaltest.post_reason('fail')
return 'fail'
if f.geomfield.ExportToWkt() != wkt2:
gdaltest.post_reason('fail')
return 'fail'
return 'success'
def mk_src_feature():
feat_def = ogr.FeatureDefn('src')
field_def = ogr.FieldDefn('field_integer', ogr.OFTInteger)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_integer64', ogr.OFTInteger64)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_real', ogr.OFTReal)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_binary', ogr.OFTBinary)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_date', ogr.OFTDate)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_time', ogr.OFTTime)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_datetime', ogr.OFTDateTime)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_integerlist', ogr.OFTIntegerList)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_integer64list', ogr.OFTInteger64List)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_reallist', ogr.OFTRealList)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_stringlist', ogr.OFTStringList)
feat_def.AddFieldDefn(field_def)
src_feature = ogr.Feature(feat_def)
src_feature.SetField('field_integer', 17)
src_feature.SetField('field_integer64', 9876543210)
src_feature.SetField('field_real', 18.4)
src_feature.SetField('field_string', 'abc def')
src_feature.SetFieldBinaryFromHexString('field_binary', '0123465789ABCDEF')
src_feature.SetField('field_date', '2011/11/11')
src_feature.SetField('field_time', '14:10:35')
src_feature.SetField('field_datetime', 2011, 11, 11, 14, 10, 35.123, 0)
got_vals = src_feature.GetFieldAsDateTime(
feat_def.GetFieldIndex('field_datetime'))
expected_vals = [2011, 11, 11, 14, 10, 35.123, 0]
for i in range(len(expected_vals)):
if abs(got_vals[i] - expected_vals[i]) > 1e-4:
gdaltest.post_reason('fail')
print(got_vals)
print(expected_vals)
src_feature.field_integerlist = '(3:10,20,30)'
src_feature.field_integer64list = [9876543210]
src_feature.field_reallist = [123.5, 567.0]
src_feature.field_stringlist = ['abc', 'def']
return src_feature
def ogr_feature_default():
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
if field_def.GetDefault() is not None:
gdaltest.post_reason('fail')
return 'fail'
if field_def.IsDefaultDriverSpecific():
gdaltest.post_reason('fail')
return 'fail'
field_def.SetDefault("(some_expr)")
if field_def.GetDefault() != "(some_expr)":
gdaltest.post_reason('fail')
return 'fail'
if not field_def.IsDefaultDriverSpecific():
gdaltest.post_reason('fail')
return 'fail'
field_def.SetDefault("'a")
if field_def.GetDefault() != "'a":
gdaltest.post_reason('fail')
return 'fail'
gdal.PushErrorHandler()
field_def.SetDefault("'a''")
gdal.PopErrorHandler()
if field_def.GetDefault() is not None:
gdaltest.post_reason('fail')
return 'fail'
gdal.PushErrorHandler()
field_def.SetDefault("'a'b'")
gdal.PopErrorHandler()
if field_def.GetDefault() is not None:
gdaltest.post_reason('fail')
return 'fail'
field_def.SetDefault("'a''b'''")
if field_def.GetDefault() != "'a''b'''":
gdaltest.post_reason('fail')
return 'fail'
if field_def.IsDefaultDriverSpecific():
gdaltest.post_reason('fail')
return 'fail'
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_datetime', ogr.OFTDateTime)
field_def.SetDefault("CURRENT_TIMESTAMP")
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_datetime2', ogr.OFTDateTime)
field_def.SetDefault("'2015/06/30 12:34:56'")
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_int', ogr.OFTInteger)
field_def.SetDefault('123')
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_nodefault', ogr.OFTInteger)
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.FillUnsetWithDefault()
if f.GetField('field_string') != 'a\'b\'' or \
not f.IsFieldSet('field_datetime') or \
f.GetField('field_datetime2') != '2015/06/30 12:34:56+00' or \
f.GetField('field_int') != 123 or \
f.IsFieldSet('field_nodefault'):
f.DumpReadable()
gdaltest.post_reason('fail')
return 'fail'
f = ogr.Feature(feat_def)
f.SetField('field_string', 'b')
f.FillUnsetWithDefault()
if f.GetField('field_string') != 'b':
f.DumpReadable()
gdaltest.post_reason('fail')
return 'fail'
return 'success'
def test_ogr_feature_64bit_fid():
feat_def = ogr.FeatureDefn('test')
f = ogr.Feature(feat_def)
f.SetFID(123456789012345)
assert f.GetFID() == 123456789012345
def ogr_feature_native_data():
feat_def = ogr.FeatureDefn('test')
f = ogr.Feature(feat_def)
if f.GetNativeData() is not None:
gdaltest.post_reason('fail')
return 'fail'
if f.GetNativeMediaType() is not None:
gdaltest.post_reason('fail')
return 'fail'
f.SetNativeData('native_data')
if f.GetNativeData() != 'native_data':
gdaltest.post_reason('fail')
return 'fail'
f.SetNativeMediaType('native_media_type')
if f.GetNativeMediaType() != 'native_media_type':
gdaltest.post_reason('fail')
print(f.GetNativeMediaType())
return 'fail'
f2 = ogr.Feature(feat_def)
f2.SetFrom(f)
if f2.GetNativeData() != 'native_data':
gdaltest.post_reason('fail')
return 'fail'
if f2.GetNativeMediaType() != 'native_media_type':
gdaltest.post_reason('fail')
return 'fail'
f_clone = f.Clone()
if f_clone.GetNativeData() != 'native_data':
gdaltest.post_reason('fail')
return 'fail'
if f_clone.GetNativeMediaType() != 'native_media_type':
gdaltest.post_reason('fail')
return 'fail'
f_clone.SetNativeData(None)
f_clone.SetNativeMediaType(None)
if f_clone.GetNativeData() is not None:
gdaltest.post_reason('fail')
return 'fail'
if f_clone.GetNativeMediaType() is not None:
gdaltest.post_reason('fail')
return 'fail'
ds = ogr.GetDriverByName('Memory').CreateDataSource('')
lyr = ds.CreateLayer('test')
lyr.SetMetadataItem('NATIVE_DATA', 'native_data', 'NATIVE_DATA')
lyr.SetMetadataItem('NATIVE_MEDIA_TYPE', 'native_media_type',
'NATIVE_DATA')
f = ogr.Feature(lyr.GetLayerDefn())
f.SetNativeData('native_data')
f.SetNativeMediaType('native_media_type')
lyr.CreateFeature(f)
f = None
dialects = ['OGR_SQL']
if gdal.GetDriverByName('SQLITE') is not None:
dialects += ['OGR_SQLITE']
for dialect in dialects:
sql_lyr = ds.ExecuteSQL('SELECT * FROM %s' % lyr.GetName(),
dialect=dialect)
native_data = sql_lyr.GetMetadataItem('NATIVE_DATA', 'NATIVE_DATA')
if native_data != 'native_data':
gdaltest.post_reason('fail')
print(dialect)
print(native_data)
return 'fail'
native_media_type = sql_lyr.GetMetadataItem('NATIVE_MEDIA_TYPE',
'NATIVE_DATA')
if native_media_type != 'native_media_type':
gdaltest.post_reason('fail')
print(dialect)
print(native_media_type)
return 'fail'
f = sql_lyr.GetNextFeature()
if f.GetNativeData() != 'native_data':
gdaltest.post_reason('fail')
print(dialect)
print(f.GetNativeData())
return 'fail'
if f.GetNativeMediaType() != 'native_media_type':
gdaltest.post_reason('fail')
print(dialect)
print(f.GetNativeMediaType())
return 'fail'
ds.ReleaseResultSet(sql_lyr)
return 'success'
def populateRow(self, item, idx):
osm_id = item.get("osm_id")
name = item["display_name"]
try:
className = QApplication.translate("nominatim", item["class"],
None)
except:
className = ""
try:
typeName = QApplication.translate("nominatim", item["type"], None)
except:
typeName = ""
wkt = item.get("geotext")
osm_type = item.get("osm_type")
# extratags and address_details are dictionaries with content that can
# vary per feature and also per nominatim server. We expose them as
# HStore strings as that is easy to handle in QGIS with the
# hstore_to_map expression function.
# When querying the official OSM nominatim server, the extratags
# contain all the tags not already included in the class, address, etc
# fields. Other nominatim servers can be configured differently.
address = item.get("address")
if address:
address = tools.dict_to_hstore_string(address)
else:
address = ""
extratags = item.get("extratags")
if extratags:
extratags = tools.dict_to_hstore_string(extratags)
else:
extratags = ""
if "boundingbox" in item.keys():
# we have a polygonal item
bbox = item["boundingbox"]
poFD = ogr.FeatureDefn("Rectangle")
poFD.SetGeomType(ogr.wkbPolygon)
NominatimDialog.add_fields(poFD)
ogrFeature = ogr.Feature(poFD)
if wkt is None:
wkt = "POLYGON(({b[2]} {b[0]}, {b[2]} {b[1]}, {b[3]} {b[1]}, {b[3]} {b[0]}, {b[2]} {b[0]}))".format(
b=bbox)
ogrGeom = ogr.CreateGeometryFromWkt(wkt)
else:
# we have something to represent as a point
lat = item["lat"]
lng = item["lon"]
poFD = ogr.FeatureDefn("Point")
poFD.SetGeomType(ogr.wkbPoint)
NominatimDialog.add_fields(poFD)
ogrFeature = ogr.Feature(poFD)
wkt = "POINT({} {})".format(lng, lat)
ogrGeom = ogr.CreateGeometryFromWkt(wkt)
ogrFeature.SetGeometry(ogrGeom)
ogrFeature.SetFID(int(idx + 1))
ogrFeature.SetField("osm_id", osm_id)
ogrFeature.SetField("class", className)
ogrFeature.SetField("type", typeName)
ogrFeature.SetField("name", name)
ogrFeature.SetField("address", address)
ogrFeature.SetField("extratags", extratags)
item = QTableWidgetItem(name)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setData(Qt.UserRole, ogrFeature)
self.tableResult.setItem(idx, 0, item)
itemLibelle = QTableWidgetItem(className)
itemLibelle.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableResult.setItem(idx, 1, itemLibelle)
itemType = QTableWidgetItem(typeName)
itemType.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableResult.setItem(idx, 2, itemType)
def populateRow(self, item, idx):
id = item["place_id"]
name = item["display_name"]
try:
className = QApplication.translate("nominatim", item["class"],
None)
except:
className = ""
try:
typeName = QApplication.translate("nominatim", item["type"], None)
except:
typeName = ""
try:
wkt = item["geotext"]
except:
wkt = None
try:
osm_type = item["osm_type"]
except:
osm_type = None
bbox = {}
if osm_type == "node":
lat = item["lat"]
lng = item["lon"]
poFD = ogr.FeatureDefn("Point")
poFD.SetGeomType(ogr.wkbPoint)
oFLD = ogr.FieldDefn("id", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
oFLD = ogr.FieldDefn("name", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
ogrFeature = ogr.Feature(poFD)
wkt = "POINT({} {})".format(lng, lat)
ogrGeom = ogr.CreateGeometryFromWkt(wkt)
else:
try:
bbox = item["boundingbox"]
poFD = ogr.FeatureDefn("Rectangle")
poFD.SetGeomType(ogr.wkbPolygon)
oFLD = ogr.FieldDefn("id", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
oFLD = ogr.FieldDefn("name", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
ogrFeature = ogr.Feature(poFD)
if wkt is None:
wkt = "POLYGON(({b[2]} {b[0]}, {b[2]} {b[1]}, {b[3]} {b[1]}, {b[3]} {b[0]}, {b[2]} {b[0]}))".format(
b=bbox)
ogrGeom = ogr.CreateGeometryFromWkt(wkt)
except:
lat = item["lat"]
lng = item["lon"]
poFD = ogr.FeatureDefn("Point")
poFD.SetGeomType(ogr.wkbPoint)
oFLD = ogr.FieldDefn("id", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
oFLD = ogr.FieldDefn("name", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
ogrFeature = ogr.Feature(poFD)
wkt = "POINT({} {})".format(lng, lat)
ogrGeom = ogr.CreateGeometryFromWkt(wkt)
ogrFeature.SetGeometry(ogrGeom)
ogrFeature.SetFID(int(idx + 1))
ogrFeature.SetField(str("id"), str(id))
ogrFeature.SetField(str("name"), name)
item = QTableWidgetItem(name)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setData(Qt.UserRole, ogrFeature)
self.tableResult.setItem(idx, 0, item)
itemLibelle = QTableWidgetItem(className)
itemLibelle.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableResult.setItem(idx, 1, itemLibelle)
itemType = QTableWidgetItem(typeName)
itemType.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableResult.setItem(idx, 2, itemType)
def test_ogr_basic_12():
# boolean integer
feat_def = ogr.FeatureDefn()
assert ogr.GetFieldSubTypeName(ogr.OFSTBoolean) == 'Boolean'
field_def = ogr.FieldDefn('fld', ogr.OFTInteger)
field_def.SetSubType(ogr.OFSTBoolean)
assert field_def.GetSubType() == ogr.OFSTBoolean
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.SetField('fld', 0)
f.SetField('fld', 1)
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetField('fld', 2)
gdal.PopErrorHandler()
assert gdal.GetLastErrorMsg() != ''
assert f.GetField('fld') == 1
f.SetField('fld', '0')
f.SetField('fld', '1')
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetField('fld', '2')
gdal.PopErrorHandler()
assert gdal.GetLastErrorMsg() != ''
assert f.GetField('fld') == 1
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
field_def = ogr.FieldDefn('fld', ogr.OFTString)
field_def.SetSubType(ogr.OFSTBoolean)
gdal.PopErrorHandler()
assert gdal.GetLastErrorMsg() != ''
assert field_def.GetSubType() == ogr.OFSTNone
# boolean list
feat_def = ogr.FeatureDefn()
field_def = ogr.FieldDefn('fld', ogr.OFTIntegerList)
field_def.SetSubType(ogr.OFSTBoolean)
assert field_def.GetSubType() == ogr.OFSTBoolean
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.SetFieldIntegerList(0, [0, 1])
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetFieldIntegerList(0, [0, 1, 2, 1])
gdal.PopErrorHandler()
assert gdal.GetLastErrorMsg() != ''
assert f.GetField('fld') == [0, 1, 1, 1]
# int16 integer
feat_def = ogr.FeatureDefn()
assert ogr.GetFieldSubTypeName(ogr.OFSTInt16) == 'Int16'
field_def = ogr.FieldDefn('fld', ogr.OFTInteger)
field_def.SetSubType(ogr.OFSTInt16)
assert field_def.GetSubType() == ogr.OFSTInt16
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.SetField('fld', -32768)
f.SetField('fld', 32767)
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetField('fld', -32769)
gdal.PopErrorHandler()
assert gdal.GetLastErrorMsg() != ''
assert f.GetField('fld') == -32768
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetField('fld', 32768)
gdal.PopErrorHandler()
assert gdal.GetLastErrorMsg() != ''
assert f.GetField('fld') == 32767
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
field_def = ogr.FieldDefn('fld', ogr.OFTString)
field_def.SetSubType(ogr.OFSTInt16)
gdal.PopErrorHandler()
assert gdal.GetLastErrorMsg() != ''
assert field_def.GetSubType() == ogr.OFSTNone
# float32
feat_def = ogr.FeatureDefn()
assert ogr.GetFieldSubTypeName(ogr.OFSTFloat32) == 'Float32'
field_def = ogr.FieldDefn('fld', ogr.OFTReal)
field_def.SetSubType(ogr.OFSTFloat32)
assert field_def.GetSubType() == ogr.OFSTFloat32
feat_def.AddFieldDefn(field_def)
if False: # pylint: disable=using-constant-test
f = ogr.Feature(feat_def)
gdal.ErrorReset()
f.SetField('fld', '1.23')
assert gdal.GetLastErrorMsg() == ''
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
f.SetField('fld', 1.230000000001)
gdal.PopErrorHandler()
assert gdal.GetLastErrorMsg() != ''
if f.GetField('fld') == pytest.approx(1.23, abs=1e-8):
f.DumpReadable()
pytest.fail()
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
field_def = ogr.FieldDefn('fld', ogr.OFSTFloat32)
field_def.SetSubType(ogr.OFSTInt16)
gdal.PopErrorHandler()
assert gdal.GetLastErrorMsg() != ''
assert field_def.GetSubType() == ogr.OFSTNone
def test_ogr_rfc41_2():
# Check implicit geometry field creation
feature_defn = ogr.FeatureDefn()
assert feature_defn.GetGeomFieldCount() == 1
assert feature_defn.GetGeomType() == ogr.wkbUnknown
# Test IsSame()
assert feature_defn.IsSame(feature_defn) == 1
other_feature_defn = ogr.FeatureDefn()
assert feature_defn.IsSame(other_feature_defn) == 1
other_feature_defn.GetGeomFieldDefn(0).SetSpatialRef(
osr.SpatialReference())
assert feature_defn.IsSame(other_feature_defn) == 0
feature_defn.GetGeomFieldDefn(0).SetSpatialRef(osr.SpatialReference())
assert feature_defn.IsSame(other_feature_defn) == 1
other_feature_defn.GetGeomFieldDefn(0).SetSpatialRef(None)
assert feature_defn.IsSame(other_feature_defn) == 0
feature_defn = None
feature_defn = ogr.FeatureDefn()
# Check changing geometry type
feature_defn.SetGeomType(ogr.wkbPoint)
assert feature_defn.GetGeomType() == ogr.wkbPoint
assert feature_defn.GetGeomFieldDefn(0).GetType() == ogr.wkbPoint
# Check setting to wkbNone and implicitly destroying the field.
for _ in range(2):
feature_defn.SetGeomType(ogr.wkbNone)
assert feature_defn.GetGeomFieldCount() == 0
assert feature_defn.GetGeomType() == ogr.wkbNone
# Recreate the field
for t in [ogr.wkbPoint, ogr.wkbLineString]:
feature_defn.SetGeomType(t)
assert feature_defn.GetGeomFieldCount() == 1
assert feature_defn.GetGeomType() == t
assert feature_defn.GetGeomFieldDefn(0).GetType() == t
# Test setting invalid value
old_val = feature_defn.GetGeomType()
gdal.PushErrorHandler('CPLQuietErrorHandler')
feature_defn.SetGeomType(-3)
gdal.PopErrorHandler()
assert feature_defn.GetGeomType() == old_val
# Test SetIgnored() / IsIgnored()
assert feature_defn.IsGeometryIgnored() == 0
assert feature_defn.GetGeomFieldDefn(0).IsIgnored() == 0
feature_defn.SetGeometryIgnored(1)
assert feature_defn.IsGeometryIgnored() == 1
assert feature_defn.GetGeomFieldDefn(0).IsIgnored() == 1
# Test wrong index values for GetGeomFieldDefn()
for idx in [-1, 1]:
gdal.PushErrorHandler('CPLQuietErrorHandler')
ret = feature_defn.GetGeomFieldDefn(idx)
gdal.PopErrorHandler()
assert ret is None
# Test GetGeomFieldIndex()
assert feature_defn.GetGeomFieldIndex("") == 0
assert feature_defn.GetGeomFieldIndex("invalid") == -1
# Test AddGeomFieldDefn()
gfld_defn = ogr.GeomFieldDefn('polygon_field', ogr.wkbPolygon)
feature_defn.AddGeomFieldDefn(gfld_defn)
assert feature_defn.GetGeomFieldCount() == 2
assert feature_defn.GetGeomFieldIndex("polygon_field") == 1
assert feature_defn.GetGeomFieldDefn(1).GetName() == 'polygon_field'
# Test DeleteGeomFieldDefn() : error cases
assert feature_defn.DeleteGeomFieldDefn(-1) != 0
assert feature_defn.DeleteGeomFieldDefn(2) != 0
assert feature_defn.GetGeomFieldCount() == 2
# Test DeleteGeomFieldDefn() : valid cases
assert feature_defn.DeleteGeomFieldDefn(0) == 0
assert feature_defn.GetGeomFieldCount() == 1
assert feature_defn.GetGeomFieldIndex("polygon_field") == 0
assert feature_defn.DeleteGeomFieldDefn(0) == 0
assert feature_defn.GetGeomFieldCount() == 0
assert feature_defn.IsSame(feature_defn) == 1
assert feature_defn.IsSame(ogr.FeatureDefn()) == 0
feature_defn = None
def test_ogr_rfc41_3():
# Test with just one geometry field
feature_defn = ogr.FeatureDefn()
feature = ogr.Feature(feature_defn)
assert feature.GetGeomFieldCount() == 1
assert feature.GetGeomFieldDefnRef(0).GetName() == ''
assert feature.GetGeomFieldDefnRef(0).GetType() == ogr.wkbUnknown
assert feature.GetGeomFieldIndex('') == 0
assert feature.GetGeomFieldIndex('non_existing') == -1
assert feature.GetGeomFieldRef(-1) is None
assert feature.GetGeomFieldRef(0) is None
assert feature.GetGeomFieldRef(1) is None
feature_clone_without_geom = feature.Clone()
assert feature.Equal(feature_clone_without_geom)
assert feature.SetGeomField(0, ogr.Geometry(ogr.wkbPoint)) == 0
assert feature.GetGeomFieldRef(0).ExportToWkt() == 'POINT EMPTY'
assert feature.Equal(feature.Clone())
assert not feature.Equal(feature_clone_without_geom)
feature_clone_with_other_geom = feature.Clone()
feature_clone_with_other_geom.SetGeometry(ogr.Geometry(ogr.wkbLineString))
assert not feature.Equal(feature_clone_with_other_geom)
assert feature.SetGeomFieldDirectly(-1, None) != 0
assert feature.SetGeomFieldDirectly(0,
ogr.Geometry(ogr.wkbLineString)) == 0
assert feature.GetGeomFieldRef(0).ExportToWkt() == 'LINESTRING EMPTY'
feature_clone_with_geom = feature.Clone()
assert feature.SetGeomFieldDirectly(0, None) == 0
assert feature.GetGeomFieldRef(0) is None
assert not feature.Equal(feature_clone_with_geom)
feature = None
# Test one a feature with 0 geometry field
feature_defn = ogr.FeatureDefn()
feature_defn.SetGeomType(ogr.wkbNone)
feature = ogr.Feature(feature_defn)
assert feature.Equal(feature.Clone())
assert feature.GetGeomFieldCount() == 0
# This used to work before RFC 41, but it no longer will
assert feature.SetGeometry(ogr.Geometry(ogr.wkbPoint)) != 0
assert feature.SetGeomField(0, ogr.Geometry(ogr.wkbPoint)) != 0
assert feature.GetGeometryRef() is None
assert feature.GetGeomFieldRef(0) is None
assert feature.SetGeometryDirectly(ogr.Geometry(ogr.wkbPoint)) != 0
assert feature.SetGeomFieldDirectly(0, ogr.Geometry(ogr.wkbPoint)) != 0
feature = None
# Test one a feature with several geometry fields
feature_defn = ogr.FeatureDefn()
feature_defn.SetGeomType(ogr.wkbNone)
gfld_defn = ogr.GeomFieldDefn('polygon_field', ogr.wkbPolygon)
feature_defn.AddGeomFieldDefn(gfld_defn)
gfld_defn = ogr.GeomFieldDefn('point_field', ogr.wkbPoint)
feature_defn.AddGeomFieldDefn(gfld_defn)
feature = ogr.Feature(feature_defn)
feature.SetGeomField(0, ogr.Geometry(ogr.wkbPolygon))
feature.SetGeomField(1, ogr.Geometry(ogr.wkbPoint))
assert feature.GetGeomFieldRef(0).ExportToWkt() == 'POLYGON EMPTY'
assert feature.GetGeomFieldRef(1).ExportToWkt() == 'POINT EMPTY'
assert feature.Equal(feature.Clone())
other_feature = ogr.Feature(feature_defn)
assert not feature.Equal(other_feature)
other_feature.SetFrom(feature)
assert feature.Equal(other_feature)
# Test that in SetFrom() where target has a single geometry field,
# we get the first geometry of the source even if we cannot find a
# source geometry field with the right name.
feature_defn_default = ogr.FeatureDefn()
feature_default = ogr.Feature(feature_defn_default)
feature_default.SetFrom(feature)
assert feature_default.GetGeomFieldRef(0).ExportToWkt() == 'POLYGON EMPTY'
def ogr_wasp_elevation_from_linestring_z_toler():
if ogr_wasp_create_ds() != 'success':
return 'skip'
ref = osr.SpatialReference()
ref.ImportFromProj4('+proj=lcc +lat_1=46.8 +lat_0=46.8 +lon_0=0 +k_0=0.99987742 +x_0=600000 +y_0=2200000 +a=6378249.2 +b=6356514.999978254 +pm=2.337229167 +units=m +no_defs')
if not ogrtest.have_geos() :
gdal.PushErrorHandler('CPLQuietErrorHandler')
layer = gdaltest.wasp_ds.CreateLayer('mylayer',
ref,
options = ['WASP_TOLERANCE=.1'],
geom_type=ogr.wkbLineString25D )
if not ogrtest.have_geos() :
gdal.PopErrorHandler()
if layer is None:
gdaltest.post_reason( 'unable to create layer')
return 'fail'
dfn = ogr.FeatureDefn()
for i in range(10):
feat = ogr.Feature( dfn )
line = ogr.Geometry( type = ogr.wkbLineString25D )
line.AddPoint( i, 0, i )
line.AddPoint( i, 0.5, i )
line.AddPoint( i, 1, i )
feat.SetGeometry( line )
if layer.CreateFeature( feat ) != 0:
gdaltest.post_reason( 'unable to create feature')
return 'fail'
del gdaltest.wasp_ds
del layer
f = open('tmp.map')
for i in range(4):
f.readline()
i = 0
j = 0
for line in f:
if not i%2:
[h,n] = line.split()
if int(n) != 2:
if ogrtest.have_geos():
gdaltest.post_reason( 'number of points should be 2 and is %s' % n )
return 'fail'
elif int(n) != 3:
gdaltest.post_reason( 'number of points should be 3 and is %s' % n )
return 'fail'
if float(h) != j:
gdaltest.post_reason( 'altitude should be %d and is %s' %(j,h) )
return 'fail'
j+=1
i+=1
if j != 10:
gdaltest.post_reason( 'nb of feature should be 10 and is %d' % j )
return 'fail'
return 'success'
def test_ogr_feature_nullable_validate():
# No fields
feat_def = ogr.FeatureDefn('test')
f = ogr.Feature(feat_def)
assert f.Validate() == 1
# Field with default parameter and empty feature
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
assert field_def.IsNullable() == 1
assert feat_def.GetGeomFieldDefn(0).IsNullable() == 1
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
assert f.Validate() == 1
# Field with not NULL constraint and empty feature
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
field_def.SetNullable(0)
assert field_def.IsNullable() == 0
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
gdal.PushErrorHandler()
ret = f.Validate()
gdal.PopErrorHandler()
assert ret == 0
# Field with not NULL constraint and non-empty feature
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
field_def.SetNullable(0)
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.SetField(0, 'foo')
assert f.Validate() == 1
# Field with width constraint that is met
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
field_def.SetWidth(3)
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.SetField(0, 'foo')
assert f.Validate() == 1
# Field with width constraint that is not met
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
field_def.SetWidth(2)
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.SetField(0, 'foo')
gdal.PushErrorHandler()
ret = f.Validate()
gdal.PopErrorHandler()
assert ret == 0
# Geometry field with not-null geometry constraint that is met
feat_def = ogr.FeatureDefn('test')
feat_def.SetGeomType(ogr.wkbNone)
gfield_def = ogr.GeomFieldDefn('test', ogr.wkbUnknown)
gfield_def.SetNullable(0)
assert gfield_def.IsNullable() == 0
feat_def.AddGeomFieldDefn(gfield_def)
f = ogr.Feature(feat_def)
f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(0 1)'))
assert f.Validate() == 1
# Geometry field with not-null geometry constraint that is not met
feat_def = ogr.FeatureDefn('test')
feat_def.SetGeomType(ogr.wkbNone)
gfield_def = ogr.GeomFieldDefn('test', ogr.wkbPoint)
gfield_def.SetNullable(0)
feat_def.AddGeomFieldDefn(gfield_def)
f = ogr.Feature(feat_def)
gdal.PushErrorHandler()
ret = f.Validate()
gdal.PopErrorHandler()
assert ret == 0
# Geometry field with Point geometry type that is met
feat_def = ogr.FeatureDefn('test')
feat_def.SetGeomType(ogr.wkbPoint)
f = ogr.Feature(feat_def)
f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(0 1)'))
assert f.Validate() == 1
# Geometry field with LineString geometry type that is not met
feat_def = ogr.FeatureDefn('test')
feat_def.SetGeomType(ogr.wkbLineString)
f = ogr.Feature(feat_def)
f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(0 1)'))
gdal.PushErrorHandler()
ret = f.Validate()
gdal.PopErrorHandler()
assert ret == 0
def ogr_wasp_merge():
if ogr_wasp_create_ds() != 'success':
return 'skip'
if not ogrtest.have_geos() :
gdal.PushErrorHandler('CPLQuietErrorHandler')
layer = gdaltest.wasp_ds.CreateLayer('mylayer',
geom_type=ogr.wkbPolygon25D )
if not ogrtest.have_geos() :
gdal.PopErrorHandler()
if layer is None:
if ogrtest.have_geos():
gdaltest.post_reason( 'unable to create layer')
return 'fail'
else:
return 'success'
dfn = ogr.FeatureDefn()
for i in range(6):
feat = ogr.Feature( dfn )
ring = ogr.Geometry( type = ogr.wkbLinearRing )
h = i%2
ring.AddPoint( 0, 0, h )
ring.AddPoint( round(math.cos(i*math.pi/3),6), round(math.sin(i*math.pi/3),6), h )
ring.AddPoint( round(math.cos((i+1)*math.pi/3),6), round(math.sin((i+1)*math.pi/3),6), h )
ring.AddPoint( 0, 0, h )
poly = ogr.Geometry( type = ogr.wkbPolygon25D )
poly.AddGeometry(ring)
feat.SetGeometry( poly )
if layer.CreateFeature( feat ) != 0:
gdaltest.post_reason( 'unable to create feature')
return 'fail'
del gdaltest.wasp_ds
del layer
f = open('tmp.map')
for i in range(4):
f.readline()
i = 0
j = 0
res = []
for line in f:
if not i%2:
[l,r,n] = [v for v in line.split()]
if int(n) != 2:
gdaltest.post_reason( 'number of points should be 2 and is %d (unwanted merge ?)' % int(n) )
return 'fail'
if float(r) > float(l) :
res.append((float(l), float(r)))
else :
res.append((float(r), float(l)))
j+=1
i+=1
if j != 6:
gdaltest.post_reason( 'there should be 6 boundaries and there are %d' %j )
return 'fail'
if res != [(0,1) for k in range(6)]:
print(res)
gdaltest.post_reason( 'wrong values f=in boundaries' )
return 'fail'
return 'success'
def test_ogr_feature_default():
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
assert field_def.GetDefault() is None
assert not field_def.IsDefaultDriverSpecific()
field_def.SetDefault("(some_expr)")
assert field_def.GetDefault() == "(some_expr)"
assert field_def.IsDefaultDriverSpecific()
field_def.SetDefault("'a")
assert field_def.GetDefault() == "'a"
gdal.PushErrorHandler()
field_def.SetDefault("'a''")
gdal.PopErrorHandler()
assert field_def.GetDefault() is None
gdal.PushErrorHandler()
field_def.SetDefault("'a'b'")
gdal.PopErrorHandler()
assert field_def.GetDefault() is None
field_def.SetDefault("'a''b'''")
assert field_def.GetDefault() == "'a''b'''"
assert not field_def.IsDefaultDriverSpecific()
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_datetime', ogr.OFTDateTime)
field_def.SetDefault("CURRENT_TIMESTAMP")
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_datetime2', ogr.OFTDateTime)
field_def.SetDefault("'2015/06/30 12:34:56'")
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_int', ogr.OFTInteger)
field_def.SetDefault('123')
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_nodefault', ogr.OFTInteger)
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.FillUnsetWithDefault()
if f.GetField('field_string') != 'a\'b\'' or \
not f.IsFieldSet('field_datetime') or \
f.GetField('field_datetime2') != '2015/06/30 12:34:56+00' or \
f.GetField('field_int') != 123 or \
f.IsFieldSet('field_nodefault'):
f.DumpReadable()
pytest.fail()
f = ogr.Feature(feat_def)
f.SetField('field_string', 'b')
f.FillUnsetWithDefault()
if f.GetField('field_string') != 'b':
f.DumpReadable()
pytest.fail()
def ogr_feature_null_field():
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
if f.IsFieldNull(feat_def.GetFieldIndex("field_string")):
gdaltest.post_reason('fail')
return 'fail'
if f.IsFieldNull("field_string"):
gdaltest.post_reason('fail')
return 'fail'
f.SetFieldNull(feat_def.GetFieldIndex("field_string"))
if f.IsFieldNull(feat_def.GetFieldIndex("field_string")) == 0:
gdaltest.post_reason('fail')
return 'fail'
f.SetField("field_string", "foo")
if f.IsFieldNull("field_string"):
gdaltest.post_reason('fail')
return 'fail'
f.SetFieldNull("field_string")
if f.IsFieldNull(feat_def.GetFieldIndex("field_string")) == 0:
gdaltest.post_reason('fail')
return 'fail'
f = None
field_def = ogr.FieldDefn('field_binary', ogr.OFTBinary)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_integerlist', ogr.OFTIntegerList)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_integer64list', ogr.OFTInteger64List)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_reallist', ogr.OFTRealList)
feat_def.AddFieldDefn(field_def)
field_def = ogr.FieldDefn('field_stringlist', ogr.OFTStringList)
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.SetFieldBinaryFromHexString('field_binary', '0123465789ABCDEF')
f.field_integerlist = '(3:10,20,30)'
f.field_integer64list = [9876543210]
f.field_reallist = [123.5, 567.0]
f.field_stringlist = ['abc', 'def']
if f.IsFieldNull('field_binary') != 0:
gdaltest.post_reason('fail')
return 'fail'
if f.IsFieldNull('field_integerlist') != 0:
gdaltest.post_reason('fail')
return 'fail'
if f.IsFieldNull('field_integer64list') != 0:
gdaltest.post_reason('fail')
return 'fail'
if f.IsFieldNull('field_reallist') != 0:
gdaltest.post_reason('fail')
return 'fail'
if f.IsFieldNull('field_stringlist') != 0:
gdaltest.post_reason('fail')
return 'fail'
f.SetField('field_binary', None)
f.SetFieldNull('field_integerlist')
f.SetFieldNull('field_integer64list')
f.SetFieldNull('field_reallist')
f.SetFieldNull('field_stringlist')
if f.IsFieldNull('field_binary') == 0:
gdaltest.post_reason('fail')
return 'fail'
if f.IsFieldNull('field_integerlist') == 0:
gdaltest.post_reason('fail')
return 'fail'
if f.IsFieldNull('field_integer64list') == 0:
gdaltest.post_reason('fail')
return 'fail'
if f.IsFieldNull('field_reallist') == 0:
gdaltest.post_reason('fail')
return 'fail'
if f.IsFieldNull('field_stringlist') == 0:
gdaltest.post_reason('fail')
return 'fail'
f_clone = f.Clone()
if f_clone.IsFieldNull('field_binary') == 0:
gdaltest.post_reason('fail')
return 'fail'
if not f.Equal(f_clone):
gdaltest.post_reason('fail')
return 'fail'
f = None
return 'success'
def ogr_mssqlspatial_create_feature_in_unregistered_table():
if gdaltest.mssqlspatial_ds is None:
return 'skip'
# Create a feature that specifies a spatial-reference system
spatial_reference = osr.SpatialReference()
spatial_reference.ImportFromEPSG(4326)
feature = ogr.Feature(ogr.FeatureDefn('Unregistered'))
feature.SetGeometryDirectly(
ogr.CreateGeometryFromWkt('POINT (10 20)', spatial_reference))
# Create a table that includes a geometry column but is not registered in
# the "geometry_columns" table
gdaltest.mssqlspatial_ds.ExecuteSQL(
'CREATE TABLE Unregistered' + '(' +
'ObjectID int IDENTITY(1,1) NOT NULL PRIMARY KEY,' +
'Shape geometry NOT NULL' + ');')
# Create a new MSSQLSpatial data source, one that will find the table just
# created and make it available via GetLayerByName()
use_geometry_columns = gdal.GetConfigOption(
'MSSQLSPATIAL_USE_GEOMETRY_COLUMNS')
gdal.SetConfigOption('MSSQLSPATIAL_USE_GEOMETRY_COLUMNS', 'NO')
test_ds = ogr.Open(gdaltest.mssqlspatial_dsname, update=1)
gdal.SetConfigOption('MSSQLSPATIAL_USE_GEOMETRY_COLUMNS',
use_geometry_columns)
if test_ds is None:
gdaltest.post_reason('cannot open data source')
return 'fail'
# Get a layer backed by the newly created table and verify that (as it is
# unregistered) it has no associated spatial-reference system
unregistered_layer = test_ds.GetLayerByName('Unregistered')
if unregistered_layer is None:
gdaltest.post_reason('did not get Unregistered layer')
return 'fail'
unregistered_spatial_reference = unregistered_layer.GetSpatialRef()
if unregistered_spatial_reference is not None:
gdaltest.post_reason('layer Unregistered unexpectedly has an SRS')
return 'fail'
# Verify creating the feature in the layer succeeds despite the lack of an
# associated spatial-reference system
if unregistered_layer.CreateFeature(feature) != ogr.OGRERR_NONE:
gdaltest.post_reason('CreateFeature failed')
return 'fail'
# Verify the created feature received the spatial-reference system of the
# original, as none was associated with the table
unregistered_layer.ResetReading()
created_feature = unregistered_layer.GetNextFeature()
if created_feature is None:
gdaltest.post_reason('did not get feature')
return 'fail'
created_feature_geometry = created_feature.GetGeometryRef()
created_spatial_reference = created_feature_geometry.GetSpatialReference()
if not ((created_spatial_reference == spatial_reference) or
((created_spatial_reference is not None)
and created_spatial_reference.IsSame(spatial_reference))):
gdaltest.post_reason('created-feature SRS does not match original')
return 'fail'
# Clean up
test_ds.Destroy()
feature.Destroy()
return 'success'
def ogr_feature_nullable_validate():
# No fields
feat_def = ogr.FeatureDefn('test')
f = ogr.Feature(feat_def)
if f.Validate() != 1:
gdaltest.post_reason('fail')
return 'fail'
# Field with default parameter and empty feature
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
if field_def.IsNullable() != 1:
gdaltest.post_reason('fail')
return 'fail'
if feat_def.GetGeomFieldDefn(0).IsNullable() != 1:
gdaltest.post_reason('fail')
return 'fail'
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
if f.Validate() != 1:
gdaltest.post_reason('fail')
return 'fail'
# Field with not NULL constraint and empty feature
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
field_def.SetNullable(0)
if field_def.IsNullable() != 0:
gdaltest.post_reason('fail')
return 'fail'
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
gdal.PushErrorHandler()
ret = f.Validate()
gdal.PopErrorHandler()
if ret != 0:
gdaltest.post_reason('fail')
return 'fail'
# Field with not NULL constraint and non-empty feature
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
field_def.SetNullable(0)
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.SetField(0, 'foo')
if f.Validate() != 1:
gdaltest.post_reason('fail')
return 'fail'
# Field with width constraint that is met
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
field_def.SetWidth(3)
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.SetField(0, 'foo')
if f.Validate() != 1:
gdaltest.post_reason('fail')
return 'fail'
# Field with width constraint that is not met
feat_def = ogr.FeatureDefn('test')
field_def = ogr.FieldDefn('field_string', ogr.OFTString)
field_def.SetWidth(2)
feat_def.AddFieldDefn(field_def)
f = ogr.Feature(feat_def)
f.SetField(0, 'foo')
gdal.PushErrorHandler()
ret = f.Validate()
gdal.PopErrorHandler()
if ret != 0:
gdaltest.post_reason('fail')
return 'fail'
# Geometry field with not-null geometry constraint that is met
feat_def = ogr.FeatureDefn('test')
feat_def.SetGeomType(ogr.wkbNone)
gfield_def = ogr.GeomFieldDefn('test', ogr.wkbUnknown)
gfield_def.SetNullable(0)
if gfield_def.IsNullable() != 0:
gdaltest.post_reason('fail')
return 'fail'
feat_def.AddGeomFieldDefn(gfield_def)
f = ogr.Feature(feat_def)
f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(0 1)'))
if f.Validate() != 1:
gdaltest.post_reason('fail')
return 'fail'
# Geometry field with not-null geometry constraint that is not met
feat_def = ogr.FeatureDefn('test')
feat_def.SetGeomType(ogr.wkbNone)
gfield_def = ogr.GeomFieldDefn('test', ogr.wkbPoint)
gfield_def.SetNullable(0)
feat_def.AddGeomFieldDefn(gfield_def)
f = ogr.Feature(feat_def)
gdal.PushErrorHandler()
ret = f.Validate()
gdal.PopErrorHandler()
if ret != 0:
gdaltest.post_reason('fail')
return 'fail'
# Geometry field with Point geometry type that is met
feat_def = ogr.FeatureDefn('test')
feat_def.SetGeomType(ogr.wkbPoint)
f = ogr.Feature(feat_def)
f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(0 1)'))
if f.Validate() != 1:
gdaltest.post_reason('fail')
return 'fail'
# Geometry field with LineString geometry type that is not met
feat_def = ogr.FeatureDefn('test')
feat_def.SetGeomType(ogr.wkbLineString)
f = ogr.Feature(feat_def)
f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(0 1)'))
gdal.PushErrorHandler()
ret = f.Validate()
gdal.PopErrorHandler()
if ret != 0:
gdaltest.post_reason('fail')
return 'fail'
return 'success'
def ogr_rfc41_3():
# Test with just one geometry field
feature_defn = ogr.FeatureDefn()
feature = ogr.Feature(feature_defn)
if feature.GetGeomFieldCount() != 1:
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldDefnRef(0).GetName() != '':
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldDefnRef(0).GetType() != ogr.wkbUnknown:
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldIndex('') != 0:
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldIndex('non_existing') != -1:
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldRef(-1) is not None:
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldRef(0) is not None:
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldRef(1) is not None:
gdaltest.post_reason('fail')
return 'fail'
feature_clone_without_geom = feature.Clone()
if not feature.Equal(feature_clone_without_geom):
gdaltest.post_reason('fail')
return 'fail'
if feature.SetGeomField(0, ogr.Geometry(ogr.wkbPoint)) != 0:
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldRef(0).ExportToWkt() != 'POINT EMPTY':
gdaltest.post_reason('fail')
return 'fail'
if not feature.Equal(feature.Clone()):
gdaltest.post_reason('fail')
return 'fail'
if feature.Equal(feature_clone_without_geom):
gdaltest.post_reason('fail')
return 'fail'
feature_clone_with_other_geom = feature.Clone()
feature_clone_with_other_geom.SetGeometry(ogr.Geometry(ogr.wkbLineString))
if feature.Equal(feature_clone_with_other_geom):
gdaltest.post_reason('fail')
return 'fail'
if feature.SetGeomFieldDirectly(-1, None) == 0:
gdaltest.post_reason('fail')
return 'fail'
if feature.SetGeomFieldDirectly(0, ogr.Geometry(ogr.wkbLineString)) != 0:
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldRef(0).ExportToWkt() != 'LINESTRING EMPTY':
gdaltest.post_reason('fail')
return 'fail'
feature_clone_with_geom = feature.Clone()
if feature.SetGeomFieldDirectly(0, None) != 0:
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldRef(0) != None:
gdaltest.post_reason('fail')
return 'fail'
if feature.Equal(feature_clone_with_geom):
gdaltest.post_reason('fail')
return 'fail'
feature = None
# Test one a feature with 0 geometry field
feature_defn = ogr.FeatureDefn()
feature_defn.SetGeomType(ogr.wkbNone)
feature = ogr.Feature(feature_defn)
if not feature.Equal(feature.Clone()):
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldCount() != 0:
gdaltest.post_reason('fail')
return 'fail'
# This used to work before RFC 41, but it no longer will
if feature.SetGeometry(ogr.Geometry(ogr.wkbPoint)) == 0:
gdaltest.post_reason('fail')
return 'fail'
if feature.SetGeomField(0, ogr.Geometry(ogr.wkbPoint)) == 0:
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeometryRef() is not None:
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldRef(0) is not None:
gdaltest.post_reason('fail')
return 'fail'
if feature.SetGeometryDirectly(ogr.Geometry(ogr.wkbPoint)) == 0:
gdaltest.post_reason('fail')
return 'fail'
if feature.SetGeomFieldDirectly(0, ogr.Geometry(ogr.wkbPoint)) == 0:
gdaltest.post_reason('fail')
return 'fail'
feature = None
# Test one a feature with several geometry fields
feature_defn = ogr.FeatureDefn()
feature_defn.SetGeomType(ogr.wkbNone)
gfld_defn = ogr.GeomFieldDefn('polygon_field', ogr.wkbPolygon)
feature_defn.AddGeomFieldDefn(gfld_defn)
gfld_defn = ogr.GeomFieldDefn('point_field', ogr.wkbPoint)
feature_defn.AddGeomFieldDefn(gfld_defn)
feature = ogr.Feature(feature_defn)
feature.SetGeomField(0, ogr.Geometry(ogr.wkbPolygon))
feature.SetGeomField(1, ogr.Geometry(ogr.wkbPoint))
if feature.GetGeomFieldRef(0).ExportToWkt() != 'POLYGON EMPTY':
gdaltest.post_reason('fail')
return 'fail'
if feature.GetGeomFieldRef(1).ExportToWkt() != 'POINT EMPTY':
gdaltest.post_reason('fail')
return 'fail'
if not feature.Equal(feature.Clone()):
gdaltest.post_reason('fail')
return 'fail'
other_feature = ogr.Feature(feature_defn)
if feature.Equal(other_feature):
gdaltest.post_reason('fail')
return 'fail'
other_feature.SetFrom(feature)
if not feature.Equal(other_feature):
gdaltest.post_reason('fail')
return 'fail'
# Test that in SetFrom() where target has a single geometry field,
# we get the first geometry of the source even if we cannot find a
# source geometry field with the right name.
feature_defn_default = ogr.FeatureDefn()
feature_default = ogr.Feature(feature_defn_default)
feature_default.SetFrom(feature)
if feature_default.GetGeomFieldRef(0).ExportToWkt() != 'POLYGON EMPTY':
gdaltest.post_reason('fail')
return 'fail'
return 'success'
def ogr_rfc41_2():
# Check implicit geometry field creation
feature_defn = ogr.FeatureDefn()
if feature_defn.GetGeomFieldCount() != 1:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomType() != ogr.wkbUnknown:
gdaltest.post_reason('fail')
return 'fail'
# Test IsSame()
if feature_defn.IsSame(feature_defn) != 1:
gdaltest.post_reason('fail')
return 'fail'
other_feature_defn = ogr.FeatureDefn()
if feature_defn.IsSame(other_feature_defn) != 1:
gdaltest.post_reason('fail')
return 'fail'
other_feature_defn.GetGeomFieldDefn(0).SetSpatialRef(osr.SpatialReference())
if feature_defn.IsSame(other_feature_defn) != 0:
gdaltest.post_reason('fail')
return 'fail'
feature_defn.GetGeomFieldDefn(0).SetSpatialRef(osr.SpatialReference())
if feature_defn.IsSame(other_feature_defn) != 1:
gdaltest.post_reason('fail')
return 'fail'
other_feature_defn.GetGeomFieldDefn(0).SetSpatialRef(None)
if feature_defn.IsSame(other_feature_defn) != 0:
gdaltest.post_reason('fail')
return 'fail'
feature_defn = None
feature_defn = ogr.FeatureDefn()
# Check changing geometry type
feature_defn.SetGeomType(ogr.wkbPoint)
if feature_defn.GetGeomType() != ogr.wkbPoint:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomFieldDefn(0).GetType() != ogr.wkbPoint:
gdaltest.post_reason('fail')
return 'fail'
# Check setting to wkbNone and implicitly destroying the field.
for i in range(2):
feature_defn.SetGeomType(ogr.wkbNone)
if feature_defn.GetGeomFieldCount() != 0:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomType() != ogr.wkbNone:
gdaltest.post_reason('fail')
return 'fail'
# Recreate the field
for t in [ogr.wkbPoint, ogr.wkbLineString]:
feature_defn.SetGeomType(t)
if feature_defn.GetGeomFieldCount() != 1:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomType() != t:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomFieldDefn(0).GetType() != t:
gdaltest.post_reason('fail')
return 'fail'
# Test setting invalid value
old_val = feature_defn.GetGeomType()
gdal.PushErrorHandler('CPLQuietErrorHandler')
feature_defn.SetGeomType(-3)
gdal.PopErrorHandler()
if feature_defn.GetGeomType() != old_val:
gdaltest.post_reason('fail')
return 'fail'
# Test SetIgnored() / IsIgnored()
if feature_defn.IsGeometryIgnored() != 0:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomFieldDefn(0).IsIgnored() != 0:
gdaltest.post_reason('fail')
return 'fail'
feature_defn.SetGeometryIgnored(1)
if feature_defn.IsGeometryIgnored() != 1:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomFieldDefn(0).IsIgnored() != 1:
gdaltest.post_reason('fail')
return 'fail'
# Test wrong index values for GetGeomFieldDefn()
for idx in [-1, 1]:
gdal.PushErrorHandler('CPLQuietErrorHandler')
ret = feature_defn.GetGeomFieldDefn(idx)
gdal.PopErrorHandler()
if ret is not None:
gdaltest.post_reason('fail')
return 'fail'
# Test GetGeomFieldIndex()
if feature_defn.GetGeomFieldIndex("") != 0:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomFieldIndex("invalid") != -1:
gdaltest.post_reason('fail')
return 'fail'
# Test AddGeomFieldDefn()
gfld_defn = ogr.GeomFieldDefn('polygon_field', ogr.wkbPolygon)
feature_defn.AddGeomFieldDefn(gfld_defn)
if feature_defn.GetGeomFieldCount() != 2:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomFieldIndex("polygon_field") != 1:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomFieldDefn(1).GetName() != 'polygon_field':
gdaltest.post_reason('fail')
return 'fail'
# Test DeleteGeomFieldDefn() : error cases
if feature_defn.DeleteGeomFieldDefn(-1) == 0:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.DeleteGeomFieldDefn(2) == 0:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomFieldCount() != 2:
gdaltest.post_reason('fail')
return 'fail'
# Test DeleteGeomFieldDefn() : valid cases
if feature_defn.DeleteGeomFieldDefn(0) != 0:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomFieldCount() != 1:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomFieldIndex("polygon_field") != 0:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.DeleteGeomFieldDefn(0) != 0:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.GetGeomFieldCount() != 0:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.IsSame(feature_defn) != 1:
gdaltest.post_reason('fail')
return 'fail'
if feature_defn.IsSame(ogr.FeatureDefn()) != 0:
gdaltest.post_reason('fail')
return 'fail'
feature_defn = None
return 'success'
def to_feature(shp, fid, proj=None):
feature_def = ogr.FeatureDefn()
feature = ogr.Feature(feature_def)
feature.SetGeometry(to_geometry(shp, proj=proj))
feature.SetFID(fid)
return feature
