if not os.path.exists(grid_dir): os.mkdir(grid_dir)
for shapefile in shapefiles:
grid = shapefile.split('/')[-1][4:-4] #grid number from filename
point = wd + 'point' + grid + '.shp'
allpt = wd + 'all' + grid + '.shp'
print 'Processing Grid, ', grid
'''_____________________________________________________ZONAL STATISTICS OVER MAP'''
if not point in glob.glob(wd + '/*'):
print 'points for ', grid
gme_isectpolyrst(shapefile, map_file)
'''__________________________________________________OPEN VECTOR FILE AND ADD FIELD'''
source = ogr.Open(shapefile, 1)
layer = source.GetLayer()
addIntField(layer, "label")
field_names = getFieldNames(layer)
maj_class = [x for x in field_names
if 'levV' in x][:-2] #labels for majority (skip 254, sum)
'''_______________________________________________________CALCULATE MAJORITY LABEL'''
if 'label_1' in field_names:
print '"label" field already exists for grid ' + str(grid)
sys.exit()
else:
print 'CLASS LABELS FOR MAJORITY: ', ' '.join(
[x for x in maj_class])
calcMajority(
layer, maj_class
def import_sua(self, filename, country_code, debug):
from osgeo import ogr
print("reading " + filename)
country_blacklist = self.blacklist.get(country_code, [])
temporary_file = os.path.join(
current_app.config['SKYLINES_TEMPORARY_DIR'],
os.path.basename(filename) + '.tmp')
# try to uncomment a CLASS definition, as many SUA files from soaringweb.org have a CLASS comment
with open(filename, 'r') as in_file:
with open(temporary_file, 'w') as out_file:
for line in in_file.xreadlines():
out_file.write(line.replace('# CLASS', 'CLASS'))
if debug:
print("Trying to open " + temporary_file)
airspace_file = ogr.Open(temporary_file)
if not airspace_file:
if debug:
print("OGR doesn't think that's a airspace file...")
return
layer = airspace_file.GetLayerByIndex(0)
feature = layer.GetFeature(0)
i = 0
j = 0
while (feature):
feature = layer.GetFeature(i)
i += 1
if not feature:
continue
name = unicode(feature.GetFieldAsString('title'), 'latin1').strip()
if name in country_blacklist:
print(name + " is in blacklist")
continue
if debug:
print("Adding " + name)
airspace_class = feature.GetFieldAsString('class').strip()
airspace_type = feature.GetFieldAsString('type').strip()
if airspace_type:
airspace_class = self.parse_airspace_type_tnp(airspace_type)
elif airspace_class:
airspace_class = self.parse_airspace_class_tnp(airspace_class)
else:
print(name + " has neither class nor type")
continue
added = self.add_airspace(country_code, airspace_class, name,
feature.GetFieldAsString('base'),
feature.GetFieldAsString('tops'),
"POLYGON" + str(feature.geometry())[8:])
if not added:
continue
if i % 100 == 0:
print("inserting geometry " + str(i))
j += 1
airspace_file.Destroy()
db.session.commit()
os.remove(temporary_file)
print("added " + str(j) + " features for country " + country_code)
def test_ogr_osm_1(filename='data/osm/test.pbf'):
ogrtest.osm_drv = ogr.GetDriverByName('OSM')
if ogrtest.osm_drv is None:
pytest.skip()
ds = ogr.Open(filename)
if ds is None:
if filename == 'data/osm/test.osm':
ogrtest.osm_drv_parse_osm = False
if gdal.GetLastErrorMsg().find('OSM XML detected, but Expat parser not available') == 0:
pytest.skip()
pytest.fail()
else:
if filename == 'data/osm/test.osm':
ogrtest.osm_drv_parse_osm = True
# Test points
lyr = ds.GetLayer('points')
assert lyr.GetGeomType() == ogr.wkbPoint
sr = lyr.GetSpatialRef()
assert (sr.ExportToWkt().find('GEOGCS["WGS 84",DATUM["WGS_1984",') == 0 or \
sr.ExportToWkt().find('GEOGCS["GCS_WGS_1984",DATUM["WGS_1984"') == 0)
if filename == 'data/osm/test.osm':
assert lyr.GetExtent() == (2.0, 3.0, 49.0, 50.0)
feat = lyr.GetNextFeature()
if feat.GetFieldAsString('osm_id') != '3' or \
feat.GetFieldAsString('name') != 'Some interesting point' or \
feat.GetFieldAsString('other_tags') != '"foo"=>"bar","bar"=>"baz"':
feat.DumpReadable()
pytest.fail()
if ogrtest.check_feature_geometry(feat, ogr.CreateGeometryFromWkt('POINT (3.0 49.5)')) != 0:
feat.DumpReadable()
pytest.fail()
feat = lyr.GetNextFeature()
if feat is not None:
feat.DumpReadable()
pytest.fail()
# Test lines
lyr = ds.GetLayer('lines')
assert lyr.GetGeomType() == ogr.wkbLineString
feat = lyr.GetNextFeature()
if feat.GetFieldAsString('osm_id') != '1' or \
feat.GetFieldAsString('highway') != 'motorway' or \
feat.GetFieldAsInteger('z_order') != 9 or \
feat.GetFieldAsString('other_tags') != '"foo"=>"bar"':
feat.DumpReadable()
pytest.fail()
if ogrtest.check_feature_geometry(feat, ogr.CreateGeometryFromWkt('LINESTRING (2 49,3 50)')) != 0:
feat.DumpReadable()
pytest.fail()
feat = lyr.GetNextFeature()
if feat.GetFieldAsString('osm_id') != '6':
feat.DumpReadable()
pytest.fail()
if ogrtest.check_feature_geometry(feat, ogr.CreateGeometryFromWkt('LINESTRING (2 49,3 49,3 50,2 50,2 49)')) != 0:
feat.DumpReadable()
pytest.fail()
feat = lyr.GetNextFeature()
if feat is not None:
feat.DumpReadable()
pytest.fail()
# Test multipolygons
lyr = ds.GetLayer('multipolygons')
if filename == 'tmp/ogr_osm_3':
assert lyr.GetGeomType() == ogr.wkbPolygon
else:
assert lyr.GetGeomType() == ogr.wkbMultiPolygon
feat = lyr.GetNextFeature()
if feat.GetFieldAsString('osm_id') != '1' or \
feat.GetFieldAsString('type') != 'multipolygon' or \
feat.GetFieldAsString('natural') != 'forest':
feat.DumpReadable()
pytest.fail()
if filename == 'tmp/ogr_osm_3':
if ogrtest.check_feature_geometry(feat, ogr.CreateGeometryFromWkt('POLYGON ((2 49,2 50,3 50,3 49,2 49),(2.1 49.1,2.2 49.1,2.2 49.2,2.1 49.2,2.1 49.1))')) != 0:
feat.DumpReadable()
pytest.fail()
else:
if ogrtest.check_feature_geometry(feat, ogr.CreateGeometryFromWkt('MULTIPOLYGON (((2 49,3 49,3 50,2 50,2 49),(2.1 49.1,2.2 49.1,2.2 49.2,2.1 49.2,2.1 49.1)))')) != 0:
feat.DumpReadable()
pytest.fail()
feat = lyr.GetNextFeature()
if feat.GetFieldAsString('osm_id') != '5' or \
feat.GetFieldAsString('type') != 'multipolygon' or \
feat.GetFieldAsString('natural') != 'wood':
feat.DumpReadable()
pytest.fail()
feat = lyr.GetNextFeature()
if feat.GetFieldAsString('osm_way_id') != '8' or \
feat.GetFieldAsString('name') != 'standalone_polygon':
feat.DumpReadable()
pytest.fail()
feat = lyr.GetNextFeature()
if feat is not None:
feat.DumpReadable()
pytest.fail()
# Test multilinestrings
lyr = ds.GetLayer('multilinestrings')
if filename == 'tmp/ogr_osm_3':
assert lyr.GetGeomType() == ogr.wkbLineString
else:
assert lyr.GetGeomType() == ogr.wkbMultiLineString
feat = lyr.GetNextFeature()
if feat.GetFieldAsString('osm_id') != '3' or \
feat.GetFieldAsString('type') != 'route':
feat.DumpReadable()
pytest.fail()
if filename == 'tmp/ogr_osm_3':
if ogrtest.check_feature_geometry(feat, ogr.CreateGeometryFromWkt('LINESTRING (2 49,3 50)')) != 0:
feat.DumpReadable()
pytest.fail()
else:
if ogrtest.check_feature_geometry(feat, ogr.CreateGeometryFromWkt('MULTILINESTRING ((2 49,3 50))')) != 0:
feat.DumpReadable()
pytest.fail()
feat = lyr.GetNextFeature()
if feat is not None:
feat.DumpReadable()
pytest.fail()
# Test other_relations
lyr = ds.GetLayer('other_relations')
if filename == 'tmp/ogr_osm_3':
assert lyr is None
else:
assert lyr.GetGeomType() == ogr.wkbGeometryCollection
feat = lyr.GetNextFeature()
if feat.GetFieldAsString('osm_id') != '4' or \
feat.GetFieldAsString('type') != 'other_type':
feat.DumpReadable()
pytest.fail()
if ogrtest.check_feature_geometry(feat, ogr.CreateGeometryFromWkt('GEOMETRYCOLLECTION (POINT (2 49),LINESTRING (2 49,3 50))')) != 0:
feat.DumpReadable()
pytest.fail()
feat = lyr.GetNextFeature()
if feat is not None:
feat.DumpReadable()
pytest.fail()
if ds.GetDriver().GetName() == 'OSM':
sql_lyr = ds.ExecuteSQL("GetBytesRead()")
assert sql_lyr is not None
feat = sql_lyr.GetNextFeature()
assert feat is not None
feat = sql_lyr.GetNextFeature()
assert feat is None
sql_lyr.ResetReading()
feat = sql_lyr.GetNextFeature()
assert feat is not None
sql_lyr.GetLayerDefn()
sql_lyr.TestCapability("foo")
ds.ReleaseResultSet(sql_lyr)
ds = None
def testOverwriteLayer(self):
"""Tests writing a layer with a field value converter."""
ml = QgsVectorLayer('Point?field=firstfield:int', 'test', 'memory')
provider = ml.dataProvider()
ft = QgsFeature()
ft.setAttributes([1])
provider.addFeatures([ft])
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'test'
filename = '/vsimem/out.gpkg'
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, filename, options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
ds = ogr.Open(filename, update=1)
lyr = ds.GetLayerByName('test')
self.assertIsNotNone(lyr)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 1)
ds.CreateLayer('another_layer')
del f
del lyr
del ds
caps = QgsVectorFileWriter.editionCapabilities(filename)
self.assertTrue((caps & QgsVectorFileWriter.CanAddNewLayer))
self.assertTrue((caps & QgsVectorFileWriter.CanAppendToExistingLayer))
self.assertTrue(
(caps & QgsVectorFileWriter.CanAddNewFieldsToExistingLayer))
self.assertTrue((caps & QgsVectorFileWriter.CanDeleteLayer))
self.assertTrue(QgsVectorFileWriter.targetLayerExists(
filename, 'test'))
self.assertFalse(
QgsVectorFileWriter.areThereNewFieldsToCreate(
filename, 'test', ml, [0]))
# Test CreateOrOverwriteLayer
ml = QgsVectorLayer('Point?field=firstfield:int', 'test', 'memory')
provider = ml.dataProvider()
ft = QgsFeature()
ft.setAttributes([2])
provider.addFeatures([ft])
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'test'
options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteLayer
filename = '/vsimem/out.gpkg'
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, filename, options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
ds = ogr.Open(filename)
lyr = ds.GetLayerByName('test')
self.assertIsNotNone(lyr)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 2)
# another_layer should still exist
self.assertIsNotNone(ds.GetLayerByName('another_layer'))
del f
del lyr
del ds
# Test CreateOrOverwriteFile
ml = QgsVectorLayer('Point?field=firstfield:int', 'test', 'memory')
provider = ml.dataProvider()
ft = QgsFeature()
ft.setAttributes([3])
provider.addFeatures([ft])
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'test'
filename = '/vsimem/out.gpkg'
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, filename, options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
ds = ogr.Open(filename)
lyr = ds.GetLayerByName('test')
self.assertIsNotNone(lyr)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 3)
# another_layer should no longer exist
self.assertIsNone(ds.GetLayerByName('another_layer'))
del f
del lyr
del ds
# Test AppendToLayerNoNewFields
ml = QgsVectorLayer('Point?field=firstfield:int&field=secondfield:int',
'test', 'memory')
provider = ml.dataProvider()
ft = QgsFeature()
ft.setAttributes([4, -10])
provider.addFeatures([ft])
self.assertTrue(
QgsVectorFileWriter.areThereNewFieldsToCreate(
filename, 'test', ml, [0, 1]))
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'test'
options.actionOnExistingFile = QgsVectorFileWriter.AppendToLayerNoNewFields
filename = '/vsimem/out.gpkg'
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, filename, options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
ds = ogr.Open(filename)
lyr = ds.GetLayerByName('test')
self.assertEqual(lyr.GetLayerDefn().GetFieldCount(), 1)
self.assertIsNotNone(lyr)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 3)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 4)
del f
del lyr
del ds
# Test AppendToLayerAddFields
ml = QgsVectorLayer('Point?field=firstfield:int&field=secondfield:int',
'test', 'memory')
provider = ml.dataProvider()
ft = QgsFeature()
ft.setAttributes([5, -1])
provider.addFeatures([ft])
self.assertTrue(
QgsVectorFileWriter.areThereNewFieldsToCreate(
filename, 'test', ml, [0, 1]))
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'test'
options.actionOnExistingFile = QgsVectorFileWriter.AppendToLayerAddFields
filename = '/vsimem/out.gpkg'
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, filename, options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
ds = ogr.Open(filename)
lyr = ds.GetLayerByName('test')
self.assertEqual(lyr.GetLayerDefn().GetFieldCount(), 2)
self.assertIsNotNone(lyr)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 3)
if hasattr(f, "IsFieldSetAndNotNull"):
# GDAL >= 2.2
self.assertFalse(f.IsFieldSetAndNotNull('secondfield'))
else:
self.assertFalse(f.IsFieldSet('secondfield'))
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 4)
if hasattr(f, "IsFieldSetAndNotNull"):
self.assertFalse(f.IsFieldSetAndNotNull('secondfield'))
else:
self.assertFalse(f.IsFieldSet('secondfield'))
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 5)
self.assertEqual(f['secondfield'], -1)
del f
del lyr
del ds
gdal.Unlink(filename)
from osgeo import ogr
import ch7funcs
ds = ogr.Open(r'D:\osgeopy-data\Galapagos', True)
pt_lyr = ds.GetLayerByName('albatross_lambert')
poly_lyr = ds.CreateLayer('albatross_ranges', pt_lyr.GetSpatialRef(),
ogr.wkbPolygon)
id_field = ogr.FieldDefn('tag_id', ogr.OFTString)
area_field = ogr.FieldDefn('area', ogr.OFTReal) #A
area_field.SetWidth(30) #A
area_field.SetPrecision(4) #A
poly_lyr.CreateFields([id_field, area_field])
poly_row = ogr.Feature(poly_lyr.GetLayerDefn())
for tag_id in ch7funcs.get_unique(ds, 'albatross_lambert', 'tag_id'):
print('Processing ' + tag_id)
pt_lyr.SetAttributeFilter("tag_id = '{}'".format(tag_id))
locations = ogr.Geometry(ogr.wkbMultiPoint) #B
for pt_row in pt_lyr: #B
locations.AddGeometry(pt_row.geometry().Clone()) #B
homerange = locations.ConvexHull() #C
poly_row.SetGeometry(homerange)
poly_row.SetField('tag_id', tag_id)
poly_row.SetField('area', homerange.GetArea())
poly_lyr.CreateFeature(poly_row)
del ds
def zonal_stats(feat, input_zone_polygon, input_value_raster, pointBuf):
## https://gis.stackexchange.com/questions/77993/issue-trying-to-create-zonal-statistics-using-gdal-and-python
"""
Does zonal stats on a feature from an input zone polygon
input zone poly can be a point shp too - in which case it'll use the pointBuf arg
to detemine the distance in X and Y used for creating a zone from the original point
"""
# Open raster data
raster = gdal.Open(input_value_raster)
# --- Check if current feature intersects with raster extent
# Now open up that reprojected input_zone_polygon
shp = ogr.Open(input_zone_polygon)
lyr = shp.GetLayer()
# Get raster georeference info
## gt = raster.GetGeoTransform()
## xOrigin = gt[0]
## yOrigin = gt[3]
## pixelWidth = gt[1]
## pixelHeight = gt[5]
##
## # Get extent of raster
## ## [left, top, right, bottom]
## rasterExtent = [xOrigin, yOrigin, xOrigin + (pixelWidth * raster.RasterXSize), yOrigin + (pixelHeight * raster.RasterYSize)]
rasterExtent, xOrigin, yOrigin, pixelWidth, pixelHeight = get_raster_extent(
raster)
# Get extent of feat
geom = feat.GetGeometryRef()
if (geom.GetGeometryName() == 'MULTIPOLYGON'):
count = 0
pointsX = []
pointsY = []
for polygon in geom:
geomInner = geom.GetGeometryRef(count)
ring = geomInner.GetGeometryRef(0)
numpoints = ring.GetPointCount()
for p in range(numpoints):
lon, lat, z = ring.GetPoint(p)
pointsX.append(lon)
pointsY.append(lat)
count += 1
elif (geom.GetGeometryName() == 'POLYGON'):
ring = geom.GetGeometryRef(0)
numpoints = ring.GetPointCount()
pointsX = []
pointsY = []
for p in range(numpoints):
lon, lat, z = ring.GetPoint(p)
pointsX.append(lon)
pointsY.append(lat)
elif (geom.GetGeometryName() == 'POINT'):
# Create 3 points:
# center (actual xy of point) and an UR & LL based on a buffer distance of pointBuf
pointsX = []
pointsY = []
pointsX.append(geom.GetX())
pointsX.append(geom.GetX() + pointBuf)
pointsX.append(geom.GetX() - pointBuf)
pointsY.append(geom.GetY())
pointsY.append(geom.GetY() + pointBuf)
pointsY.append(geom.GetY() - pointBuf)
else:
sys.exit()
# Get the extent of the current feature
xmin = min(pointsX)
xmax = max(pointsX)
ymin = min(pointsY)
ymax = max(pointsY)
## [left, bottom, right, top]
featExtent = [xmin, ymax, xmax, ymin]
## print '\t - Bounds: [xmin,ymin,xmax,ymax]'
## print '\t - Feature bounds: %s' % str(featExtent)
## print '\t - Raster bounds: %s' % str(rasterExtent)
# Need to find intersection of featExtent and rasterExtent here
## max of the lefts (xmins), [0]
## min of the tops
## min of the rights
## max of the bottoms
intersection = [max(rasterExtent[0], featExtent[0]) , \
min(rasterExtent[1], featExtent[1]) , \
min(rasterExtent[2], featExtent[2]) , \
max(rasterExtent[3], featExtent[3]) ]
if rasterExtent != featExtent:
print '\tLooking for overlap (intersection) b/w feature and raster...'
# check for any overlap at all...
if (intersection[2] < intersection[0]) or (intersection[1] <
intersection[3]):
intersection = None
print '\t***No overlap. Returning np.nan value for zonal statistics'
return np.nan, np.nan
else:
print '\tHere is the overlap (intersection):', intersection
# Specify offset and rows and columns to read
xoff = int((xmin - xOrigin) / pixelWidth)
yoff = int((yOrigin - ymax) / pixelWidth)
xcount = int((xmax - xmin) / pixelWidth) + 1
ycount = int((ymax - ymin) / pixelWidth) + 1
# print '\t Create memory target raster...'
target_ds = gdal.GetDriverByName('MEM').Create(
'', xcount, ycount, gdal.GDT_Byte)
target_ds.SetGeoTransform((
xmin,
pixelWidth,
0,
ymax,
0,
pixelHeight,
))
# Create for target raster the same projection as for the value raster
raster_srs = osr.SpatialReference()
raster_srs.ImportFromWkt(raster.GetProjectionRef())
target_ds.SetProjection(raster_srs.ExportToWkt())
# print '\t Rasterize zone polygon to raster, fill with 1's...'
gdal.RasterizeLayer(target_ds, [1], lyr, burn_values=[1])
# print '\tRead raster as arrays...'
banddataraster = raster.GetRasterBand(1)
try:
dataraster = banddataraster.ReadAsArray(
xoff, yoff, xcount, ycount).astype(np.float)
except Exception, e:
print '\t' + str(e)
dataraster = banddataraster.ReadAsArray(
xoff, yoff, xcount, ycount)
## print 'dataraster'
## print dataraster
# Set up datamask that is filled with 1's
bandmask = target_ds.GetRasterBand(1)
datamask = bandmask.ReadAsArray(0, 0, xcount,
ycount) ##.astype(np.float)
if geom.GetGeometryName() == 'POINT':
# For points, this has to be done, otherwise you get 0s for all but the center position...
datamask.fill(1)
## print 'datamask'
## print datamask
## print '/t xoff + xcount = ' + str(xoff) + ' + ' + str(xcount) + ' = ' + str(np.add(xoff,xcount))
## print '/t raster X size = ' + str(raster.RasterXSize)
## print '/t yoff + ycount = ' + str(yoff) + ' + ' + str(ycount) + ' = ' + str(np.add(yoff,ycount))
## print '/t raster Y size = ' + str(raster.RasterYSize)
# Mask zone of raster
try:
zoneraster = np.ma.masked_array(dataraster,
np.logical_not(datamask))
zoneraster[zoneraster <= -99.] = np.nan
try:
# Get a masked array that prevents nans from interfering
##https://stackoverflow.com/questions/5480694/numpy-calculate-averages-with-nans-removed
m_zoneraster = np.ma.masked_array(zoneraster,
np.isnan(zoneraster))
# Calculate statistics of zonal raster
##print '\t std: ' + str(round(np.std(zoneraster),2))
##return round(np.mean(zoneraster),2), round(np.std(zoneraster),2)
print '\t std: ' + str(round(m_zoneraster.std(), 2))
zValList = dataraster.flatten()
return round(m_zoneraster.mean(),
2), round(m_zoneraster.std(), 2), zValList
except Exception, e:
print '\t' + str(e)
return np.nan, np.nan, None
except Exception, e:
print '\t No stats for features straddling edge of raster.'
return np.nan, np.nan, None
def ogr_mongodb_2():
if ogrtest.mongodb_drv is None:
return 'skip'
ogrtest.mongodb_ds = ogr.Open(ogrtest.mongodb_test_uri, update=1)
if ogrtest.mongodb_ds.GetLayerByName('not_existing') is not None:
gdaltest.post_reason('fail')
return 'fail'
if ogrtest.mongodb_ds.TestCapability(ogr.ODsCCreateLayer) != 1:
gdaltest.post_reason('fail')
return 'fail'
if ogrtest.mongodb_ds.TestCapability(ogr.ODsCDeleteLayer) != 1:
gdaltest.post_reason('fail')
return 'fail'
if ogrtest.mongodb_ds.TestCapability(
ogr.ODsCCreateGeomFieldAfterCreateLayer) != 1:
gdaltest.post_reason('fail')
return 'fail'
# Create layer
a_uuid = str(uuid.uuid1()).replace('-', '_')
ogrtest.mongodb_layer_name = 'test_' + a_uuid
srs = osr.SpatialReference()
srs.ImportFromEPSG(4258) # ETRS 89 will reproject identically to EPSG:4326
lyr = ogrtest.mongodb_ds.CreateLayer(
ogrtest.mongodb_layer_name,
geom_type=ogr.wkbPolygon,
srs=srs,
options=['GEOMETRY_NAME=location.mygeom', 'FID='])
gdal.PushErrorHandler()
ret = lyr.CreateGeomField(
ogr.GeomFieldDefn('location.mygeom', ogr.wkbPoint))
gdal.PopErrorHandler()
if ret == 0:
gdaltest.post_reason('fail')
return 'fail'
ret = lyr.CreateField(ogr.FieldDefn('str', ogr.OFTString))
if ret != 0:
gdaltest.post_reason('fail')
return 'fail'
gdal.PushErrorHandler()
ret = lyr.CreateField(ogr.FieldDefn('str', ogr.OFTString))
gdal.PopErrorHandler()
if ret == 0:
gdaltest.post_reason('fail')
return 'fail'
lyr.CreateField(ogr.FieldDefn('location.name', ogr.OFTString))
bool_field = ogr.FieldDefn('bool', ogr.OFTInteger)
bool_field.SetSubType(ogr.OFSTBoolean)
lyr.CreateField(bool_field)
lyr.CreateField(ogr.FieldDefn('int', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('int64', ogr.OFTInteger64))
lyr.CreateField(ogr.FieldDefn('real', ogr.OFTReal))
lyr.CreateField(ogr.FieldDefn('dt', ogr.OFTDateTime))
lyr.CreateField(ogr.FieldDefn('embed.str', ogr.OFTString))
lyr.CreateField(ogr.FieldDefn('binary', ogr.OFTBinary))
lyr.CreateField(ogr.FieldDefn('strlist', ogr.OFTStringList))
lyr.CreateField(ogr.FieldDefn('intlist', ogr.OFTIntegerList))
lyr.CreateField(ogr.FieldDefn('int64list', ogr.OFTInteger64List))
lyr.CreateField(ogr.FieldDefn('realist', ogr.OFTRealList))
lyr.CreateField(ogr.FieldDefn('embed.embed2.int', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('embed.embed2.real', ogr.OFTReal))
# Test CreateFeature()
f = ogr.Feature(lyr.GetLayerDefn())
f['str'] = 'str'
f['location.name'] = 'Paris'
f['bool'] = 1
f['int'] = 1
f['int64'] = 1234567890123456 # put a number larger than 1 << 40 so that fromjson() doesn't pick double
f['real'] = 1.23
f['dt'] = '1234/12/31 23:59:59.123+00'
f.SetFieldBinaryFromHexString('binary', '00FF')
f['strlist'] = ['a', 'b']
f['intlist'] = [1, 2]
f['int64list'] = [1234567890123456, 1234567890123456]
f['realist'] = [1.23, 4.56]
f['embed.str'] = 'foo'
f['embed.embed2.int'] = 3
f['embed.embed2.real'] = 3.45
f.SetGeometryDirectly(
ogr.CreateGeometryFromWkt('POLYGON((2 49,2 50,3 50,3 49,2 49))'))
if lyr.CreateFeature(f) != 0:
gdaltest.post_reason('fail')
return 'fail'
if f['_id'] is None:
gdaltest.post_reason('fail')
return 'fail'
f_ref = f.Clone()
# Test GetFeatureCount()
if lyr.GetFeatureCount() != 1:
gdaltest.post_reason('fail')
return 'fail'
# Test GetNextFeature()
lyr.ResetReading()
f = lyr.GetNextFeature()
if not f.Equal(f_ref):
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
f = lyr.GetNextFeature()
if f is not None:
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
# Test GetFeature()
f = lyr.GetFeature(1)
if not f.Equal(f_ref):
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
# Test SetFeature()
f['bool'] = 0
if lyr.SetFeature(f) != 0:
gdaltest.post_reason('fail')
return 'fail'
f_ref = f.Clone()
f = lyr.GetFeature(1)
if f['bool'] != 0:
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
# Test (not working) DeleteFeature()
gdal.PushErrorHandler()
ret = lyr.DeleteFeature(1)
gdal.PopErrorHandler()
if ret == 0:
gdaltest.post_reason('fail')
return 'fail'
# Test Mongo filter
lyr.SetAttributeFilter('{ "int": 1 }')
lyr.ResetReading()
f = lyr.GetNextFeature()
if not f.Equal(f_ref):
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
lyr.SetAttributeFilter('{ "int": 2 }')
lyr.ResetReading()
f = lyr.GetNextFeature()
if f is not None:
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
# Test OGR filter
lyr.SetAttributeFilter('int = 1')
lyr.ResetReading()
f = lyr.GetNextFeature()
if not f.Equal(f_ref):
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
lyr.SetAttributeFilter('int = 2')
lyr.ResetReading()
f = lyr.GetNextFeature()
if f is not None:
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
# Test geometry filter
lyr.SetAttributeFilter(None)
lyr.SetSpatialFilterRect(2.1, 49.1, 2.9, 49.9)
lyr.ResetReading()
f = lyr.GetNextFeature()
if not f.Equal(f_ref):
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
lyr.SetSpatialFilterRect(1.1, 49.1, 1.9, 49.9)
lyr.ResetReading()
f = lyr.GetNextFeature()
if f is not None:
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
f = f_ref.Clone()
f.SetFID(-1)
f.SetGeometryDirectly(None)
if lyr.CreateFeature(f) != 0:
gdaltest.post_reason('fail')
return 'fail'
# Duplicate key
gdal.PushErrorHandler()
ret = lyr.SyncToDisk()
gdal.PopErrorHandler()
if ret == 0:
gdaltest.post_reason('fail')
return 'fail'
f['_id'] = None
lyr.CreateFeature(f)
ret = lyr.SyncToDisk()
if ret != 0:
gdaltest.post_reason('fail')
return 'fail'
# Missing _id
f.UnsetField('_id')
gdal.PushErrorHandler()
ret = lyr.SetFeature(f)
gdal.PopErrorHandler()
if ret == 0:
gdaltest.post_reason('fail')
return 'fail'
# MongoDB dialect of ExecuteSQL() with invalid JSON
gdal.PushErrorHandler()
sql_lyr = ogrtest.mongodb_ds.ExecuteSQL('{', dialect='MongoDB')
gdal.PopErrorHandler()
# MongoDB dialect of ExecuteSQL() with nonexistent command.
sql_lyr = ogrtest.mongodb_ds.ExecuteSQL('{ "foo": 1 }', dialect='MongoDB')
if sql_lyr is None:
gdaltest.post_reason('fail')
return 'fail'
ogrtest.mongodb_ds.ReleaseResultSet(sql_lyr)
# MongoDB dialect of ExecuteSQL() with existing commnand
sql_lyr = ogrtest.mongodb_ds.ExecuteSQL('{ "listCommands" : 1 }',
dialect='MongoDB')
if sql_lyr is None:
gdaltest.post_reason('fail')
return 'fail'
f = sql_lyr.GetNextFeature()
if f is None:
gdaltest.post_reason('fail')
return 'fail'
f = sql_lyr.GetNextFeature()
if f is not None:
gdaltest.post_reason('fail')
return 'fail'
sql_lyr.GetLayerDefn()
sql_lyr.ResetReading()
sql_lyr.TestCapability('')
ogrtest.mongodb_ds.ReleaseResultSet(sql_lyr)
# Regular ExecuteSQL()
sql_lyr = ogrtest.mongodb_ds.ExecuteSQL('SELECT * FROM ' +
ogrtest.mongodb_layer_name)
if sql_lyr is None:
gdaltest.post_reason('fail')
return 'fail'
ogrtest.mongodb_ds.ReleaseResultSet(sql_lyr)
# Test CreateLayer again with same name
gdal.PushErrorHandler()
lyr = ogrtest.mongodb_ds.CreateLayer(ogrtest.mongodb_layer_name)
gdal.PopErrorHandler()
if lyr is not None:
return 'fail'
ogrtest.mongodb_ds = gdal.OpenEx(
ogrtest.mongodb_test_uri,
gdal.OF_UPDATE,
open_options=[
'FEATURE_COUNT_TO_ESTABLISH_FEATURE_DEFN=-1', 'BULK_INSERT=NO',
'JSON_FIELD=TRUE'
])
# Check after reopening
lyr = ogrtest.mongodb_ds.GetLayerByName(ogrtest.mongodb_layer_name)
if lyr.TestCapability(ogr.OLCFastSpatialFilter) == 0:
gdaltest.post_reason('fail')
return 'fail'
f = lyr.GetNextFeature()
json_field = f['_json']
# We cannot use feature.Equal() has the C++ layer defn has changed
for i in range(f_ref.GetDefnRef().GetFieldCount()):
if f.GetField(i) != f_ref.GetField(i) or \
f.GetFieldDefnRef(i).GetType() != f_ref.GetFieldDefnRef(i).GetType() or \
f.GetFieldDefnRef(i).GetSubType() != f_ref.GetFieldDefnRef(i).GetSubType():
gdaltest.post_reason('fail')
f.DumpReadable()
f_ref.DumpReadable()
return 'fail'
for i in range(f_ref.GetDefnRef().GetGeomFieldCount()):
if not f.GetGeomFieldRef(i).Equals(f_ref.GetGeomFieldRef(i)) or \
f.GetGeomFieldDefnRef(i).GetName() != f_ref.GetGeomFieldDefnRef(i).GetName() or \
f.GetGeomFieldDefnRef(i).GetType() != f_ref.GetGeomFieldDefnRef(i).GetType():
gdaltest.post_reason('fail')
f.DumpReadable()
f_ref.DumpReadable()
return 'fail'
lyr.SetSpatialFilterRect(2.1, 49.1, 2.9, 49.9)
lyr.ResetReading()
if f is None:
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
# Create a feature only from its _json content and do not store any ogr metadata related to the layer
ogrtest.mongodb_layer_name_no_ogr_metadata = ogrtest.mongodb_layer_name + "_no_ogr_metadata"
lyr = ogrtest.mongodb_ds.CreateLayer(
ogrtest.mongodb_layer_name_no_ogr_metadata,
options=[
'GEOMETRY_NAME=location.mygeom', 'FID=', 'WRITE_OGR_METADATA=NO'
])
f = ogr.Feature(lyr.GetLayerDefn())
f['_json'] = json_field
if lyr.CreateFeature(f) != 0:
gdaltest.post_reason('fail')
return 'fail'
ogrtest.mongodb_layer_name_guess_types = ogrtest.mongodb_layer_name + "_guess_types"
lyr = ogrtest.mongodb_ds.CreateLayer(
ogrtest.mongodb_layer_name_guess_types,
geom_type=ogr.wkbNone,
options=['FID=', 'WRITE_OGR_METADATA=NO'])
f = ogr.Feature(lyr.GetLayerDefn())
f['_json'] = '{'
f['_json'] += '"int": 2, '
f['_json'] += '"int64": { "$numberLong" : "1234567890123456" }, '
f['_json'] += '"real": 2.34, '
f['_json'] += '"intlist" : [2], '
f['_json'] += '"reallist" : [2.34], '
f['_json'] += '"int64list" : [{ "$numberLong" : "1234567890123456" }], '
f['_json'] += '"int_str" : 2, '
f['_json'] += '"str_int" : "2", '
f['_json'] += '"int64_str" : { "$numberLong" : "1234567890123456" }, '
f['_json'] += '"str_int64" : "2", '
f['_json'] += '"int_int64": 2, '
f['_json'] += '"int64_int": { "$numberLong" : "1234567890123456" }, '
f['_json'] += '"int_real": 2, '
f['_json'] += '"real_int": 3.45, '
f['_json'] += '"int64_real": { "$numberLong" : "1234567890123456" }, '
f['_json'] += '"real_int64": 3.45, '
f['_json'] += '"real_str": 3.45, '
f['_json'] += '"str_real": "3.45", '
f['_json'] += '"int_bool" : 2, '
f['_json'] += '"bool_int" : true, '
f['_json'] += '"intlist_strlist" : [2], '
f['_json'] += '"strlist_intlist" : ["2"], '
f['_json'] += '"intlist_int64list": [2], '
f['_json'] += '"int64list_intlist": [{ "$numberLong" : "1234567890123456" }], '
f['_json'] += '"intlist_reallist": [2], '
f['_json'] += '"reallist_intlist": [3.45], '
f['_json'] += '"int64list_reallist": [{ "$numberLong" : "1234567890123456" }], '
f['_json'] += '"reallist_int64list": [3.45], '
f['_json'] += '"intlist_boollist" : [2], '
f['_json'] += '"boollist_intlist" : [true], '
f['_json'] += '"mixedlist": [true,1,{ "$numberLong" : "1234567890123456" },3.45],'
f['_json'] += '"mixedlist2": [true,1,{ "$numberLong" : "1234567890123456" },3.45,"str"]'
f['_json'] += '}'
if lyr.CreateFeature(f) != 0:
gdaltest.post_reason('fail')
return 'fail'
f = ogr.Feature(lyr.GetLayerDefn())
f['_json'] = '{'
f['_json'] += '"int_str" : "3", '
f['_json'] += '"str_int" : 3, '
f['_json'] += '"int64_str" : "2", '
f['_json'] += '"str_int64" : { "$numberLong" : "1234567890123456" }, '
f['_json'] += '"int_int64": { "$numberLong" : "1234567890123456" }, '
f['_json'] += '"int64_int": 2, '
f['_json'] += '"int_real" : 3.45, '
f['_json'] += '"real_int": 2, '
f['_json'] += '"int64_real": 3.45, '
f['_json'] += '"real_int64": { "$numberLong" : "1234567890123456" }, '
f['_json'] += '"real_str": "3.45", '
f['_json'] += '"str_real": 3.45, '
f['_json'] += '"int_bool" : true, '
f['_json'] += '"bool_int" : 2, '
f['_json'] += '"intlist_strlist" : ["3"], '
f['_json'] += '"strlist_intlist" : [3], '
f['_json'] += '"intlist_int64list": [{ "$numberLong" : "1234567890123456" }], '
f['_json'] += '"int64list_intlist": [2], '
f['_json'] += '"intlist_reallist": [3.45], '
f['_json'] += '"reallist_intlist": [2], '
f['_json'] += '"int64list_reallist": [3.45], '
f['_json'] += '"reallist_int64list": [{ "$numberLong" : "1234567890123456" }], '
f['_json'] += '"intlist_boollist" : [true], '
f['_json'] += '"boollist_intlist" : [2]'
f['_json'] += '}'
if lyr.CreateFeature(f) != 0:
gdaltest.post_reason('fail')
return 'fail'
# This new features will not be taken into account by below the FEATURE_COUNT_TO_ESTABLISH_FEATURE_DEFN=2
f = ogr.Feature(lyr.GetLayerDefn())
f['_json'] = '{'
f['_json'] += '"int": { "$minKey": 1 }, '
f['_json'] += '"int64": { "$minKey": 1 }, '
f['_json'] += '"real": { "$minKey": 1 }, '
f['_json'] += '"intlist" : [1, "1", { "$minKey": 1 },{ "$maxKey": 1 },{ "$numberLong" : "-1234567890123456" }, { "$numberLong" : "1234567890123456" }, -1234567890123456.1, 1234567890123456.1, { "$numberLong" : "1" }, 1.23 ], '
f['_json'] += '"int64list" : [1, { "$numberLong" : "1234567890123456" }, "1", { "$minKey": 1 },{ "$maxKey": 1 }, -1e300, 1e300, 1.23 ], '
f['_json'] += '"reallist" : [1, { "$numberLong" : "1234567890123456" }, 1.0, "1", { "$minKey": 1 },{ "$maxKey": 1 }, { "$numberLong" : "1234567890123456" } ] '
f['_json'] += '}'
if lyr.CreateFeature(f) != 0:
gdaltest.post_reason('fail')
return 'fail'
f = ogr.Feature(lyr.GetLayerDefn())
f['_json'] = '{'
f['_json'] += '"int": { "$maxKey": 1 }, '
f['_json'] += '"int64": { "$maxKey": 1 }, '
f['_json'] += '"real": { "$maxKey": 1 } '
f['_json'] += '}'
if lyr.CreateFeature(f) != 0:
gdaltest.post_reason('fail')
return 'fail'
ogrtest.mongodb_layer_name_with_2d_index = ogrtest.mongodb_layer_name + "_with_2d_index"
gdal.SetConfigOption('OGR_MONGODB_SPAT_INDEX_TYPE', '2d')
lyr = ogrtest.mongodb_ds.CreateLayer(
ogrtest.mongodb_layer_name_with_2d_index,
geom_type=ogr.wkbPoint,
options=['FID=', 'WRITE_OGR_METADATA=NO'])
gdal.SetConfigOption('OGR_MONGODB_SPAT_INDEX_TYPE', None)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetGeometryDirectly(ogr.CreateGeometryFromWkt('POINT(2 49)'))
if lyr.CreateFeature(f) != 0:
gdaltest.post_reason('fail')
return 'fail'
ogrtest.mongodb_layer_name_no_spatial_index = ogrtest.mongodb_layer_name + "_no_spatial_index"
for i in range(2):
lyr = ogrtest.mongodb_ds.CreateLayer(
ogrtest.mongodb_layer_name_no_spatial_index,
options=['SPATIAL_INDEX=NO', 'OVERWRITE=YES'])
f = ogr.Feature(lyr.GetLayerDefn())
f.SetGeometryDirectly(ogr.CreateGeometryFromWkt('POINT(2 49)'))
if lyr.CreateFeature(f) != 0:
gdaltest.post_reason('fail')
return 'fail'
ogrtest.mongodb_ds.ExecuteSQL(
'WRITE_OGR_METADATA ' +
ogrtest.mongodb_layer_name_no_spatial_index)
# Open "ghost" layer
lyr = ogrtest.mongodb_ds.GetLayerByName('_ogr_metadata')
if lyr is None:
gdaltest.post_reason('fail')
return 'fail'
lyr.SetAttributeFilter("layer LIKE '%s%%'" % ogrtest.mongodb_layer_name)
if lyr.GetFeatureCount() != 2:
print(lyr.GetFeatureCount())
gdaltest.post_reason('fail')
return 'fail'
if ogrtest.mongodb_ds.DeleteLayer(-1) == 0:
gdaltest.post_reason('fail')
return 'fail'
lyr = ogrtest.mongodb_ds.GetLayerByName(ogrtest.mongodb_test_dbname + '.' +
'_ogr_metadata')
if lyr is None:
gdaltest.post_reason('fail')
return 'fail'
ogrtest.mongodb_ds = None
# Reopen in read-only
ogrtest.mongodb_ds = gdal.OpenEx(
ogrtest.mongodb_test_uri,
0,
open_options=[
'FEATURE_COUNT_TO_ESTABLISH_FEATURE_DEFN=2', 'JSON_FIELD=TRUE'
])
lyr = ogrtest.mongodb_ds.GetLayerByName(
ogrtest.mongodb_layer_name_no_ogr_metadata)
if lyr.TestCapability(ogr.OLCFastSpatialFilter) != 0:
gdaltest.post_reason('fail')
return 'fail'
f = lyr.GetNextFeature()
for i in range(f_ref.GetDefnRef().GetFieldCount()):
# Order might be a bit different...
j = f.GetDefnRef().GetFieldIndex(f_ref.GetFieldDefnRef(i).GetNameRef())
if f.GetField(j) != f_ref.GetField(i) or \
f.GetFieldDefnRef(j).GetType() != f_ref.GetFieldDefnRef(i).GetType() or \
f.GetFieldDefnRef(j).GetSubType() != f_ref.GetFieldDefnRef(i).GetSubType():
gdaltest.post_reason('fail')
f.DumpReadable()
f_ref.DumpReadable()
return 'fail'
for i in range(f_ref.GetDefnRef().GetGeomFieldCount()):
# Order might be a bit different...
j = f.GetDefnRef().GetGeomFieldIndex(
f_ref.GetGeomFieldDefnRef(i).GetNameRef())
if not f.GetGeomFieldRef(j).Equals(f_ref.GetGeomFieldRef(i)) or \
f.GetGeomFieldDefnRef(j).GetName() != f_ref.GetGeomFieldDefnRef(i).GetName() or \
f.GetGeomFieldDefnRef(j).GetType() != f_ref.GetGeomFieldDefnRef(i).GetType():
gdaltest.post_reason('fail')
f.DumpReadable()
f_ref.DumpReadable()
print(f.GetGeomFieldDefnRef(j).GetType())
print(f_ref.GetGeomFieldDefnRef(i).GetType())
return 'fail'
lyr.SetSpatialFilterRect(2.1, 49.1, 2.9, 49.9)
lyr.ResetReading()
if f is None:
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
lyr = ogrtest.mongodb_ds.GetLayerByName(
ogrtest.mongodb_layer_name_guess_types)
expected_fields = [
("int", ogr.OFTInteger), ("int64", ogr.OFTInteger64),
("real", ogr.OFTReal), ("intlist", ogr.OFTIntegerList),
("reallist", ogr.OFTRealList), ("int64list", ogr.OFTInteger64List),
("int_str", ogr.OFTString), ("str_int", ogr.OFTString),
("int64_str", ogr.OFTString), ("str_int64", ogr.OFTString),
("int_int64", ogr.OFTInteger64), ("int64_int", ogr.OFTInteger64),
("int_real", ogr.OFTReal), ("real_int", ogr.OFTReal),
("int64_real", ogr.OFTReal), ("real_int64", ogr.OFTReal),
("real_str", ogr.OFTString), ("str_real", ogr.OFTString),
("int_bool", ogr.OFTInteger), ("bool_int", ogr.OFTInteger),
("intlist_strlist", ogr.OFTStringList),
("strlist_intlist", ogr.OFTStringList),
("intlist_int64list", ogr.OFTInteger64List),
("int64list_intlist", ogr.OFTInteger64List),
("intlist_reallist", ogr.OFTRealList),
("reallist_intlist", ogr.OFTRealList),
("int64list_reallist", ogr.OFTRealList),
("reallist_int64list", ogr.OFTRealList),
("intlist_boollist", ogr.OFTIntegerList),
("boollist_intlist", ogr.OFTIntegerList),
("mixedlist", ogr.OFTRealList), ("mixedlist2", ogr.OFTStringList)
]
for (fieldname, fieldtype) in expected_fields:
fld_defn = lyr.GetLayerDefn().GetFieldDefn(
lyr.GetLayerDefn().GetFieldIndex(fieldname))
if fld_defn.GetType() != fieldtype:
gdaltest.post_reason('fail')
print(fieldname)
print(fld_defn.GetType())
return 'fail'
if fld_defn.GetSubType() != ogr.OFSTNone:
gdaltest.post_reason('fail')
return 'fail'
f = lyr.GetNextFeature()
f = lyr.GetNextFeature()
f = lyr.GetNextFeature()
if f['intlist'] != [1,1,-2147483648,2147483647,-2147483648,2147483647,-2147483648,2147483647,1,1] or \
f['int64list'] != [1,1234567890123456,1,-9223372036854775808,9223372036854775807,-9223372036854775808,9223372036854775807,1] or \
f['int'] != -2147483648 or f['int64'] != -9223372036854775808 or f['real'] - 1 != f['real']:
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
f = lyr.GetNextFeature()
if f['int'] != 2147483647 or f[
'int64'] != 9223372036854775807 or f['real'] + 1 != f['real']:
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
lyr = ogrtest.mongodb_ds.GetLayerByName(
ogrtest.mongodb_layer_name_with_2d_index)
if lyr.TestCapability(ogr.OLCFastSpatialFilter) == 0:
gdaltest.post_reason('fail')
return 'fail'
lyr.SetSpatialFilterRect(1.9, 48.9, 2.1, 49.1)
lyr.ResetReading()
f = lyr.GetNextFeature()
if f is None:
gdaltest.post_reason('fail')
return 'fail'
lyr.SetSpatialFilterRect(1.9, 48.9, 1.95, 48.95)
lyr.ResetReading()
f = lyr.GetNextFeature()
if f is not None:
gdaltest.post_reason('fail')
return 'fail'
lyr = ogrtest.mongodb_ds.GetLayerByName(
ogrtest.mongodb_layer_name_no_spatial_index)
if lyr.TestCapability(ogr.OLCFastSpatialFilter) != 0:
gdaltest.post_reason('fail')
print(lyr.TestCapability(ogr.OLCFastSpatialFilter))
return 'fail'
lyr.SetSpatialFilterRect(1.9, 48.9, 2.1, 49.1)
lyr.ResetReading()
f = lyr.GetNextFeature()
if f is None:
gdaltest.post_reason('fail')
return 'fail'
gdal.PushErrorHandler()
lyr = ogrtest.mongodb_ds.CreateLayer('foo')
gdal.PopErrorHandler()
if lyr is not None:
gdaltest.post_reason('fail')
return 'fail'
gdal.ErrorReset()
gdal.PushErrorHandler()
ogrtest.mongodb_ds.ExecuteSQL('WRITE_OGR_METADATA ' +
ogrtest.mongodb_layer_name)
gdal.PopErrorHandler()
if gdal.GetLastErrorMsg() == '':
gdaltest.post_reason('fail')
return 'fail'
lyr_count_before = ogrtest.mongodb_ds.GetLayerCount()
gdal.PushErrorHandler()
ogrtest.mongodb_ds.ExecuteSQL('DELLAYER:' + ogrtest.mongodb_layer_name)
gdal.PopErrorHandler()
if ogrtest.mongodb_ds.GetLayerCount() != lyr_count_before:
gdaltest.post_reason('fail')
return 'fail'
lyr = ogrtest.mongodb_ds.GetLayerByName(ogrtest.mongodb_layer_name)
gdal.PushErrorHandler()
ret = lyr.CreateField(ogr.FieldDefn('foo', ogr.OFTString))
gdal.PopErrorHandler()
if ret == 0:
gdaltest.post_reason('fail')
return 'fail'
gdal.PushErrorHandler()
ret = lyr.CreateGeomField(ogr.GeomFieldDefn('foo', ogr.wkbPoint))
gdal.PopErrorHandler()
if ret == 0:
gdaltest.post_reason('fail')
return 'fail'
f = ogr.Feature(lyr.GetLayerDefn())
gdal.PushErrorHandler()
ret = lyr.CreateFeature(f)
gdal.PopErrorHandler()
if ret == 0:
gdaltest.post_reason('fail')
return 'fail'
gdal.PushErrorHandler()
ret = lyr.SetFeature(f)
gdal.PopErrorHandler()
if ret == 0:
gdaltest.post_reason('fail')
return 'fail'
gdal.PushErrorHandler()
ret = lyr.DeleteFeature(1)
gdal.PopErrorHandler()
if ret == 0:
gdaltest.post_reason('fail')
return 'fail'
return 'success'
def read_shp(path, simplify=True, geom_attrs=True, strict=True):
"""Generates a networkx.DiGraph from shapefiles. Point geometries are
translated into nodes, lines into edges. Coordinate tuples are used as
keys. Attributes are preserved, line geometries are simplified into start
and end coordinates. Accepts a single shapefile or directory of many
shapefiles.
"The Esri Shapefile or simply a shapefile is a popular geospatial vector
data format for geographic information systems software [1]_."
Parameters
----------
path : file or string
File, directory, or filename to read.
simplify: bool
If True, simplify line geometries to start and end coordinates.
If False, and line feature geometry has multiple segments, the
non-geometric attributes for that feature will be repeated for each
edge comprising that feature.
geom_attrs: bool
If True, include the Wkb, Wkt and Json geometry attributes with
each edge.
NOTE: if these attributes are available, write_shp will use them
to write the geometry. If nodes store the underlying coordinates for
the edge geometry as well (as they do when they are read via
this method) and they change, your geomety will be out of sync.
strict: bool
If True, raise NetworkXError when feature geometry is missing or
GeometryType is not supported.
If False, silently ignore missing or unsupported geometry in features.
Returns
-------
G : NetworkX graph
Raises
------
ImportError
If ogr module is not available.
RuntimeError
If file cannot be open or read.
NetworkXError
If strict=True and feature is missing geometry or GeometryType is
not supported.
Examples
--------
>>> G = nx.read_shp('test.shp') # doctest: +SKIP
References
----------
.. [1] https://en.wikipedia.org/wiki/Shapefile
"""
try:
from osgeo import ogr
except ImportError:
raise ImportError("read_shp requires OGR: http://www.gdal.org/")
if not isinstance(path, str):
return
net = nx.DiGraph()
shp = ogr.Open(path)
if shp is None:
raise RuntimeError("Unable to open {}".format(path))
for lyr in shp:
fields = [x.GetName() for x in lyr.schema]
for f in lyr:
g = f.geometry()
if g is None:
if strict:
raise nx.NetworkXError(
"Bad data: feature missing geometry")
else:
continue
flddata = [f.GetField(f.GetFieldIndex(x)) for x in fields]
attributes = dict(zip(fields, flddata))
attributes["ShpName"] = lyr.GetName()
# Note: Using layer level geometry type
if g.GetGeometryType() == ogr.wkbPoint:
net.add_node((g.GetPoint_2D(0)), **attributes)
elif g.GetGeometryType() in (ogr.wkbLineString,
ogr.wkbMultiLineString):
for edge in edges_from_line(g, attributes, simplify,
geom_attrs):
e1, e2, attr = edge
net.add_edge(e1, e2)
net[e1][e2].update(attr)
else:
if strict:
raise nx.NetworkXError(
"GeometryType {} not supported".format(
g.GetGeometryType()))
return net
def Rasterize_GLIM_geologic_maps_pythonic(shapefile_name, raster_resolution = 400):
# The shapefile to be rasterized:
print('Rasterize ' + shapefile_name)
#get path and filename seperately
shapefilefilepath = LSDPT.GetPath(shapefile_name)
shapefilename = LSDPT.GetFileNameNoPath(shapefile_name)
shapefileshortname = LSDPT.GetFilePrefix(shapefile_name)
print("Shapefile name is: "+shapefilename)
# now get the the fields from the shapefile
daShapefile = shapefile_name
dataSource = ogr.Open(daShapefile)
daLayer = dataSource.GetLayer(0)
# lets see what the layers are
print("Let me tell you what the names of the fields are!")
layerDefinition = daLayer.GetLayerDefn()
for i in range(layerDefinition.GetFieldCount()):
print(layerDefinition.GetFieldDefn(i).GetName())
# The raster file to be created and receive the rasterized shapefile
outrastername = shapefileshortname + '.tif'
outraster = shapefilefilepath+os.sep+ outrastername
outcsv = shapefilefilepath+os.sep+shapefileshortname+'_lithokey.csv'
print("Full name of out raster is: "+outraster)
# Create the destination data source
inGridSize=float(raster_resolution)
xMin, xMax, yMin, yMax = daLayer.GetExtent()
xRes = int((xMax - xMin) / inGridSize)
yRes = int((yMax - yMin) / inGridSize)
rasterDS = gdal.GetDriverByName('GTiff').Create(outraster, xRes, yRes, 1, gdal.GDT_Byte)
# Define spatial reference
NoDataVal = -9999
rasterDS.SetProjection(daLayer.GetSpatialRef().ExportToWkt())
rasterDS.SetGeoTransform((xMin, inGridSize, 0, yMax, 0, -inGridSize))
rBand = rasterDS.GetRasterBand(1)
rBand.SetNoDataValue(NoDataVal)
rBand.Fill(NoDataVal)
# Rasterize
gdal.RasterizeLayer(rasterDS, [1], daLayer, options = ["ATTRIBUTE=GEOL_CODE"])
# Make a key for the bedrock
geol_dict = dict()
for feature in daLayer:
ID = feature.GetField("xx")
GEOL = feature.GetField("GEOL_CODE")
if ID not in geol_dict:
print("I found a new rock type, ID: "+ str(ID)+ " and rock type: " + str(GEOL))
geol_dict[ID] = GEOL
print("The rocks are: ")
print(geol_dict)
with open(outcsv, 'wb') as f:
f.write('ID,rocktype\n')
for key in geol_dict:
f.write(str(key)+','+ str(geol_dict[key])+'\n')
print("Done rasterizing!")
return outraster
# Script to read attributes from a shapefile.
# Don't forget to import ogr
import sys
from osgeo import ogr
# Open the data source and get the layer
fn = r'D:\osgeopy-data\global\ne_50m_populated_places.shp'
ds = ogr.Open(fn, 0)
if ds is None:
sys.exit('Could not open {0}.'.format(fn))
lyr = ds.GetLayer(0)
i = 0
for feat in lyr:
# Get the x,y coordinates
pt = feat.geometry()
x = pt.GetX()
y = pt.GetY()
# Get the attribute values
name = feat.GetField('NAME')
pop = feat.GetField('POP_MAX')
print(name, pop, x, y)
i += 1
if i == 10:
break
del ds
def ogr_plscenes_data_v1_live():
if gdaltest.plscenes_drv is None:
return 'skip'
api_key = gdal.GetConfigOption('PL_API_KEY')
if api_key is None:
print('Skipping test as PL_API_KEY not defined')
return 'skip'
gdal.SetConfigOption('PLSCENES_PAGE_SIZE', '10')
ds = ogr.Open('PLScenes:version=data_v1,FOLLOW_LINKS=YES')
gdal.SetConfigOption('PLSCENES_PAGE_SIZE', None)
if ds is None:
gdaltest.post_reason('fail')
return 'fail'
lyr = ds.GetLayer(0)
if lyr is None:
gdaltest.post_reason('fail')
return 'fail'
lyr.SetAttributeFilter("permissions = 'assets:download'")
f = lyr.GetNextFeature()
if f is None:
gdaltest.post_reason('fail')
return 'fail'
catalog = lyr.GetName()
scene = f['id']
f.DumpReadable()
lyr_defn = lyr.GetLayerDefn()
asset_name = None
for i in range(lyr_defn.GetFieldCount()):
fld_defn = lyr_defn.GetFieldDefn(i)
name = fld_defn.GetName()
if name.startswith('asset_') and name.endswith(
'_activate_link') and f.GetFieldAsString(i) != '':
asset_name = name[len('asset_'):-len('_activate_link')]
break
elif name.startswith('asset_') and name.endswith(
'_location') and f.GetFieldAsString(i) != '':
asset_name = name[len('asset_'):-len('_location')]
break
if asset_name is None:
gdaltest.post_reason('fail')
return 'fail'
acquired_field = lyr_defn.GetFieldIndex('acquired')
if acquired_field < 0 or lyr_defn.GetFieldDefn(
acquired_field).GetType() != ogr.OFTDateTime:
gdaltest.post_reason('fail')
return 'fail'
if not f.IsFieldSet(acquired_field):
gdaltest.post_reason('fail')
f.DumpReadable()
return 'fail'
int_field = -1
float_field = -1
string_field = -1
for i in range(lyr_defn.GetFieldCount()):
typ = lyr_defn.GetFieldDefn(i).GetType()
if int_field < 0 and typ == ogr.OFTInteger and f.IsFieldSet(i):
int_field = i
elif float_field < 0 and typ == ogr.OFTReal and f.IsFieldSet(i):
float_field = i
elif string_field < 0 and typ == ogr.OFTString and f.IsFieldSet(i):
string_field = i
filtr = "acquired='%s'" % f.GetFieldAsString(acquired_field)
if int_field >= 0:
name = lyr_defn.GetFieldDefn(int_field).GetName()
mini = f.GetField(int_field) - 1
maxi = f.GetField(int_field) + 1
filtr += ' AND %s >= %d AND %s <= %d' % (name, mini, name, maxi)
if float_field >= 0:
name = lyr_defn.GetFieldDefn(float_field).GetName()
mini = f.GetField(float_field) - 0.01
maxi = f.GetField(float_field) + 0.01
filtr += ' AND %s BETWEEN %f AND %f' % (name, mini, maxi)
if string_field >= 0:
name = lyr_defn.GetFieldDefn(string_field).GetName()
value = f.GetField(string_field)
filtr += " AND %s = '%s'" % (name, value)
lyr.SetAttributeFilter(filtr)
f = lyr.GetNextFeature()
if f is None:
gdaltest.post_reason('fail')
return 'fail'
ds = None
ds = gdal.Open('PLScenes:version=data_v1,itemtypes=%s,scene=%s,asset=%s' %
(catalog, scene, asset_name))
if ds is None:
gdaltest.post_reason('fail')
return 'fail'
if ds.RasterCount == 0:
gdaltest.post_reason('fail')
return 'fail'
return 'success'
def test(self):
# Skip if GDAL python bindings are not available
try:
from osgeo import gdal, ogr
except:
return
version_num = int(gdal.VersionInfo('VERSION_NUM'))
if version_num < GDAL_COMPUTE_VERSION(1, 11, 0):
return
dialog = QgsNewGeoPackageLayerDialog()
dialog.setProperty("hideDialogs", True)
mDatabase = dialog.findChild(QgsFileWidget, "mDatabase")
buttonBox = dialog.findChild(QDialogButtonBox, "buttonBox")
ok_button = buttonBox.button(QDialogButtonBox.Ok)
mTableNameEdit = dialog.findChild(QLineEdit, "mTableNameEdit")
mLayerIdentifierEdit = dialog.findChild(QLineEdit,
"mLayerIdentifierEdit")
mLayerDescriptionEdit = dialog.findChild(QLineEdit,
"mLayerDescriptionEdit")
mFeatureIdColumnEdit = dialog.findChild(QLineEdit,
"mFeatureIdColumnEdit")
mGeometryTypeBox = dialog.findChild(QComboBox, "mGeometryTypeBox")
mGeometryColumnEdit = dialog.findChild(QLineEdit,
"mGeometryColumnEdit")
mFieldNameEdit = dialog.findChild(QLineEdit, "mFieldNameEdit")
mFieldTypeBox = dialog.findChild(QComboBox, "mFieldTypeBox")
mFieldLengthEdit = dialog.findChild(QLineEdit, "mFieldLengthEdit")
mAddAttributeButton = dialog.findChild(QToolButton,
"mAddAttributeButton")
mRemoveAttributeButton = dialog.findChild(QToolButton,
"mRemoveAttributeButton")
mAttributeView = dialog.findChild(QTreeWidget, "mAttributeView")
dialog.accepted.connect(self.accepted_slot)
mGeometryTypeBox.setCurrentIndex(
mGeometryTypeBox.findData(ogr.wkbPoint))
self.assertEqual(mGeometryTypeBox.currentText(), "Point")
self.assertFalse(ok_button.isEnabled())
dbname = os.path.join(self.basetestpath, 'test.gpkg')
mDatabase.setFilePath(dbname)
self.assertEqual(mTableNameEdit.text(), 'test')
self.assertEqual(mLayerIdentifierEdit.text(), 'test')
self.assertTrue(ok_button.isEnabled())
mGeometryColumnEdit.setText('my_geom')
mFeatureIdColumnEdit.setText('my_fid')
self.assertFalse(mAddAttributeButton.isEnabled())
self.assertFalse(mRemoveAttributeButton.isEnabled())
mFieldNameEdit.setText('strfield')
self.assertTrue(mAddAttributeButton.isEnabled())
mFieldLengthEdit.setText('10')
QTest.mouseClick(mAddAttributeButton, Qt.LeftButton)
mFieldNameEdit.setText('intfield')
mFieldTypeBox.setCurrentIndex(mFieldTypeBox.findData('integer'))
self.assertFalse(mFieldLengthEdit.isEnabled())
QTest.mouseClick(mAddAttributeButton, Qt.LeftButton)
mFieldNameEdit.setText('realfield')
mFieldTypeBox.setCurrentIndex(mFieldTypeBox.findData('real'))
self.assertFalse(mFieldLengthEdit.isEnabled())
QTest.mouseClick(mAddAttributeButton, Qt.LeftButton)
mFieldNameEdit.setText('datefield')
mFieldTypeBox.setCurrentIndex(mFieldTypeBox.findData('date'))
self.assertFalse(mFieldLengthEdit.isEnabled())
QTest.mouseClick(mAddAttributeButton, Qt.LeftButton)
mFieldNameEdit.setText('datetimefield')
mFieldTypeBox.setCurrentIndex(mFieldTypeBox.findData('datetime'))
self.assertFalse(mFieldLengthEdit.isEnabled())
QTest.mouseClick(mAddAttributeButton, Qt.LeftButton)
if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0):
mFieldNameEdit.setText('int64field')
mFieldTypeBox.setCurrentIndex(mFieldTypeBox.findData('integer64'))
self.assertFalse(mFieldLengthEdit.isEnabled())
QTest.mouseClick(mAddAttributeButton, Qt.LeftButton)
# Add and remove field
mFieldNameEdit.setText('dummy')
self.assertFalse(mFieldLengthEdit.isEnabled())
QTest.mouseClick(mAddAttributeButton, Qt.LeftButton)
index = mAttributeView.model().index(
mAttributeView.model().rowCount() - 1, 0)
mAttributeView.setCurrentIndex(index)
QTest.mouseClick(mRemoveAttributeButton, Qt.LeftButton)
self.accepted = False
QTest.mouseClick(ok_button, Qt.LeftButton)
self.assertTrue(self.accepted)
layers = QgsProject.instance().mapLayers()
self.assertEqual(len(layers), 1)
layer = layers[list(layers.keys())[0]]
self.assertEqual(layer.name(), 'test')
self.assertEqual(layer.geometryType(), QgsWkbTypes.PointGeometry)
QgsProject.instance().removeAllMapLayers()
ds = ogr.Open(dbname)
lyr = ds.GetLayer(0)
self.assertEqual(lyr.GetFIDColumn(), 'my_fid')
self.assertEqual(lyr.GetGeometryColumn(), 'my_geom')
self.assertEqual(lyr.GetGeomType(), ogr.wkbPoint)
if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0):
self.assertEqual(lyr.GetLayerDefn().GetFieldCount(), 6)
else:
self.assertEqual(lyr.GetLayerDefn().GetFieldCount(), 5)
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(0).GetNameRef(),
'strfield')
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(0).GetType(),
ogr.OFTString)
# Only GDAL 2.0 recognizes string field width
if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0):
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(0).GetWidth(), 10)
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(1).GetNameRef(),
'intfield')
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(1).GetType(),
ogr.OFTInteger)
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(1).GetWidth(), 0)
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(2).GetNameRef(),
'realfield')
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(2).GetType(),
ogr.OFTReal)
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(2).GetWidth(), 0)
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(3).GetNameRef(),
'datefield')
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(3).GetType(),
ogr.OFTDate)
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(3).GetWidth(), 0)
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(4).GetNameRef(),
'datetimefield')
if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0):
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(4).GetType(),
ogr.OFTDateTime)
else:
# There's a bug in OGR 1.11. The field is probably declared as DATETIME in SQL
# but OGR detects it as OFTDate
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(4).GetType(),
ogr.OFTDate)
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(4).GetWidth(), 0)
if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0):
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(5).GetNameRef(),
'int64field')
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(5).GetType(),
ogr.OFTInteger64)
self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(5).GetWidth(), 0)
ds = None
# Try re-adding with different table. It should ask if we want to
# overwrite the DB, and we'll implicitly answer cancel, hence failure
mTableNameEdit.setText('table2')
self.accepted = False
QTest.mouseClick(ok_button, Qt.LeftButton)
self.assertFalse(self.accepted)
# Retry, and ask to keep the DB
self.accepted = False
dialog.setProperty('question_existing_db_answer_add_new_layer', True)
QTest.mouseClick(ok_button, Qt.LeftButton)
dialog.setProperty('question_existing_db_answer_add_new_layer', None)
self.assertTrue(self.accepted)
QgsProject.instance().removeAllMapLayers()
ds = ogr.Open(dbname)
self.assertEqual(ds.GetLayerCount(), 2)
ds = None
# Retry, and ask to overwrite the DB
self.accepted = False
dialog.setProperty('question_existing_db_answer_overwrite', True)
QTest.mouseClick(ok_button, Qt.LeftButton)
dialog.setProperty('question_existing_db_answer_overwrite', None)
self.assertTrue(self.accepted)
QgsProject.instance().removeAllMapLayers()
ds = ogr.Open(dbname)
self.assertEqual(ds.GetLayerCount(), 1)
ds = None
# Try re-adding with same parameters. It should ask if we want to
# overwrite the layer, and we'll implicitly answer no, hence failure
# since it already exists with that name
self.accepted = False
dialog.setProperty('question_existing_db_answer_add_new_layer', True)
QTest.mouseClick(ok_button, Qt.LeftButton)
dialog.setProperty('question_existing_db_answer_add_new_layer', None)
self.assertFalse(self.accepted)
# Now answer yes, and change a few things
mLayerIdentifierEdit.setText('my_identifier')
mLayerDescriptionEdit.setText('my_description')
dialog.setProperty('question_existing_db_answer_add_new_layer', True)
dialog.setProperty('question_existing_layer_answer_overwrite', True)
self.accepted = False
QTest.mouseClick(ok_button, Qt.LeftButton)
dialog.setProperty('question_existing_db_answer_add_new_layer', None)
dialog.setProperty('question_existing_layer_answer_overwrite', None)
self.assertTrue(self.accepted)
# Only check with OGR 2.0 since the IDENTIFIER and DESCRIPTION creation options don't exist in OGR 1.11
if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0):
layers = QgsProject.instance().mapLayers()
self.assertEqual(len(layers), 1)
layer = layers[list(layers.keys())[0]]
self.assertEqual(layer.name(), 'my_identifier')
QgsProject.instance().removeAllMapLayers()
ds = ogr.Open(dbname)
sql_lyr = ds.ExecuteSQL('SELECT * FROM gpkg_contents')
self.assertEqual(sql_lyr.GetFeatureCount(), 1)
f = sql_lyr.GetNextFeature()
identifier = f.GetField('identifier')
description = f.GetField('description')
f = None
ds.ReleaseResultSet(sql_lyr)
ds = None
self.assertEqual(identifier, 'my_identifier')
self.assertEqual(description, 'my_description')
else:
QgsProject.instance().removeAllMapLayers()
# Try invalid path
mDatabase.setFilePath('/this/is/invalid/test.gpkg')
self.accepted = False
QTest.mouseClick(ok_button, Qt.LeftButton)
self.assertFalse(self.accepted)
def test_ogr_shape_sbn_2():
ds = ogr.Open('data/CoHI_GCS12.shp')
lyr = ds.GetLayer(0)
return search_all_features(lyr)
if mask is 'default':
maskband = srcband.GetMaskBand()
elif mask is 'none':
maskband = None
else:
mask_ds = gdal.Open(mask)
maskband = mask_ds.GetRasterBand(1)
# =============================================================================
# Try opening the destination file as an existing file.
# =============================================================================
try:
gdal.PushErrorHandler('CPLQuietErrorHandler')
dst_ds = ogr.Open(dst_filename, update=1)
gdal.PopErrorHandler()
except:
dst_ds = None
# =============================================================================
# Create output file.
# =============================================================================
if dst_ds is None:
drv = ogr.GetDriverByName(format)
if not quiet_flag:
print('Creating output %s of format %s.' % (dst_filename, format))
dst_ds = drv.CreateDataSource(dst_filename)
# =============================================================================
# Find or create destination layer.
def mergeDataSources2Vrt(self, dataSources, outFile, union=False, relative=False,
schema=False, feedback=None):
'''Function to do the work of merging datasources in a single vrt format
@param data_sources: Array of path strings
@param outfile: the output vrt file to generate
@param relative: Write relative flag. DOES NOT relativise paths. They have to be already relative
@param schema: Schema flag
@return: vrt in string format
'''
if feedback is None:
feedback = QgsProcessingFeedback()
vrt = '<OGRVRTDataSource>'
if union:
vrt += '<OGRVRTUnionLayer name="UnionedLayer">'
total = 100.0 / len(dataSources) if dataSources else 1
for current, layer in enumerate(dataSources):
if feedback.isCanceled():
break
feedback.setProgress(int(current * total))
inFile = layer.source()
srcDS = ogr.Open(inFile, 0)
if srcDS is None:
raise QgsProcessingException(
self.tr('Invalid datasource: {}'.format(inFile)))
if schema:
inFile = '@dummy@'
for layer in srcDS:
layerDef = layer.GetLayerDefn()
layerName = layerDef.GetName()
vrt += '<OGRVRTLayer name="{}">'.format(self.XmlEsc(layerName))
vrt += '<SrcDataSource relativeToVRT="{}" shared="{}">{}</SrcDataSource>'.format(1 if relative else 0, not schema, self.XmlEsc(inFile))
if schema:
vrt += '<SrcLayer>@dummy@</SrcLayer>'
else:
vrt += '<SrcLayer>{}</SrcLayer>'.format(self.XmlEsc(layerName))
vrt += '<GeometryType>{}</GeometryType>'.format(self.GeomType2Name(layerDef.GetGeomType()))
crs = layer.GetSpatialRef()
if crs is not None:
vrt += '<LayerSRS>{}</LayerSRS>'.format(self.XmlEsc(crs.ExportToWkt()))
# Process all the fields.
for fieldIdx in range(layerDef.GetFieldCount()):
fieldDef = layerDef.GetFieldDefn(fieldIdx)
vrt += '<Field name="{}" type="{}"'.format(self.XmlEsc(fieldDef.GetName()), self.fieldType2Name(fieldDef.GetType()))
if not schema:
vrt += ' src="{}"'.format(self.XmlEsc(fieldDef.GetName()))
if fieldDef.GetWidth() > 0:
vrt += ' width="{}"'.format(fieldDef.GetWidth())
if fieldDef.GetPrecision() > 0:
vrt += ' precision="{}"'.format(fieldDef.GetPrecision())
vrt += '/>'
vrt += '</OGRVRTLayer>'
srcDS.Destroy()
if union:
vrt += '</OGRVRTUnionLayer>'
vrt += '</OGRVRTDataSource>'
#TODO: pretty-print XML
if outFile is not None:
with codecs.open(outFile, 'w') as f:
f.write(vrt)
return vrt
def Copy_Shapefile(shapefile_name,new_shapefile_name):
"""
Sweet Jesus why is this so difficult?
"""
if exists(shapefile_name) is False:
raise Exception('[Errno 2] No such file or directory: \'' + shapefile_name + '\'')
# get the short name of the new shapefile
shapefileshortname = LSDPT.GetFilePrefix(new_shapefile_name)
print("The shortname is: "+shapefileshortname)
# read in the data
src = ogr.Open(shapefile_name)
daLayer = src.GetLayer(0)
# lets see what the layers are
print("Let me tell you what the names of the fields are!")
layerDefinition = daLayer.GetLayerDefn()
for i in range(layerDefinition.GetFieldCount()):
print(layerDefinition.GetFieldDefn(i).GetName())
geom_type = layerDefinition.GetGeomType()
# get rid of previous copies
if exists(new_shapefile_name):
os.remove(new_shapefile_name)
# get the driver and create a new data source
driver = ogr.GetDriverByName('ESRI Shapefile')
#src.Destroy()
# Now write to the the outfile
out_ds = driver.CreateDataSource(new_shapefile_name)
# create the output layer
#out_lyr = out_ds.CreateLayer("yo",srs = daLayer.GetSpatialRef(),geom_type=ogr.wkbPolygon)
out_lyr = out_ds.CreateLayer("yo",srs = daLayer.GetSpatialRef(),geom_type=geom_type)
# Add input Layer Fields to the output Layer if it is the one we want
for i in range(0, layerDefinition.GetFieldCount()):
fieldDefn = layerDefinition.GetFieldDefn(i)
#fieldName = fieldDefn.GetName()
out_lyr.CreateField(fieldDefn)
# Get the output Layer's Feature Definition
outLayerDefn = out_lyr.GetLayerDefn()
# Add features to the ouput Layer
for inFeature in daLayer:
# Create output Feature
outFeature = ogr.Feature(outLayerDefn)
# add in geometries
geom = inFeature.GetGeometryRef()
outFeature.SetGeometry(geom.Clone())
# Add new feature to output Layer
# Add field values from input Layer
for i in range(0, outLayerDefn.GetFieldCount()):
fieldDefn = outLayerDefn.GetFieldDefn(i)
#fieldName = fieldDefn.GetName()
outFeature.SetField(outLayerDefn.GetFieldDefn(i).GetNameRef(),
inFeature.GetField(i))
out_lyr.CreateFeature(outFeature)
def loop_zonal_stats(input_zone_polygon, input_value_raster, pointBuf,
rasteridtail, outDir):
## https://gis.stackexchange.com/questions/77993/issue-trying-to-create-zonal-statistics-using-gdal-and-python
"""
Input:
input_zone_polygon a zone shapefile
input_value_raster a raster in UTM
pointBuf a distance (m) to add to & substract from both X and Y to create an area
rasteridtail a string to help distinguish the output CSV files
Output:
a CSV with fields: FID, mn, std
FID corresponds to FID in input zone polygon
stored in dir as input_zone_polygon
name includes combo of input zone poly and raster (might wanna change this to suite your needs)
Return:
stat dictionary
"""
# Reproject input_zone_polygon to srs of raster
# Get SRS and UTM zone from raster
raster = gdal.Open(input_value_raster)
srs = osr.SpatialReference(wkt=raster.GetProjection())
zone = srs.GetAttrValue('projcs').split(
'zone ')[1][:-1] # removes the last char, which is 'N' or 'S'
print "\n\tUTM Zone for the reprojection: %s" % zone
if int(zone) < 10:
zone = "0" + str(zone)
# Set up tmp zone file that will be projected to srs of raster
name = input_value_raster.split('/')[-2]
rasterid = name + rasteridtail ## eg: 'WV01_20130604_1020010023E3DB00_1020010024C5D300dsm'
tmpShp = input_zone_polygon.split('.shp')[0] + '_' + platform.node(
) + '_' + strftime("%Y%m%d_%H%M%S") + "_tmp.shp"
driver = ogr.GetDriverByName("ESRI Shapefile")
# Wait for the input_zone_polygon in case it is being used by another file
wait_for_files([input_zone_polygon])
## if os.path.exists(rpShp):
## # Check if UTM zone matches that of raster
## shp = ogr.Open(rpShp)
## lyr = shp.GetLayer()
##
## # if no match, delete and reproject
## driver.DeleteDataSource(tmpShp)
## print '\tReprojected version of shapefile exists...deleting'
## ogr2ogr targetSRS output input
rExt, xOrigin, yOrigin, pixelWidth, pixelHeight = get_raster_extent(raster)
rExtStr = str(rExt[0]) + " " + str(rExt[1]) + " " + str(
rExt[2]) + " " + str(rExt[3])
print '\n\tReproject input poly to UTM zone matching raster AND clip to raster extent...'
cmdStr = "ogr2ogr -t_srs EPSG:326" + zone + " -clipdst " + rExtStr + " " + tmpShp + " " + input_zone_polygon
run_wait_os(cmdStr)
## tmpBox = input_zone_polygon.split('.shp')[0] + '_' + platform.node() + '_' + rasterid + "_tmp.shp"
## print '\Run gdaltindex to get shapefile bounding box of input raster'
## cmdStr = "gdaltindex -t_srs EPSG:326" + zone + " " + tmpBox + " " + input_value_raster
shp = ogr.Open(tmpShp)
lyr = shp.GetLayer()
featList = range(lyr.GetFeatureCount())
# Stats to return
statsnames = [rasterid + '_mean', rasterid + '_std']
statDict_mean = {}
statDict_std = {}
# Existing attributes to return
##fieldnames = ["campaign","rec_ndx","shotn","lat","lon","elev","elvdiff","Centroid","wflen"]
fieldnames = [
"rec_ndx", "shotn", "lat", "lon", "elev", "elev_ground", "wflen"
]
print "Fieldnames: %s" % fieldnames
"""
TODO iterate through fieldnames and append multiple fieldname values to a common dict key (FID),
instead of having a diff dict
"""
##fieldDict_camp = {}
fieldDict_rec = {}
fieldDict_shot = {}
fieldDict_lat = {}
fieldDict_lon = {}
fieldDict_elev = {}
fieldDict_elev_ground = {}
##fieldDict_elvd = {}
##fieldDict_cent = {}
fieldDict_wflen = {}
# Loop through features
for FID in featList:
feat = lyr.GetFeature(FID)
print '\tFID: %s' % (FID)
# Stats to return
meanValue, stdValue, zValList = zonal_stats(feat, tmpShp,
input_value_raster,
pointBuf)
statDict_mean[FID] = meanValue
statDict_std[FID] = stdValue
# Existing attributes to return
##fieldDict_camp[FID] = feat.GetField("campaign")
fieldDict_rec[FID] = feat.GetField("rec_ndx")
fieldDict_shot[FID] = feat.GetField("shotn")
fieldDict_lat[FID] = feat.GetField("lat")
fieldDict_lon[FID] = feat.GetField("lon")
fieldDict_elev[FID] = feat.GetField("elev")
fieldDict_elev_ground[FID] = feat.GetField(
"elev_groun") # <-- this fieldname is too long and gets truncated
##fieldDict_elvd[FID] = feat.GetField("elvdiff")
##fieldDict_cent[FID] = feat.GetField("Centroid")
fieldDict_wflen[FID] = feat.GetField("wflen")
# Output a csv list of the DSM values in the box around the GLAS centroid
## if rasteridtail == 'dsm':
## try:
## np.savetxt(os.path.join(outDir,name + '_dsm_vals_'+ str(feat.GetField("rec_ndx")) + "_" + str(feat.GetField("shotn"))), zValList, delimiter = ",", fmt='%.2f')
## except Exception, e:
## print '\t' + str(e)
# Header for output CSV
hdr = ['FID'] + fieldnames + statsnames
# Combine all attribute and stats dictionaries
##Comb_Dicts = fieldDict_camp, fieldDict_rec, fieldDict_shot, fieldDict_lat, fieldDict_lon, fieldDict_elev, fieldDict_elvd, fieldDict_cent, fieldDict_wflen, statDict_mean, statDict_std
Comb_Dicts = fieldDict_rec, fieldDict_shot, fieldDict_lat, fieldDict_lon, fieldDict_elev, fieldDict_elev_ground, fieldDict_wflen, statDict_mean, statDict_std
# delete the tmp reproj'd shp
driver.DeleteDataSource(tmpShp)
# Write stats to CSV
path, input_zone_file = os.path.split(input_zone_polygon)
outCSV = os.path.join(
outDir,
input_zone_file.split('.shp')[0] + '_' + rasterid + '.csv')
## # Combine the 2 dictionaries into one using the key (this case, the FID)
## ## formatting a combined dictionary to CSV is tricky..room for improvement
## StatDict_Combined = defaultdict(list)
##
## for d in (statDict_mean, statDict_std): # you can list as many input dicts as you want here
## for key, value in d.iteritems():
## StatDict_Combined[key].append(value)
##
## with open(outCSV, 'w') as f:
## hdr = 'FID,' + rasterid + '_elev_mn'##+',' + rasterid + '_elev_std'
## f.write(hdr + '\n')
## [f.write('{0},{1}\n'.format(key, value )) for key, value in StatDict_Combined.items()]
## ## Below doesnt work on lists, only tuples..
## ## https://stackoverflow.com/questions/5530619/python-how-to-write-a-dictionary-of-tuple-values-to-a-csv-file?rq=1
## ##csv.writer(f).writerows(hdr + '\n')
## ##csv.writer(f).writerows((k,) + v for k, v in StatDict_Combined.iteritems())
# Write multiple dicts to CSV
## https://stackoverflow.com/questions/22273970/writing-multiple-python-dictionaries-to-csv-file
with open(outCSV, 'w') as f:
writer = csv.writer(f, delimiter=',')
##writer.writerow(['FID', rasterid + '_elev_mn', rasterid + '_elev_std'])
writer.writerow(hdr)
# Here you just need any template dict from above through which you can iterate the keys
for key in statDict_mean.iterkeys():
writer.writerow([key] + [d[key] for d in Comb_Dicts])
return Comb_Dicts, outCSV, hdr
def Rasterize_BGS_geologic_maps(shapefile_name):
# The shapefile to be rasterized:
print('Rasterize ' + shapefile_name)
#get path and filename seperately
shapefilefilepath = LSDPT.GetPath(shapefile_name)
shapefilename = LSDPT.GetFileNameNoPath(shapefile_name)
shapefileshortname = LSDPT.GetFilePrefix(shapefile_name)
print("Shapefile name is: "+shapefilename)
# now get the the fields from the shapefile
daShapefile = shapefile_name
dataSource = ogr.Open(daShapefile)
daLayer = dataSource.GetLayer(0)
# lets see what the layers are
print("Let me tell you what the names of the fields are!")
layerDefinition = daLayer.GetLayerDefn()
for i in range(layerDefinition.GetFieldCount()):
print(layerDefinition.GetFieldDefn(i).GetName())
# The raster file to be created and receive the rasterized shapefile
outrastername = shapefileshortname + '.tif'
outraster = shapefilefilepath+os.sep+ outrastername
outcsv = shapefilefilepath+os.sep+shapefileshortname+'_lithokey.csv'
print("Full name of out raster is: "+outraster)
# Rasterize!!
system_call = 'gdal_rasterize -a BGSREF -l ' + shapefileshortname +' -tr 90 -90 -a_nodata -9999 ' + shapefile_name + ' ' + outraster
print("System call is: ")
print(system_call)
os.system(system_call)
# now convert the raster to UTM, as well as delete the stupid TIF
# The raster file to be created and receive the rasterized shapefile
outrastername_bil = shapefileshortname + '.bil'
outraster_bil = shapefilefilepath+os.sep+ outrastername_bil
print("Full name of out raster is: "+outraster_bil)
# This assumes UTM zone 30, because why would we do any work in East Anglia?
system_call2 = 'gdalwarp -t_srs EPSG:32630 -of ENVI -dstnodata -9999 ' + outraster + ' ' + outraster_bil
os.system(system_call2)
# Now get rid of the tif
system_call3 = 'rm '+ outraster
os.system(system_call3)
# Make a key for the bedrock
geol_dict = dict()
for feature in daLayer:
ID = feature.GetField("BGSREF")
GEOL = feature.GetField("RCS_D")
if ID not in geol_dict:
print("I found a new rock type, ID: "+ str(ID)+ " and rock type: " + str(GEOL))
geol_dict[ID] = GEOL
print("The rocks are: ")
print(geol_dict)
with open(outcsv, 'wb') as f:
f.write('ID,rocktype\n')
for key in geol_dict:
f.write(str(key)+','+ str(geol_dict[key])+'\n')
print("All done")
def ogr_mongodb_1():
if ogrtest.mongodb_drv is None:
return 'skip'
# The below options must be used the very first time mongoDB is initialized
# otherwise they will get ignored
open_options = []
open_options += ['SSL_PEM_KEY_FILE=bla']
open_options += ['SSL_PEM_KEY_PASSWORD=bla']
open_options += ['SSL_CA_FILE=bla']
open_options += ['SSL_CRL_FILE=bla']
open_options += ['SSL_ALLOW_INVALID_CERTIFICATES=YES']
open_options += ['SSL_ALLOW_INVALID_HOSTNAMES=YES']
open_options += ['FIPS_MODE=YES']
gdal.PushErrorHandler()
ds = gdal.OpenEx('mongodb:', open_options=open_options)
gdal.PopErrorHandler()
# Might work or not depending on how the db is set up
gdal.PushErrorHandler()
ds = ogr.Open("mongodb:")
gdal.PopErrorHandler()
# Wrong URI
gdal.PushErrorHandler()
ds = ogr.Open("mongodb://")
gdal.PopErrorHandler()
if ds is not None:
gdaltest.post_reason('fail')
return 'fail'
# URI to non existent host.
gdal.PushErrorHandler()
ds = ogr.Open("mongodb://non_existing")
gdal.PopErrorHandler()
if ds is not None:
gdaltest.post_reason('fail')
return 'fail'
# Connect to non existent host.
gdal.PushErrorHandler()
ds = gdal.OpenEx('mongodb:', open_options=['HOST=non_existing'])
gdal.PopErrorHandler()
if ds is not None:
gdaltest.post_reason('fail')
return 'fail'
# All arguments split up
open_options = []
open_options += ['HOST=' + ogrtest.mongodb_test_host]
open_options += ['PORT=' + str(ogrtest.mongodb_test_port)]
open_options += ['DBNAME=' + ogrtest.mongodb_test_dbname]
if ogrtest.mongodb_test_user is not None:
open_options += ['USER='******'PASSWORD='******'mongodb:', open_options=open_options)
if ds is None:
gdaltest.post_reason('fail')
return 'fail'
# Without DBNAME
open_options = []
open_options += ['HOST=' + ogrtest.mongodb_test_host]
open_options += ['PORT=' + str(ogrtest.mongodb_test_port)]
if ogrtest.mongodb_test_user is not None:
open_options += ['AUTH_DBNAME=' + ogrtest.mongodb_test_dbname]
open_options += ['USER='******'PASSWORD='******'mongodb:', open_options=open_options)
gdal.PopErrorHandler()
# A few error cases with authentication
if ogrtest.mongodb_test_user is not None:
open_options = []
open_options += ['HOST=' + ogrtest.mongodb_test_host]
open_options += ['PORT=' + str(ogrtest.mongodb_test_port)]
open_options += ['DBNAME=' + ogrtest.mongodb_test_dbname]
# Missing user and password
gdal.PushErrorHandler()
ds = gdal.OpenEx('mongodb:', open_options=open_options)
gdal.PopErrorHandler()
if ds is not None:
gdaltest.post_reason('fail')
return 'fail'
open_options = []
open_options += ['HOST=' + ogrtest.mongodb_test_host]
open_options += ['PORT=' + str(ogrtest.mongodb_test_port)]
open_options += ['DBNAME=' + ogrtest.mongodb_test_dbname]
open_options += ['USER='******'mongodb:', open_options=open_options)
gdal.PopErrorHandler()
if ds is not None:
gdaltest.post_reason('fail')
return 'fail'
open_options = []
open_options += ['HOST=' + ogrtest.mongodb_test_host]
open_options += ['PORT=' + str(ogrtest.mongodb_test_port)]
open_options += ['USER='******'PASSWORD='******'mongodb:', open_options=open_options)
gdal.PopErrorHandler()
if ds is not None:
gdaltest.post_reason('fail')
return 'fail'
open_options = []
open_options += ['HOST=' + ogrtest.mongodb_test_host]
open_options += ['PORT=' + str(ogrtest.mongodb_test_port)]
open_options += ['DBNAME=' + ogrtest.mongodb_test_dbname]
open_options += ['USER='******'PASSWORD='******'_wrong'
]
# Wrong password
gdal.PushErrorHandler()
ds = gdal.OpenEx('mongodb:', open_options=open_options)
gdal.PopErrorHandler()
if ds is not None:
gdaltest.post_reason('fail')
return 'fail'
# Test AUTH_JSON: invalid JSon
gdal.PushErrorHandler()
open_options = []
open_options += ['HOST=' + ogrtest.mongodb_test_host]
open_options += ['PORT=' + str(ogrtest.mongodb_test_port)]
open_options += ['DBNAME=' + ogrtest.mongodb_test_dbname]
open_options += ['AUTH_JSON={']
ds = gdal.OpenEx('mongodb:', open_options=open_options)
gdal.PopErrorHandler()
if ds is not None:
gdaltest.post_reason('fail')
return 'fail'
# Test AUTH_JSON: missing mechanism
gdal.PushErrorHandler()
open_options = []
open_options += ['HOST=' + ogrtest.mongodb_test_host]
open_options += ['PORT=' + str(ogrtest.mongodb_test_port)]
open_options += ['DBNAME=' + ogrtest.mongodb_test_dbname]
open_options += ['AUTH_JSON={}']
ds = gdal.OpenEx('mongodb:', open_options=open_options)
gdal.PopErrorHandler()
if ds is not None:
gdaltest.post_reason('fail')
return 'fail'
# Successful AUTH_JSON use
if ogrtest.mongodb_test_user is not None:
open_options = []
open_options += ['HOST=' + ogrtest.mongodb_test_host]
open_options += ['PORT=' + str(ogrtest.mongodb_test_port)]
open_options += ['DBNAME=' + ogrtest.mongodb_test_dbname]
open_options += ['AUTH_JSON={ "mechanism" : "SCRAM-SHA-1", "db": "%s", "user": "******", "pwd": "%s" }' % \
(ogrtest.mongodb_test_dbname, ogrtest.mongodb_test_user, ogrtest.mongodb_test_password)]
ds = gdal.OpenEx('mongodb:', open_options=open_options)
if ds is None:
gdaltest.post_reason('fail')
return 'fail'
return 'success'
def test_ogr_pdf_2(name='tmp/ogr_pdf_1.pdf', has_attributes=True):
if not has_read_support():
pytest.skip()
ds = ogr.Open(name)
assert ds is not None
lyr = ds.GetLayerByName('first_layer')
assert lyr is not None
if has_attributes:
assert lyr.GetLayerDefn().GetFieldDefn(
lyr.GetLayerDefn().GetFieldIndex(
'strfield')).GetType() == ogr.OFTString
assert lyr.GetLayerDefn().GetFieldDefn(
lyr.GetLayerDefn().GetFieldIndex(
'intfield')).GetType() == ogr.OFTInteger
assert lyr.GetLayerDefn().GetFieldDefn(
lyr.GetLayerDefn().GetFieldIndex(
'realfield')).GetType() == ogr.OFTReal
else:
assert lyr.GetLayerDefn().GetFieldCount() == 0
if has_attributes:
feat = lyr.GetNextFeature()
# This won't work properly until text support is added to the
# PDF vector feature reader
# if ogrtest.check_feature_geometry(feat, ogr.CreateGeometryFromWkt('POINT(2 49)')) != 0:
# feat.DumpReadable()
# gdaltest.post_reason('fail')
# return 'fail'
feat = lyr.GetNextFeature()
if ogrtest.check_feature_geometry(
feat, ogr.CreateGeometryFromWkt('LINESTRING(2 48,3 50)')) != 0:
feat.DumpReadable()
pytest.fail()
if has_attributes:
if feat.GetField('strfield') != 'str':
feat.DumpReadable()
pytest.fail()
if feat.GetField('intfield') != 1:
feat.DumpReadable()
pytest.fail()
if abs(feat.GetFieldAsDouble('realfield') - 2.34) > 1e-10:
feat.DumpReadable()
pytest.fail()
feat = lyr.GetNextFeature()
if ogrtest.check_feature_geometry(
feat,
ogr.CreateGeometryFromWkt(
'POLYGON((2 48,2 49,3 49,3 48,2 48))')) != 0:
feat.DumpReadable()
pytest.fail()
feat = lyr.GetNextFeature()
if ogrtest.check_feature_geometry(
feat,
ogr.CreateGeometryFromWkt(
'POLYGON((2 48,2 49,3 49,3 48,2 48),(2.25 48.25,2.25 48.75,2.75 48.75,2.75 48.25,2.25 48.25))'
)) != 0:
feat.DumpReadable()
pytest.fail()
for i in range(10):
feat = lyr.GetNextFeature()
if ogrtest.check_feature_geometry(
feat,
ogr.CreateGeometryFromWkt('POINT(%f 49.1)' %
(2 + i * 0.05))) != 0:
feat.DumpReadable()
pytest.fail('fail with ogr-sym-%d' % i)
feat = lyr.GetNextFeature()
if ogrtest.check_feature_geometry(
feat, ogr.CreateGeometryFromWkt('POINT(2.5 49.1)')) != 0:
feat.DumpReadable()
pytest.fail('fail with raster icon')
ds = None
def lcgc(bhcat='', cluster=''):
pa_list = np.genfromtxt(
'results/overall_optim_thresholds2.csv', dtype='int', skip_header=0
) #,usecols=(1))#np.genfromtxt('wdpaids_marine.csv',dtype='int')
#pa_list = pa_listt[,0]
#res_list = pa_listt[,1]#np.genfromtxt('results/overall_optim_thresholds2.csv',dtype='int',skip_header=0,usecols=(2))
n = len(pa_list)
#pa_list = pa_list2[0:n] #n-2
#print pa_list
#n2 = len(pa_list)
print n
field_name_target = 'hclst_m'
idd = roads = mval = None
csvname = 'results/gclc_aver_in.csv' # +str(bhcat)+
if os.path.isfile(csvname) == False:
wb = open(csvname, 'a')
wb.write('wdpaid cluster gclc aver')
wb.write('\n')
wb.close()
#f=open('','w')
#f.write('wdpaid, roads, tot, perc\n')
csvname1 = 'csv/gclc_' + str(bhcat) + '_in_done_100km2.csv'
if os.path.isfile(csvname1) == False:
wb = open(csvname1, 'a')
wb.write('None')
wb.write('\n')
wb.close()
gtif_file = '/home/majavie/DOPA/consensus_full_class_LC/consensus_full_class_' + str(
bhcat) + '_moll.tif' # 1.tif
gtif_dataset = gdal.Open(gtif_file, GA_ReadOnly)
transform = gtif_dataset.GetGeoTransform()
xOrigin = transform[0]
yOrigin = transform[3]
pixelWidth = transform[1]
pixelHeight = transform[5]
banddataraster = gtif_dataset.GetRasterBand(1)
#segmlist = range(1,9)
pa_list_done = np.genfromtxt(csvname1, dtype='int')
for px in range(0, n):
idd2 = pa_list[px, 0]
res = pa_list[px, 1]
#print idd2,res
if idd2 not in pa_list_done:
#clusterlistcsv = 'csv/park_'+idd2+'_'+res+'.csv'
#segmlist = np.genfromtxt(segmlistcsv,dtype='int')
#n2 = len(segmlist)
#for px in range(0,n2):
#idd = segmlist[px]
inShapefile = 'results/park_segm_' + str(idd2) + '_' + str(
res) + '_class.shp'
inDriver = ogr.GetDriverByName("ESRI Shapefile")
inDataSource = inDriver.Open(inShapefile, 0)
inLayer = inDataSource.GetLayer()
#inLayer.GetFieldAsString(field_name_target)
#for cluster in segmlist: # indent1
# Get the input Layer
print idd2, res, 'cluster:', cluster
opt = field_name_target + " = '" + str(cluster) + "'"
#print opt
inLayer.SetAttributeFilter(opt)
if inLayer.GetFeatureCount() > 0: # indent2
ola = 'pa_tmpfs_' + str(bhcat) + '_' + str(idd2) + '_' + str(
cluster) + '.shp'
# Create the output LayerS
outShapefile = os.path.join(os.path.split(inShapefile)[0], ola)
#print outShapefile
outDriver = ogr.GetDriverByName("ESRI Shapefile")
# Remove output shapefile if it already exists
if os.path.exists(outShapefile):
outDriver.DeleteDataSource(outShapefile)
# Create the output shapefile
outDataSource = outDriver.CreateDataSource(outShapefile)
out_lyr_name = os.path.splitext(
os.path.split(outShapefile)[1])[0]
outLayer = outDataSource.CreateLayer(
out_lyr_name, geom_type=ogr.wkbMultiPolygon)
# Add input Layer Fields to the output Layer if it is the one we want
inLayerDefn = inLayer.GetLayerDefn()
for i in range(0, inLayerDefn.GetFieldCount()):
fieldDefn = inLayerDefn.GetFieldDefn(i)
fieldName = fieldDefn.GetName()
if fieldName not in field_name_target:
continue
outLayer.CreateField(fieldDefn)
# Get the output Layer's Feature Definition
outLayerDefn = outLayer.GetLayerDefn()
# Add features to the ouput Layer
for inFeature in inLayer:
# Create output Feature
outFeature = ogr.Feature(outLayerDefn)
# Add field values from input Layer
for i in range(0, outLayerDefn.GetFieldCount()):
fieldDefn = outLayerDefn.GetFieldDefn(i)
fieldName = fieldDefn.GetName()
if fieldName not in field_name_target:
continue
outFeature.SetField(
outLayerDefn.GetFieldDefn(i).GetNameRef(),
inFeature.GetField(i))
# Set geometry as centroid
geom = inFeature.GetGeometryRef()
outFeature.SetGeometry(geom.Clone())
# Add new feature to output Layer
outLayer.CreateFeature(outFeature)
# Close DataSources
inDataSource.Destroy()
outDataSource.Destroy()
pixel_size = 1000
NoData_value = 255
# Filename of input OGR file
vector_fn = ola #'sierranevada2.shp'
# Filename of the raster Tiff that will be created
#raster_fn = 'sierranevada2.tif'
# Open the data source and read in the extent
source_ds = ogr.Open(outShapefile) #vector_fn)
source_layer = source_ds.GetLayer()
x_min, x_max, y_min, y_max = source_layer.GetExtent()
print str(x_min) + " " + str(x_max) + " " + str(
y_min) + " " + str(y_max)
tx = abs(x_min) - abs(x_max)
ty = abs(y_min) - abs(y_max)
ggo = 1
#if tx<100 or ty<100: ggo=0
#print 'tx:',tx
#print 'ty:',ty
#print 'ggo:',ggo
# if tx<1000: tx=1000
# if ty<1000: ty=1000
if ggo == 1:
# Create the destination data source
raster_fn = 'tmpf/pa_' + str(bhcat) + '_' + str(
idd2) + '_' + str(cluster) + '.tif'
x_res = int((x_max - x_min) / pixel_size)
y_res = int((y_max - y_min) / pixel_size)
print 'xres:', x_res
print 'yres:', y_res
# if x_res<1000: x_res=1000
# if y_res<1000: y_res=1000
target_ds = gdal.GetDriverByName('MEM').Create(
'', x_res, y_res, 1, gdal.GDT_Int32)
#target_ds2 = gdal.GetDriverByName('GTiff').Create(raster_fn, x_res, y_res, 1, gdal.GDT_Int32)
target_ds.SetGeoTransform(
(x_min, pixel_size, 0, y_max, 0, -pixel_size))
#target_ds2.SetGeoTransform((x_min, pixel_size, 0, y_max, 0, -pixel_size))
band = target_ds.GetRasterBand(1)
#band2 = target_ds.GetRasterBand(1)
band.SetNoDataValue(NoData_value)
#band2.SetNoDataValue(NoData_value)
# Rasterize
gdal.RasterizeLayer(target_ds, [1],
source_layer,
burn_values=[1]) # options = [""]
#gdal.RasterizeLayer(target_ds2, [1], source_layer, burn_values=[1])#)
array = band.ReadAsArray().astype(np.int32)
xoff = int((x_min - xOrigin) / pixelWidth)
yoff = int((yOrigin - y_max) / pixelWidth)
xcount = int((x_max - x_min) / pixelWidth) #+1
ycount = int((y_max - y_min) / pixelWidth) #+1
tcount = xcount + ycount
print 'tcount:', tcount
if xoff < 0:
xoff = 0
if yoff < 0:
yoff = 0
sumx = xoff + xcount
sumy = yoff + ycount
go = 1
if sumx > gtif_dataset.RasterXSize: go = 0
if sumy > gtif_dataset.RasterYSize: go = 0
if tcount == 0: go = 0
print 'go:', go
if go == 1:
dataraster = banddataraster.ReadAsArray(
xoff, yoff, xcount, ycount) #.astype(np.float)
print 'unique:', np.unique(array)
mask = np.where(array == 1, dataraster, (0))
#roads = np.sum(mask)
mval = np.mean(dataraster)
#tot = np.sum(array)
#perc = float(roads/tot)*100
print 'pa', 'cl', 'cat', 'mn'
var = str(idd2) + " " + str(cluster) + " " + str(
bhcat) + " " + str(mval)
print var
dele = 'rm tmpf/pa_' + str(
bhcat) + '*' # '_'+str(idd)+
#os.system(dele)
#f.write('{0}, {1}, {2}, {3}\n'.format(idd, roads, tot, perc))
wb = open(csvname, 'a')
wb.write(var)
wb.write('\n')
wb.close()
target_ds = dataraster = array = outShapefile = outFeature = outDataSource = vector_fn = outLayer = source_ds = opt = ola = source_layer = inDataSource = None
# = None
dele = 'rm results/*tmpfs*' # '_'+str(idd)+
os.system(dele)
wb = open(csvname1, 'a')
varx = str(idd)
wb.write(varx)
wb.write('\n')
wb.close()
def test_ogr_pdf_online_2():
if not has_read_support():
pytest.skip()
if not gdaltest.download_file(
'https://download.osgeo.org/gdal/data/pdf/340711752_Azusa_FSTopo.pdf',
'340711752_Azusa_FSTopo.pdf'):
pytest.skip()
expected_layers = [
['Other_5', 0],
['Quadrangle_Extent_Other_4', 0],
['Quadrangle_Extent_State_Outline', 0],
['Adjacent_Quadrangle_Diagram_Other_3', 0],
['Adjacent_Quadrangle_Diagram_Quadrangle_Extent', 0],
['Adjacent_Quadrangle_Diagram_Quad_Outlines', 0],
['Quadrangle_Other', 0],
['Quadrangle_Labels_Unplaced_Labels_Road_Shields_-_Vertical', 0],
['Quadrangle_Labels_Road_Shields_-_Horizontal', 0],
['Quadrangle_Labels_Road_Shields_-_Vertical', 0],
['Quadrangle_Neatline/Mask_Neatline', 0],
['Quadrangle_Neatline/Mask_Mask', 0],
['Quadrangle_Culture_Features', 0],
['Quadrangle_Large_Tanks', 0],
['Quadrangle_Linear_Transportation_Features', 0],
['Quadrangle_Railroads_', 0],
['Quadrangle_Linear_Culture_Features', 0],
['Quadrangle_Linear_Landform_Features', 0],
['Quadrangle_Boundaries', 0],
['Quadrangle_PLSS', 0],
['Quadrangle_Survey_Lines', 0],
['Quadrangle_Linear_Drainage_Features', 0],
['Quadrangle_Contour_Labels', 0],
['Quadrangle_Contours', 0],
['Quadrangle_2_5`_Tics_Interior_Grid_Intersections', 0],
['Quadrangle_2_5`_Tics_Grid_Tics_along_Neatline', 0],
['Quadrangle_UTM_Grid_Interior_Grid_Intersections', 0],
['Quadrangle_UTM_Grid_Grid_Tics_along_Neatline', 0],
['Quadrangle_UTM_Grid_UTM_Grid_Lines', 0],
['Quadrangle_Large_Buildings', 0],
['Quadrangle_Drainage_Polygons', 0],
['Quadrangle_Ownership', 0],
['Quadrangle_Builtup_Areas', 0],
['Quadrangle_WoodlandUSGS_P', 0],
]
ds = ogr.Open('tmp/cache/340711752_Azusa_FSTopo.pdf')
assert ds is not None
if ds.GetLayerCount() != len(expected_layers):
for lyr in ds:
print(lyr.GetName(), lyr.GetGeomType())
pytest.fail(ds.GetLayerCount())
for i in range(ds.GetLayerCount()):
assert ds.GetLayer(i).GetName() == expected_layers[i][0], \
('%d : %s' % (i, ds.GetLayer(i).GetName()))
assert ds.GetLayer(i).GetGeomType() == expected_layers[i][1], \
('%d : %d' % (i, ds.GetLayer(i).GetGeomType()))
def test_gdal_polygonize_1():
#from osgeo import gdal, gdalconst, ogr
try:
x = gdal.Polygonize
gdaltest.have_ng = 1
except:
gdaltest.have_ng = 0
return 'skip'
script_path = test_py_scripts.get_py_script('gdal_polygonize')
if script_path is None:
return 'skip'
# Create a OGR datasource to put results in.
shp_drv = ogr.GetDriverByName('ESRI Shapefile')
try:
os.stat('tmp/poly.shp')
shp_drv.DeleteDataSource('tmp/poly.shp')
except:
pass
shp_ds = shp_drv.CreateDataSource('tmp/poly.shp')
shp_layer = shp_ds.CreateLayer('poly', None, ogr.wkbPolygon)
fd = ogr.FieldDefn('DN', ogr.OFTInteger)
shp_layer.CreateField(fd)
shp_ds.Destroy()
# run the algorithm.
test_py_scripts.run_py_script(script_path, 'gdal_polygonize',
'../alg/data/polygonize_in.grd tmp poly DN')
# Confirm we get the set of expected features in the output layer.
shp_ds = ogr.Open('tmp')
shp_lyr = shp_ds.GetLayerByName('poly')
expected_feature_number = 13
if shp_lyr.GetFeatureCount() != expected_feature_number:
gdaltest.post_reason(
'GetFeatureCount() returned %d instead of %d' %
(mem_layer.GetFeatureCount(), expected_feature_number))
return 'fail'
expect = [107, 123, 115, 115, 140, 148, 123, 140, 156, 100, 101, 102, 103]
tr = ogrtest.check_features_against_list(shp_lyr, 'DN', expect)
# check at least one geometry.
if tr:
shp_lyr.SetAttributeFilter('dn = 156')
feat_read = shp_lyr.GetNextFeature()
if ogrtest.check_feature_geometry(
feat_read,
'POLYGON ((440720 3751200,440900 3751200,440900 3751020,440720 3751020,440720 3751200),(440780 3751140,440780 3751080,440840 3751080,440840 3751140,440780 3751140))'
) != 0:
tr = 0
feat_read.Destroy()
shp_ds.Destroy()
# Reload drv because of side effects of run_py_script()
shp_drv = ogr.GetDriverByName('ESRI Shapefile')
shp_drv.DeleteDataSource('tmp/poly.shp')
if tr:
return 'success'
else:
return 'fail'
default=False,
action="store_true",
help="close the largest open linestring with a circular arc")
parser.add_option(
"-t",
"--tolerance",
dest="tolerance",
type="float",
default=0.0,
metavar="DISTANCE",
help="Tolerance for joining two endpoints, in geographic units")
parser.add_option("-m",
"--multiple",
dest="single_feature",
default=True,
action="store_false",
metavar="SINGLE_FEATURE")
(options, args) = parser.parse_args()
input_shp, output_shp = args
ods = ogr.Open(input_shp)
layer = ods.GetLayer(0)
process_layer(layer,
output_shp,
create_polygons=options.create_polygons,
close_arc=options.close_arc,
tolerance=options.tolerance,
single_feature=options.single_feature)
#!/usr/bin/env python
from osgeo import gdal, ogr
if __name__ == '__main__':
in_file = '../images/portland_chip.tif'
out_file = '../images/portland_roads.tif'
road_file = '../images/roads.shp'
try:
# Open the input dataset.
ds_in = gdal.Open(in_file)
# Open the vector dataset.
ds_vector = ogr.Open(road_file)
lyr = ds_vector.GetLayer()
# Create a dataset to write to.
ds_out = gdal.GetDriverByName("GTiff").Create(out_file,
ds_in.RasterXSize,
ds_in.RasterYSize, 3,
gdal.GDT_Byte)
ds_out.SetProjection(ds_in.GetProjection())
ds_out.SetGeoTransform(ds_in.GetGeoTransform())
# Rasterize.
gdal.RasterizeLayer(ds_out, [1, 2, 3],
lyr,
burn_values=[255, 0, 0],
options=['ALL_TOUCHED=TRUE'])
finally:
def process_layer(orig_layer,
output_name,
tolerance=0.0,
create_polygons=False,
close_arc=False,
single_feature=True,
remove_duplicates=True):
"""
remove_duplicates: if true, exactly duplicated nodes along a single path will be removed, i.e.
the linestring A-B-B-C will become A-B-C.
single_feature: only save the biggest feature
"""
if isinstance(orig_layer, str):
ods = ogr.Open(orig_layer)
orig_layer = ods.GetLayer(0)
### The actual geometry processing: ###
### <processing>
new_features = merge_lines(orig_layer)
if remove_duplicates:
log.info("Checking the merged features for duplicate points")
# possibly important here to have the duplicate test more stringent than
# the tolerant_merge_lines.
# also have to be careful about a string of points closely spaced - don't
# want to remove all of them, just enough to keep the minimal spacing above
# tolerance.
short_tol = 0.5 * tolerance
for fi in range(len(new_features)):
pnts = new_features[fi]
valid = ones(len(pnts), 'bool8')
# go with a slower but safer loop here -
last_valid = 0
for i in range(1, len(pnts)):
if vector_mag(pnts[last_valid] - pnts[i]) < short_tol:
if i == len(pnts) - 1:
# special case to avoid moving the last vertex
valid[last_valid] = False
last_valid = i
else:
valid[i] = False
else:
last_valid = i
# print "Ring %d: # invalid=%d / %d"%(i,sum(~valid),len(new_features[i]))
new_features[fi] = new_features[fi][valid, :]
if tolerance > 0.0:
new_features = tolerant_merge_lines(new_features, tolerance)
### </processing>
### <output>
if create_polygons:
geoms = lines_to_polygons(new_features,
close_arc=close_arc,
single_feature=single_feature)
else:
# Line output
geoms = [shapely.geometry.LineString(pnts) for pnts in new_features]
# Write it all out to a shapefile:
progress_message("Writing output")
wkb2shp.wkb2shp(output_name, geoms, overwrite=True)
return output_name
def ogr_dispatch(argv, progress=None, progress_arg=None):
# pylint: disable=unused-argument
src_filename = None
dst_filename = None
driver_name = "ESRI Shapefile"
options = Options()
lco = []
dsco = []
pszWHERE = None
if not argv:
return Usage()
i = 0
while i < len(argv):
arg = argv[i]
if EQUAL(arg, '-src') and i + 1 < len(argv):
i = i + 1
src_filename = argv[i]
elif EQUAL(arg, '-dst') and i + 1 < len(argv):
i = i + 1
dst_filename = argv[i]
elif EQUAL(arg, '-f') and i + 1 < len(argv):
i = i + 1
driver_name = argv[i]
elif EQUAL(arg, '-a_srs') and i + 1 < len(argv):
i = i + 1
pszOutputSRSDef = argv[i]
if EQUAL(pszOutputSRSDef, "NULL") or \
EQUAL(pszOutputSRSDef, "NONE"):
options.bNullifyOutputSRS = True
else:
options.poOutputSRS = osr.SpatialReference()
if options.poOutputSRS.SetFromUserInput(pszOutputSRSDef) != 0:
print("Failed to process SRS definition: %s" % pszOutputSRSDef)
return 1
elif EQUAL(arg, '-dsco') and i + 1 < len(argv):
i = i + 1
dsco.append(argv[i])
elif EQUAL(arg, '-lco') and i + 1 < len(argv):
i = i + 1
lco.append(argv[i])
elif EQUAL(arg, '-field') and i + 1 < len(argv):
i = i + 1
options.dispatch_fields.append(argv[i])
elif EQUAL(arg, '-25D_as_2D'):
options.b25DAs2D = True
elif EQUAL(arg, '-multi_as_single'):
options.bMultiAsSingle = True
elif EQUAL(arg, '-remove_dispatch_fields'):
options.bRemoveDispatchFields = True
elif EQUAL(arg, '-prefix_with_layer_name'):
options.bPrefixWithLayerName = True
elif EQUAL(arg, '-style_as_field'):
options.bStyleAsField = True
elif (EQUAL(arg, "-tg") or
EQUAL(arg, "-gt")) and i + 1 < len(argv):
i = i + 1
options.nGroupTransactions = int(argv[i])
elif EQUAL(arg, "-where") and i + 1 < len(argv):
i = i + 1
pszWHERE = argv[i]
elif EQUAL(arg, '-quiet'):
options.bQuiet = True
else:
print('Unrecognized argument : %s' % arg)
return Usage()
i = i + 1
if src_filename is None:
print('Missing -src')
return 1
if dst_filename is None:
print('Missing -dst')
return 1
if not options.dispatch_fields:
print('Missing -dispatch_field')
return 1
src_ds = ogr.Open(src_filename)
if src_ds is None:
print('Cannot open source datasource %s' % src_filename)
return 1
dst_ds = ogr.Open(dst_filename, update=1)
if dst_ds is not None:
if dsco:
print('-dsco should not be specified for an existing datasource')
return 1
else:
dst_ds = ogr.GetDriverByName(driver_name).CreateDataSource(dst_filename, options=dsco)
if dst_ds is None:
print('Cannot open or create target datasource %s' % dst_filename)
return 1
layerMap = {}
for src_lyr in src_ds:
if pszWHERE is not None:
src_lyr.SetAttributeFilter(pszWHERE)
ret = convert_layer(src_lyr, dst_ds, layerMap, options)
if ret != 0:
return ret
return 0
elif argv[iArg] == "-t_srs" and iArg < nArgc - 1:
iArg = iArg + 1
srsname = argv[iArg]
elif argv[iArg][0] == '-':
Usage()
elif ogr_ds_name is None:
ogr_ds_name = argv[iArg]
iArg = iArg + 1
if ogr_ds_name is None or tilesrs is None:
Usage()
ogr_ds = ogr.Open(ogr_ds_name)
if ogr_ds is None:
raise Exception('cannot open %s' % ogr_ds_name)
if ogr_ds.GetLayerCount() == 1:
lyr = ogr_ds.GetLayer(0)
elif lyr_name is None:
raise Exception('-lyr_name should be specified')
else:
lyr = ogr_ds.GetLayerByName(lyr_name)
if lyr.GetLayerDefn().GetFieldIndex(tileitem) < 0:
raise Exception('%s field cannot be found in layer definition' % tileitem)
if lyr.GetLayerDefn().GetFieldIndex(tilesrs) < 0:
raise Exception('%s field cannot be found in layer definition' % tilesrs)
def test_ogr_osm_10():
if ogrtest.osm_drv is None:
pytest.skip()
# A file that does not exist.
ds = ogr.Open('/nonexistent/foo.osm')
assert ds is None
# Empty .osm file
f = gdal.VSIFOpenL('/vsimem/foo.osm', 'wb')
gdal.VSIFCloseL(f)
ds = ogr.Open('/vsimem/foo.osm')
assert ds is None
gdal.Unlink('/vsimem/foo.osm')
# Empty .pbf file
f = gdal.VSIFOpenL('/vsimem/foo.pbf', 'wb')
gdal.VSIFCloseL(f)
ds = ogr.Open('/vsimem/foo.pbf')
assert ds is None
gdal.Unlink('/vsimem/foo.pbf')
if ogrtest.osm_drv_parse_osm:
# Invalid .osm file
f = gdal.VSIFOpenL('/vsimem/foo.osm', 'wb')
data = "<osm>"
gdal.VSIFWriteL(data, 1, len(data), f)
gdal.VSIFCloseL(f)
ds = ogr.Open('/vsimem/foo.osm')
lyr = ds.GetLayer(0)
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
feat = lyr.GetNextFeature()
gdal.PopErrorHandler()
assert gdal.GetLastErrorMsg() != ''
ds = None
gdal.Unlink('/vsimem/foo.osm')
# Invalid .pbf file
f = gdal.VSIFOpenL('/vsimem/foo.pbf', 'wb')
data = "OSMHeader\n"
gdal.VSIFWriteL(data, 1, len(data), f)
gdal.VSIFCloseL(f)
ds = ogr.Open('/vsimem/foo.pbf')
lyr = ds.GetLayer(0)
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
feat = lyr.GetNextFeature()
gdal.PopErrorHandler()
assert gdal.GetLastErrorMsg() != ''
ds = None
gdal.Unlink('/vsimem/foo.pbf')
# Test million laugh pattern
if ogrtest.osm_drv_parse_osm:
ds = ogr.Open('data/osm/billionlaugh.osm')
lyr = ds.GetLayer(0)
gdal.ErrorReset()
gdal.PushErrorHandler('CPLQuietErrorHandler')
feat = lyr.GetNextFeature()
gdal.PopErrorHandler()
assert feat is None and gdal.GetLastErrorMsg() != ''
import os
import time
import shapely.geometry
import shapely.ops
from osgeo import ogr
format = '%.8f %.8f'
tolerance = 0.01
infile = '/Users/kirilllebedev/Maps/50m-admin-0-countries/ne_50m_admin_0_countries.shp'
outfile = 'map.shp'
# Open the datasource to operate on.
in_ds = ogr.Open(infile, update=0)
in_layer = in_ds.GetLayer(0)
in_defn = in_layer.GetLayerDefn()
# Create output file with similar information.
shp_driver = ogr.GetDriverByName('ESRI Shapefile')
if os.path.exists('map.shp'):
shp_driver.DeleteDataSource(outfile)
shp_ds = shp_driver.CreateDataSource(outfile)
shp_layer = shp_ds.CreateLayer(in_defn.GetName(),
geom_type=in_defn.GetGeomType(),
srs=in_layer.GetSpatialRef())
in_field_count = in_defn.GetFieldCount()
for fld_index in range(in_field_count):
src_fd = in_defn.GetFieldDefn(fld_index)
fd = ogr.FieldDefn(src_fd.GetName(), src_fd.GetType())
fd.SetWidth(src_fd.GetWidth())
