def internal_multipart_to_singlepart(
vector: Union[str, ogr.DataSource],
out_path: Optional[str] = None,
copy_attributes: bool = False,
overwrite: bool = True,
add_index: bool = True,
process_layer: int = -1,
verbose: int = 1,
) -> str:
type_check(vector, [str, ogr.DataSource], "vector")
type_check(out_path, [str], "out_path", allow_none=True)
type_check(overwrite, [bool], "overwrite")
type_check(add_index, [bool], "add_index")
type_check(process_layer, [int], "process_layer")
type_check(verbose, [int], "verbose")
vector_list, path_list = ready_io_vector(vector, out_path, overwrite=overwrite)
ref = open_vector(vector_list[0])
out_name = path_list[0]
driver = ogr.GetDriverByName(path_to_driver_vector(out_name))
metadata = internal_vector_to_metadata(ref)
remove_if_overwrite(out_name, overwrite)
destination = driver.CreateDataSource(out_name)
for index, layer_meta in enumerate(metadata["layers"]):
if process_layer != -1 and index != process_layer:
continue
if verbose == 1:
layer_name = layer_meta["layer_name"]
print(f"Splitting layer: {layer_name}")
target_unknown = False
if layer_meta["geom_type_ogr"] == 4: # MultiPoint
target_type = 1 # Point
elif layer_meta["geom_type_ogr"] == 5: # MultiLineString
target_type = 2 # LineString
elif layer_meta["geom_type_ogr"] == 6: # MultiPolygon
target_type = 3 # Polygon
elif layer_meta["geom_type_ogr"] == 1004: # MultiPoint (z)
target_type = 1001 # Point (z)
elif layer_meta["geom_type_ogr"] == 1005: # MultiLineString (z)
target_type = 1002 # LineString (z)
elif layer_meta["geom_type_ogr"] == 1006: # MultiPolygon (z)
target_type = 1003 # Polygon (z)
elif layer_meta["geom_type_ogr"] == 2004: # MultiPoint (m)
target_type = 2001 # Point (m)
elif layer_meta["geom_type_ogr"] == 2005: # MultiLineString (m)
target_type = 2002 # LineString (m)
elif layer_meta["geom_type_ogr"] == 2006: # MultiPolygon (m)
target_type = 2003 # Polygon (m)
elif layer_meta["geom_type_ogr"] == 3004: # MultiPoint (zm)
target_type = 3001 # Point (m)
elif layer_meta["geom_type_ogr"] == 3005: # MultiLineString (zm)
target_type = 3002 # LineString (m)
elif layer_meta["geom_type_ogr"] == 3006: # MultiPolygon (zm)
target_type = 3003 # Polygon (m)
else:
target_unknown = True
target_type = layer_meta["geom_type_ogr"]
destination_layer = destination.CreateLayer(
layer_meta["layer_name"], layer_meta["projection_osr"], target_type
)
layer_defn = destination_layer.GetLayerDefn()
field_count = layer_meta["field_count"]
original_target = ref.GetLayerByIndex(index)
feature_count = original_target.GetFeatureCount()
if copy_attributes:
first_feature = original_target.GetNextFeature()
original_target.ResetReading()
if verbose == 1:
print("Creating attribute fields")
for field_id in range(field_count):
field_defn = first_feature.GetFieldDefnRef(field_id)
fname = field_defn.GetName()
ftype = field_defn.GetTypeName()
fwidth = field_defn.GetWidth()
fprecision = field_defn.GetPrecision()
if ftype == "String" or ftype == "Date":
fielddefn = ogr.FieldDefn(fname, ogr.OFTString)
fielddefn.SetWidth(fwidth)
elif ftype == "Real":
fielddefn = ogr.FieldDefn(fname, ogr.OFTReal)
fielddefn.SetWidth(fwidth)
fielddefn.SetPrecision(fprecision)
else:
fielddefn = ogr.FieldDefn(fname, ogr.OFTInteger)
destination_layer.CreateField(fielddefn)
for _ in range(feature_count):
feature = original_target.GetNextFeature()
geom = feature.GetGeometryRef()
if target_unknown:
out_feat = ogr.Feature(layer_defn)
out_feat.SetGeometry(geom)
if copy_attributes:
for field_id in range(field_count):
values = feature.GetField(field_id)
out_feat.SetField(field_id, values)
destination_layer.CreateFeature(out_feat)
for geom_part in geom:
out_feat = ogr.Feature(layer_defn)
out_feat.SetGeometry(geom_part)
if copy_attributes:
for field_id in range(field_count):
values = feature.GetField(field_id)
out_feat.SetField(field_id, values)
destination_layer.CreateFeature(out_feat)
if verbose == 1:
progress(_, feature_count - 1, "Splitting.")
if add_index:
vector_add_index(destination)
return out_name
def ogr_index_10():
ds = ogr.GetDriverByName('ESRI Shapefile').CreateDataSource(
'tmp/ogr_index_10.shp')
lyr = ds.CreateLayer('ogr_index_10')
lyr.CreateField(ogr.FieldDefn('intfield', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('realfield', ogr.OFTReal))
lyr.CreateField(ogr.FieldDefn('strfield', ogr.OFTString))
feat = ogr.Feature(lyr.GetLayerDefn())
feat.SetField(0, 1)
feat.SetField(1, 1)
feat.SetField(2, "foo")
lyr.CreateFeature(feat)
feat = None
ds.ExecuteSQL('create index on ogr_index_10 using intfield')
ds.ExecuteSQL('create index on ogr_index_10 using realfield')
lyr.SetAttributeFilter('intfield IN (1)')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter('intfield = 1')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter('intfield IN (2)')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is not None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter('intfield IN (1.0)')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter('intfield = 1.0')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter('intfield IN (1.1)')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is not None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter("intfield IN ('1')")
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter('realfield IN (1.0)')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter('realfield = 1.0')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter('realfield IN (1.1)')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is not None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter('realfield IN (1)')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter('realfield = 1')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter('realfield IN (2)')
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is not None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter("realfield IN ('1')")
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter("strfield IN ('foo')")
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter("strfield = 'foo'")
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is None:
gdaltest.post_reason('failed')
return 'fail'
lyr.SetAttributeFilter("strfield IN ('bar')")
lyr.ResetReading()
feat = lyr.GetNextFeature()
if feat is not None:
gdaltest.post_reason('failed')
return 'fail'
ds = None
return 'success'
def testFidSupport(self):
# We do not use @unittest.expectedFailure since the test might actually succeed
# on Linux 64bit with GDAL 1.11, where "long" is 64 bit...
# GDAL 2.0 is guaranteed to properly support it on all platforms
version_num = int(gdal.VersionInfo('VERSION_NUM'))
if version_num < GDAL_COMPUTE_VERSION(2, 0, 0):
return
tmpfile = os.path.join(self.basetestpath, 'testFidSupport.sqlite')
ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test',
geom_type=ogr.wkbPoint,
options=['FID=fid'])
lyr.CreateField(ogr.FieldDefn('strfield', ogr.OFTString))
lyr.CreateField(ogr.FieldDefn('intfield', ogr.OFTInteger))
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(12)
f.SetField(0, 'foo')
f.SetField(1, 123)
lyr.CreateFeature(f)
f = None
ds = None
vl = QgsVectorLayer('{}'.format(tmpfile), 'test', 'ogr')
self.assertEqual(len(vl.fields()), 3)
got = [(f.attribute('fid'), f.attribute('strfield'),
f.attribute('intfield')) for f in vl.getFeatures()]
self.assertEqual(got, [(12, 'foo', 123)])
got = [(f.attribute('fid'), f.attribute('strfield'))
for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression(
"strfield = 'foo'"))]
self.assertEqual(got, [(12, 'foo')])
got = [(f.attribute('fid'), f.attribute('strfield'))
for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression(
"fid = 12"))]
self.assertEqual(got, [(12, 'foo')])
result = [
f['strfield']
for f in vl.dataProvider().getFeatures(QgsFeatureRequest(
).setSubsetOfAttributes(['strfield'],
vl.dataProvider().fields()))
]
self.assertEqual(result, ['foo'])
result = [
f['fid'] for f in vl.dataProvider().getFeatures(QgsFeatureRequest(
).setSubsetOfAttributes(['fid'],
vl.dataProvider().fields()))
]
self.assertEqual(result, [12])
# Test that when the 'fid' field is not set, regular insertion is done
f = QgsFeature()
f.setFields(vl.fields())
f.setAttributes([None, 'automatic_id'])
(res, out_f) = vl.dataProvider().addFeatures([f])
self.assertEqual(out_f[0].id(), 13)
self.assertEqual(out_f[0].attribute('fid'), 13)
self.assertEqual(out_f[0].attribute('strfield'), 'automatic_id')
# Test that when the 'fid' field is set, it is really used to set the id
f = QgsFeature()
f.setFields(vl.fields())
f.setAttributes([9876543210, 'bar'])
(res, out_f) = vl.dataProvider().addFeatures([f])
self.assertEqual(out_f[0].id(), 9876543210)
self.assertEqual(out_f[0].attribute('fid'), 9876543210)
self.assertEqual(out_f[0].attribute('strfield'), 'bar')
got = [(f.attribute('fid'), f.attribute('strfield'))
for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression(
"fid = 9876543210"))]
self.assertEqual(got, [(9876543210, 'bar')])
self.assertTrue(vl.dataProvider().changeAttributeValues(
{9876543210: {
1: 'baz'
}}))
got = [(f.attribute('fid'), f.attribute('strfield'))
for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression(
"fid = 9876543210"))]
self.assertEqual(got, [(9876543210, 'baz')])
self.assertTrue(vl.dataProvider().changeAttributeValues(
{9876543210: {
0: 9876543210,
1: 'baw'
}}))
got = [(f.attribute('fid'), f.attribute('strfield'))
for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression(
"fid = 9876543210"))]
self.assertEqual(got, [(9876543210, 'baw')])
# Not allowed: changing the fid regular field
self.assertTrue(vl.dataProvider().changeAttributeValues(
{9876543210: {
0: 12,
1: 'baw'
}}))
got = [(f.attribute('fid'), f.attribute('strfield'))
for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression(
"fid = 9876543210"))]
self.assertEqual(got, [(9876543210, 'baw')])
# Cannot delete fid
self.assertFalse(vl.dataProvider().deleteAttributes([0]))
# Delete first "genuine" attribute
self.assertTrue(vl.dataProvider().deleteAttributes([1]))
got = [(f.attribute('fid'), f.attribute('intfield'))
for f in vl.dataProvider().getFeatures(
QgsFeatureRequest().setFilterExpression("fid = 12"))]
self.assertEqual(got, [(12, 123)])
def export_feature_class(filegdb, featureclass, output_dir, output_epsg,
retained_fields, attribute_filter, spatial_filter):
log = Logger('Export FC')
log.info('Exporting geodatabase feature class {}'.format(featureclass))
# Get the input layer
in_driver = ogr.GetDriverByName("OpenFileGDB")
in_datasource = in_driver.Open(filegdb, 0)
in_layer = in_datasource.GetLayer(featureclass)
inSpatialRef = in_layer.GetSpatialRef()
if attribute_filter:
log.info('Export attribute filter: {}'.format(attribute_filter))
in_layer.SetAttributeFilter(attribute_filter)
if spatial_filter:
log.info('Export spatial filter area: {}'.format(spatial_filter.area))
in_layer.SetSpatialFilter(
ogr.CreateGeometryFromJson(json.dumps(mapping(spatial_filter))))
safe_makedirs(output_dir)
# Create the output layer
out_shapefile = os.path.join(output_dir, featureclass + '.shp')
out_driver = ogr.GetDriverByName("ESRI Shapefile")
outSpatialRef, transform = get_transform_from_epsg(inSpatialRef,
output_epsg)
# Remove output shapefile if it already exists
if os.path.exists(out_shapefile):
out_driver.DeleteDataSource(out_shapefile)
# Create the output shapefile
out_datasource = out_driver.CreateDataSource(out_shapefile)
out_layer = out_datasource.CreateLayer(featureclass,
outSpatialRef,
geom_type=in_layer.GetGeomType())
# Add input Layer Fields to the output Layer if it is the one we want
in_layer_def = in_layer.GetLayerDefn()
for i in range(0, in_layer_def.GetFieldCount()):
field_def = in_layer_def.GetFieldDefn(i)
field_name = field_def.GetName()
if retained_fields and field_name not in retained_fields:
continue
fieldTypeCode = field_def.GetType()
if field_name.lower() == 'nhdplusid' and fieldTypeCode == ogr.OFTReal:
field_def.SetWidth(32)
field_def.SetPrecision(0)
out_layer.CreateField(field_def)
# Get the output Layer's Feature Definition
out_layer_def = out_layer.GetLayerDefn()
# Add features to the ouput Layer
progbar = ProgressBar(in_layer.GetFeatureCount(), 50,
"Adding features to output layer")
counter = 0
for in_feature in in_layer:
counter += 1
progbar.update(counter)
# Create output Feature
out_feature = ogr.Feature(out_layer_def)
geom = in_feature.GetGeometryRef()
geom.Transform(transform)
# Add field values from input Layer
for i in range(0, out_layer_def.GetFieldCount()):
field_def = out_layer_def.GetFieldDefn(i)
field_name = field_def.GetName()
if retained_fields and field_name not in retained_fields:
continue
out_feature.SetField(
out_layer_def.GetFieldDefn(i).GetNameRef(),
in_feature.GetField(i))
# Set geometry as centroid
out_feature.SetGeometry(geom)
# Add new feature to output Layer
out_layer.CreateFeature(out_feature)
out_feature = None
progbar.finish()
# Save and close DataSources
in_datasource = None
out_datasource = None
return out_shapefile
def test_check_geometries(self):
"""DelineateIt: Check that we can reasonably repair geometries."""
from natcap.invest.delineateit import delineateit
srs = osr.SpatialReference()
srs.ImportFromEPSG(32731) # WGS84/UTM zone 31s
projection_wkt = srs.ExportToWkt()
dem_matrix = numpy.array(
[[0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1], [0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0]],
dtype=numpy.int8)
dem_raster_path = os.path.join(self.workspace_dir, 'dem.tif')
# byte datatype
pygeoprocessing.numpy_array_to_raster(dem_matrix, 255, (2, -2),
(2, -2), projection_wkt,
dem_raster_path)
# empty geometry
invalid_geometry = ogr.CreateGeometryFromWkt('POLYGON EMPTY')
self.assertTrue(invalid_geometry.IsEmpty())
# point outside of the DEM bbox
invalid_point = ogr.CreateGeometryFromWkt('POINT (-100 -100)')
# line intersects the DEM but is not contained by it
valid_line = ogr.CreateGeometryFromWkt(
'LINESTRING (-100 100, 100 -100)')
# invalid polygon coult fixed by buffering by 0
invalid_bowtie_polygon = ogr.CreateGeometryFromWkt(
'POLYGON ((2 -2, 6 -2, 2 -6, 6 -6, 2 -2))')
self.assertFalse(invalid_bowtie_polygon.IsValid())
# Bowtie polygon with vertex in the middle, could be fixed
# by buffering by 0
invalid_alt_bowtie_polygon = ogr.CreateGeometryFromWkt(
'POLYGON ((2 -2, 6 -2, 4 -4, 6 -6, 2 -6, 4 -4, 2 -2))')
self.assertFalse(invalid_alt_bowtie_polygon.IsValid())
# invalid polygon could be fixed by closing rings
invalid_open_ring_polygon = ogr.CreateGeometryFromWkt(
'POLYGON ((2 -2, 6 -2, 6 -6, 2 -6))')
self.assertFalse(invalid_open_ring_polygon.IsValid())
gpkg_driver = gdal.GetDriverByName('GPKG')
outflow_vector_path = os.path.join(self.workspace_dir, 'vector.gpkg')
outflow_vector = gpkg_driver.Create(outflow_vector_path, 0, 0, 0,
gdal.GDT_Unknown)
outflow_layer = outflow_vector.CreateLayer('outflow_layer', srs,
ogr.wkbUnknown)
outflow_layer.CreateField(ogr.FieldDefn('geom_id', ogr.OFTInteger))
outflow_layer.StartTransaction()
for index, geometry in enumerate(
(invalid_geometry, invalid_point, valid_line,
invalid_bowtie_polygon, invalid_alt_bowtie_polygon,
invalid_open_ring_polygon)):
if geometry is None:
self.fail('Geometry could not be created')
outflow_feature = ogr.Feature(outflow_layer.GetLayerDefn())
outflow_feature.SetField('geom_id', index)
outflow_feature.SetGeometry(geometry)
outflow_layer.CreateFeature(outflow_feature)
outflow_layer.CommitTransaction()
self.assertEqual(outflow_layer.GetFeatureCount(), 6)
outflow_layer = None
outflow_vector = None
target_vector_path = os.path.join(self.workspace_dir,
'checked_geometries.gpkg')
with self.assertRaises(ValueError) as cm:
delineateit.check_geometries(outflow_vector_path,
dem_raster_path,
target_vector_path,
skip_invalid_geometry=False)
self.assertTrue('is invalid' in str(cm.exception))
delineateit.check_geometries(outflow_vector_path,
dem_raster_path,
target_vector_path,
skip_invalid_geometry=True)
# I only expect to see 1 feature in the output layer, as there's only 1
# valid geometry.
expected_geom_areas = {
2: 0,
}
target_vector = gdal.OpenEx(target_vector_path, gdal.OF_VECTOR)
target_layer = target_vector.GetLayer()
self.assertEqual(target_layer.GetFeatureCount(),
len(expected_geom_areas))
for feature in target_layer:
geom = feature.GetGeometryRef()
self.assertAlmostEqual(
geom.Area(), expected_geom_areas[feature.GetField('geom_id')])
target_layer = None
target_vector = None
def processAlgorithm(self, parameters, context, feedback):
raster_layer = self.parameterAsRasterLayer(parameters, self.INPUT_DEM, context)
target_crs = raster_layer.crs()
rasterPath = raster_layer.source()
source = self.parameterAsSource(parameters, self.BOUNDARY_LAYER, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.BOUNDARY_LAYER))
step = self.parameterAsDouble(parameters, self.STEP, context)
percentage = self.parameterAsBool(parameters, self.USE_PERCENTAGE, context)
outputPath = self.parameterAsString(parameters, self.OUTPUT_DIRECTORY, context)
rasterDS = gdal.Open(rasterPath, gdal.GA_ReadOnly)
geoTransform = rasterDS.GetGeoTransform()
rasterBand = rasterDS.GetRasterBand(1)
noData = rasterBand.GetNoDataValue()
cellXSize = abs(geoTransform[1])
cellYSize = abs(geoTransform[5])
rasterXSize = rasterDS.RasterXSize
rasterYSize = rasterDS.RasterYSize
rasterBBox = QgsRectangle(geoTransform[0],
geoTransform[3] - cellYSize * rasterYSize,
geoTransform[0] + cellXSize * rasterXSize,
geoTransform[3])
rasterGeom = QgsGeometry.fromRect(rasterBBox)
crs = osr.SpatialReference()
crs.ImportFromProj4(str(target_crs.toProj4()))
memVectorDriver = ogr.GetDriverByName('Memory')
memRasterDriver = gdal.GetDriverByName('MEM')
features = source.getFeatures(QgsFeatureRequest().setDestinationCrs(target_crs, context.transformContext()))
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, f in enumerate(features):
if not f.hasGeometry():
continue
if feedback.isCanceled():
break
geom = f.geometry()
intersectedGeom = rasterGeom.intersection(geom)
if intersectedGeom.isEmpty():
feedback.pushInfo(
self.tr('Feature {0} does not intersect raster or '
'entirely located in NODATA area').format(f.id()))
continue
fName = os.path.join(
outputPath, 'hystogram_%s_%s.csv' % (source.sourceName(), f.id()))
ogrGeom = ogr.CreateGeometryFromWkt(intersectedGeom.asWkt())
bbox = intersectedGeom.boundingBox()
xMin = bbox.xMinimum()
xMax = bbox.xMaximum()
yMin = bbox.yMinimum()
yMax = bbox.yMaximum()
(startColumn, startRow) = raster.mapToPixel(xMin, yMax, geoTransform)
(endColumn, endRow) = raster.mapToPixel(xMax, yMin, geoTransform)
width = endColumn - startColumn
height = endRow - startRow
srcOffset = (startColumn, startRow, width, height)
srcArray = rasterBand.ReadAsArray(*srcOffset)
if srcOffset[2] == 0 or srcOffset[3] == 0:
feedback.pushInfo(
self.tr('Feature {0} is smaller than raster '
'cell size').format(f.id()))
continue
newGeoTransform = (
geoTransform[0] + srcOffset[0] * geoTransform[1],
geoTransform[1],
0.0,
geoTransform[3] + srcOffset[1] * geoTransform[5],
0.0,
geoTransform[5]
)
memVDS = memVectorDriver.CreateDataSource('out')
memLayer = memVDS.CreateLayer('poly', crs, ogr.wkbPolygon)
ft = ogr.Feature(memLayer.GetLayerDefn())
ft.SetGeometry(ogrGeom)
memLayer.CreateFeature(ft)
ft.Destroy()
rasterizedDS = memRasterDriver.Create('', srcOffset[2],
srcOffset[3], 1, gdal.GDT_Byte)
rasterizedDS.SetGeoTransform(newGeoTransform)
gdal.RasterizeLayer(rasterizedDS, [1], memLayer, burn_values=[1])
rasterizedArray = rasterizedDS.ReadAsArray()
srcArray = numpy.nan_to_num(srcArray)
masked = numpy.ma.MaskedArray(srcArray,
mask=numpy.logical_or(srcArray == noData,
numpy.logical_not(rasterizedArray)))
self.calculateHypsometry(f.id(), fName, feedback, masked,
cellXSize, cellYSize, percentage, step)
memVDS = None
rasterizedDS = None
feedback.setProgress(int(current * total))
rasterDS = None
return {self.OUTPUT_DIRECTORY: outputPath}
def excel_to_shp(data_path, excel_name, vec_file, lng_col_num, lat_col_num):
# 支持文件中文路径
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO")
# 支持文件中文字段
gdal.SetConfigOption("SHAPE_ENCODING", "GB2312")
# 注册所有的驱动
ogr.RegisterAll()
# 获取ESRI ShapeFile文件驱动
driver = ogr.GetDriverByName("ESRI ShapeFile")
# 切换到数据路径下
os.chdir(data_path)
# 判断该路径下是否存在该文件名的shp文件
if os.path.exists(vec_file):
# 存在,删除该shp文件
driver.DeleteDataSource(vec_file)
# 创建shp文件
out_ds = driver.CreateDataSource(vec_file)
# 判断文件是否创建成功
if out_ds is None:
# 提示创建文件失败
print("创建文件失败！")
# 跳出当前函数
return
# 创建空间参考对象
spatial_ref = osr.SpatialReference()
# 导入投影信息
spatial_ref.ImportFromEPSG(4326)
# 获取shp文件名称，并将其赋值给图层
layer_name = os.path.splitext(vec_file)[0]
# 创建输出的图层
out_layer = out_ds.CreateLayer(layer_name, spatial_ref, ogr.wkbPoint)
# 获取excel的表头及数据
cols, data = read_excel(excel_name, "Sheet1")
# 获取表头的个数
cols_count = len(cols)
# 遍历多有的表头并创建属性字段
for i_col in range(cols_count):
# 定义字段的名称
field_name = cols[i_col]
# 字段定义
field_def = ogr.FieldDefn(field_name, ogr.OFTString)
# 定义字段的长度
field_def.SetWidth(100)
# 将字段定义添加到图层中
out_layer.CreateField(field_def)
# 获取输出图层定义
out_layer_def = out_layer.GetLayerDefn()
# 获取数据的行数
rows_count = len(data)
# 遍历所有的数据并写入的字段中
for i_row in range(rows_count):
# 获取经度
lng = float(data[i_row][lng_col_num - 1])
# 获取纬度
lat = float(data[i_row][lat_col_num - 1])
# 创建点要素对象
feature_point = ogr.Feature(out_layer_def)
for i_col in range(cols_count):
# 获取字段名
field_name = cols[i_col]
# 获取每个字段对应的值
field_value = data[i_row][i_col]
# 给字段赋值
feature_point.SetField(field_name, field_value)
# 定义要素为点对象
geom_point = ogr.Geometry(ogr.wkbPoint)
# 添加点的坐标值
geom_point.AddPoint(lng, lat)
# 设置点的几何信息
feature_point.SetGeometry(geom_point)
# 创建要素点
out_layer.CreateFeature(feature_point)
# 销毁数据源
out_ds.Destroy()
# 提示数据转换成功
print("Excel 转点成功！")
def feature_to_pipes_shp(self, layer, id_nr, pipe):
"""
Add features to a shapefile.
Args:
(shapefile layer) layer: A shapefile layer.
(dict) queryset: A Django queryset that will be used for getting
the values of the fields.
Returns:
(shapefile layer) layer: A shapefile layer.
"""
# Get values
id_nr = id_nr
start_x = pipe.get("Beginpunt x", ' ')
start_y = pipe.get("Beginpunt y", ' ')
end_x = pipe.get("Eindpunt x", ' ')
end_y = pipe.get("Eindpunt y", ' ')
AAA = pipe.get("AAA", ' ')
AAB = pipe.get("AAB", ' ')
AAD = pipe.get("AAD", ' ')
AAE = ", ".join(pipe["AAE"])
AAF = pipe.get("AAF", ' ')
AAG = ", ".join(pipe["AAG"])
AAJ = pipe.get("AAJ", ' ')
AAK = pipe.get("AAK", ' ')
AAL = pipe.get("AAL", ' ')
AAM = pipe.get("AAM", ' ')
AAN = pipe.get("AAN", ' ')
AAO = pipe.get("AAO", ' ')
AAP = pipe.get("AAP", ' ')
AAQ = pipe.get("AAQ", ' ')
ABA = pipe.get("ABA", ' ')
ABB = pipe.get("ABB", ' ')
ABC = pipe.get("ABC", ' ')
ABE = pipe.get("ABE", ' ')
ABF = pipe.get("ABF", ' ')
ABH = pipe.get("ABH", ' ')
ABI = pipe.get("ABI", ' ')
ABJ = pipe.get("ABJ", ' ')
ABK = pipe.get("ABK", ' ')
ABL = pipe.get("ABL", ' ')
ABM = pipe.get("ABM", ' ')
ABP = pipe.get("ABP", ' ')
ABQ = pipe.get("ABQ", ' ')
ABS = pipe.get("ABS", ' ')
ACA = pipe.get("ACA", ' ')
ACB = pipe.get("ACB", ' ')
ACC = pipe.get("ACC", ' ')
ACD = pipe.get("ACD", ' ')
ACG = pipe.get("ACG", ' ')
ACJ = pipe.get("ACJ", ' ')
ACK = pipe.get("ACK", ' ')
ACM = pipe.get("ACM", ' ')
ACN = pipe.get("ACN", ' ')
ADA = pipe.get("ADA", ' ')
ADB = pipe.get("ADB", ' ')
ADC = pipe.get("ADC", ' ')
AXA = pipe.get("AXA", ' ')
AXB = pipe.get("AXB", ' ')
AXF = pipe.get("AXF", ' ')
AXG = pipe.get("AXG", ' ')
AXH = pipe.get("AXH", ' ')
herstelmaatregel = pipe["Herstelmaatregel"]
# herstelmaatregel = HERSTELMAATREGEL_DEFAULT
opmerking = pipe["Opmerking"]
artrigger = pipe.get("Trigger", '')
ZC = pipe["ZC"]
# Set values
feature = ogr.Feature(layer.GetLayerDefn())
wkt = "LINESTRING({} {}, {} {})".format(start_x, start_y, end_x, end_y)
line = ogr.CreateGeometryFromWkt(wkt)
feature.SetGeometry(line)
feature.SetField("ID", str(id_nr))
feature.SetField("AAA", str(AAA))
feature.SetField("AAB", str(AAB))
feature.SetField("AAD", str(AAD))
feature.SetField("AAE", str(AAE))
feature.SetField("AAF", str(AAF))
feature.SetField("AAG", str(AAG))
feature.SetField("AAJ", str(AAJ))
feature.SetField("AAK", str(AAK))
feature.SetField("AAL", str(AAL))
feature.SetField("AAM", str(AAM))
feature.SetField("AAN", str(AAN))
feature.SetField("AAO", str(AAO))
feature.SetField("AAP", str(AAP))
feature.SetField("AAQ", str(AAQ))
feature.SetField("ABA", str(ABA))
feature.SetField("ABB", str(ABB))
feature.SetField("ABC", str(ABC))
feature.SetField("ABE", str(ABE))
feature.SetField("ABF", str(ABF))
feature.SetField("ABH", str(ABH))
feature.SetField("ABI", str(ABI))
feature.SetField("ABJ", str(ABJ))
feature.SetField("ABK", str(ABK))
feature.SetField("ABL", str(ABL))
feature.SetField("ABM", str(ABM))
feature.SetField("ABP", str(ABP))
feature.SetField("ABQ", str(ABQ))
feature.SetField("ABS", str(ABS))
feature.SetField("ACA", str(ACA))
feature.SetField("ACB", str(ACB))
feature.SetField("ACC", str(ACC))
feature.SetField("ACD", str(ACD))
feature.SetField("ACG", str(ACG))
feature.SetField("ACJ", str(ACJ))
feature.SetField("ACK", str(ACK))
feature.SetField("ACM", str(ACM))
feature.SetField("ACN", str(ACN))
feature.SetField("ADA", str(ADA))
feature.SetField("ADB", str(ADB))
feature.SetField("ADC", str(ADC))
feature.SetField("AXA", str(AXA))
feature.SetField("AXB", str(AXB))
feature.SetField("AXF", str(AXF))
feature.SetField("AXG", str(AXG))
feature.SetField("AXH", str(AXH))
feature.SetField("Herstelmaa", str(herstelmaatregel))
feature.SetField("Opmerking", str(opmerking))
feature.SetField('Trigger', str(artrigger))
feature.SetField("ZC", str(ZC))
layer.CreateFeature(feature)
feature = None
return layer
def difference(f1,f2):
outputFileName = 'difference_' + f1
driver = ogr.GetDriverByName("ESRI Shapefile")
f1 = driver.Open(f1,0)
layer1 = f1.GetLayer()
feature1 = layer1.GetNextFeature()
if f1 is None:
print "Could not open file ", f1
sys.exit(1)
f2 = driver.Open(f2,0)
layer2 = f2.GetLayer()
# feature2 = layer2.GetNextFeature()
if f2 is None:
print "Could not open file ", f2
### Create output file ###
if os.path.exists(outputFileName):
os.remove(outputFileName)
try:
output = driver.CreateDataSource(outputFileName)
except:
print 'Could not create output datasource ', outputFileName
sys.exit(1)
newLayer = output.CreateLayer('SymmetricDifference',geom_type=ogr.wkbPolygon,srs=layer1.GetSpatialRef())
if newLayer is None:
print "Could not create output layer"
sys.exit(1)
newLayerDef = newLayer.GetLayerDefn()
##############################
featureID = 0
while feature1:
layer2.ResetReading()
geom1 = feature1.GetGeometryRef()
feature2 = layer2.GetNextFeature()
while feature2:
geom2 = feature2.GetGeometryRef()
if geom1.Overlaps(geom2) == 1:
newgeom = geom1.Difference(geom2)
newFeature = ogr.Feature(newLayerDef)
newFeature.SetGeometry(newgeom)
newFeature.SetFID(featureID)
newLayer.CreateFeature(newFeature)
featureID += 1
newFeature.Destroy()
else:
newFeature1 = ogr.Feature(newLayerDef)
newFeature1.SetGeometry(geom1)
newFeature1.SetFID(featureID)
newLayer.CreateFeature(newFeature1)
featureID += 1
newFeature2 = ogr.Feature(newLayerDef)
newFeature2.SetGeometry(geom2)
newFeature2.SetFID(featureID)
newLayer.CreateFeature(newfeature2)
featureID += 1
newFeature1.Destroy()
newFeature2.Destroy()
feature2.Destroy()
feature2 = layer2.GetNextFeature()
feature1.Destroy()
feature1 = layer1.GetNextFeature()
f1.Destroy()
f2.Destroy()
ring.AddPoint_2D(s_maxx, s_maxy)
ring.AddPoint_2D(s_minx, s_maxy)
ring.AddPoint_2D(s_minx, s_miny)
filt_geom = ogr.Geometry(ogr.wkbPolygon)
filt_geom.AddGeometry(ring)
#############################################################################
# Process all features in input layer.
in_feat = in_layer.GetNextFeature()
while in_feat is not None:
geom = in_feat.GetGeometryRef()
if geom.Intersect(filt_geom) != 0:
out_feat = ogr.Feature(feature_def=shp_layer.GetLayerDefn())
out_feat.SetFrom(in_feat)
shp_layer.CreateFeature(out_feat)
out_feat.Destroy()
in_feat.Destroy()
in_feat = in_layer.GetNextFeature()
#############################################################################
# Cleanup
shp_ds.Destroy()
in_ds.Destroy()
def exportATL08(input_icesat_h5file, out_vec_file, out_vec_lyr, vec_frmt='GPKG'):
"""
A function to import a ATL08 ICESAT2 hdf5.
* input_icesat_file
* out_vec_file
* out_vec_lyr
* vec_frmt
"""
if os.path.exists(out_vec_file):
vecDS = gdal.OpenEx(out_vec_file, gdal.GA_Update)
else:
outdriver = ogr.GetDriverByName(vec_frmt)
vecDS = outdriver.CreateDataSource(out_vec_file)
if vecDS is None:
raise Exception("Could not open or create '{}'".format(out_vec_file))
srs = osr.SpatialReference()
srs.ImportFromEPSG(4326)
laser_beams = ['gt1l', 'gt1r', 'gt2l', 'gt2r', 'gt3l', 'gt3r']
flds_dict = dict()
# General
flds_dict['segment_id'] = ogr.OFTInteger
flds_dict['segment_id_beg'] = ogr.OFTInteger
flds_dict['segment_id_end'] = ogr.OFTInteger
flds_dict['latitude'] = ogr.OFTReal
flds_dict['longitude'] = ogr.OFTReal
flds_dict['solar_azimuth'] = ogr.OFTReal
flds_dict['solar_elevation'] = ogr.OFTReal
flds_dict['delta_time'] = ogr.OFTReal
flds_dict['delta_time_beg'] = ogr.OFTReal
flds_dict['delta_time_end'] = ogr.OFTReal
flds_dict['night_flag'] = ogr.OFTInteger
flds_dict['dem_h'] = ogr.OFTReal
flds_dict['dem_flag'] = ogr.OFTInteger
flds_dict['dem_removal_flag'] = ogr.OFTInteger
flds_dict['h_dif_ref'] = ogr.OFTReal
flds_dict['terrain_flg'] = ogr.OFTInteger
flds_dict['segment_landcover'] = ogr.OFTInteger
flds_dict['segment_watermask'] = ogr.OFTInteger
flds_dict['segment_snowcover'] = ogr.OFTInteger
flds_dict['urban_flag'] = ogr.OFTInteger
flds_dict['cloud_flag_asr'] = ogr.OFTInteger
flds_dict['surf_type'] = ogr.OFTInteger
flds_dict['snr'] = ogr.OFTReal
# Terrain
flds_dict['h_te_mean'] = ogr.OFTReal
flds_dict['h_te_median'] = ogr.OFTReal
flds_dict['h_te_min'] = ogr.OFTReal
flds_dict['h_te_max'] = ogr.OFTReal
flds_dict['h_te_mode'] = ogr.OFTReal
flds_dict['h_te_skew'] = ogr.OFTReal
flds_dict['n_te_photons'] = ogr.OFTInteger
flds_dict['h_te_interp'] = ogr.OFTReal
flds_dict['h_te_std'] = ogr.OFTReal
flds_dict['h_te_uncertainty'] = ogr.OFTReal
flds_dict['terrain_slope'] = ogr.OFTReal
flds_dict['h_te_best_fit'] = ogr.OFTReal
# Canopy
flds_dict['canopy_h_metrics_abs_p25'] = ogr.OFTReal
flds_dict['canopy_h_metrics_abs_p50'] = ogr.OFTReal
flds_dict['canopy_h_metrics_abs_p60'] = ogr.OFTReal
flds_dict['canopy_h_metrics_abs_p70'] = ogr.OFTReal
flds_dict['canopy_h_metrics_abs_p75'] = ogr.OFTReal
flds_dict['canopy_h_metrics_abs_p80'] = ogr.OFTReal
flds_dict['canopy_h_metrics_abs_p85'] = ogr.OFTReal
flds_dict['canopy_h_metrics_abs_p90'] = ogr.OFTReal
flds_dict['canopy_h_metrics_abs_p95'] = ogr.OFTReal
flds_dict['canopy_h_metrics_p25'] = ogr.OFTReal
flds_dict['canopy_h_metrics_p50'] = ogr.OFTReal
flds_dict['canopy_h_metrics_p60'] = ogr.OFTReal
flds_dict['canopy_h_metrics_p70'] = ogr.OFTReal
flds_dict['canopy_h_metrics_p75'] = ogr.OFTReal
flds_dict['canopy_h_metrics_p80'] = ogr.OFTReal
flds_dict['canopy_h_metrics_p85'] = ogr.OFTReal
flds_dict['canopy_h_metrics_p90'] = ogr.OFTReal
flds_dict['canopy_h_metrics_p95'] = ogr.OFTReal
flds_dict['h_canopy_abs'] = ogr.OFTReal
flds_dict['h_canopy'] = ogr.OFTReal
flds_dict['h_mean_canopy_abs'] = ogr.OFTReal
flds_dict['h_mean_canopy'] = ogr.OFTReal
flds_dict['h_dif_canopy'] = ogr.OFTReal
flds_dict['h_min_canopy_abs'] = ogr.OFTReal
flds_dict['h_min_canopy'] = ogr.OFTReal
flds_dict['h_max_canopy_abs'] = ogr.OFTReal
flds_dict['h_max_canopy'] = ogr.OFTReal
flds_dict['h_canopy_uncertainty'] = ogr.OFTReal
flds_dict['canopy_openness'] = ogr.OFTReal
flds_dict['toc_roughness'] = ogr.OFTReal
flds_dict['h_canopy_quad'] = ogr.OFTReal
flds_dict['n_ca_photons'] = ogr.OFTInteger
flds_dict['n_toc_photons'] = ogr.OFTInteger
flds_dict['centroid_height'] = ogr.OFTReal
flds_dict['canopy_rh_conf'] = ogr.OFTInteger
flds_dict['canopy_flag'] = ogr.OFTInteger
flds_dict['landsat_flag'] = ogr.OFTInteger
flds_dict['landsat_perc'] = ogr.OFTReal
print("Processing Input File: {}".format(input_icesat_h5file))
fH5 = h5py.File(input_icesat_h5file)
for beam_name in laser_beams:
print("\tProcessing Beam: {}".format(beam_name))
lyr_name = '{}_{}'.format(out_vec_lyr, beam_name)
out_lyr_obj = vecDS.CreateLayer(lyr_name, srs, geom_type=ogr.wkbPoint, options=['OVERWRITE=YES'])
if out_lyr_obj is None:
raise Exception("Could not create layer: '{}'".format(lyr_name))
feat_defn = out_lyr_obj.GetLayerDefn()
col_exists = False
for fld_name in flds_dict:
#print(fld_name)
for i in range( feat_defn.GetFieldCount() ):
if feat_defn.GetFieldDefn(i).GetName().lower() == fld_name.lower():
col_exists = True
break
if not col_exists:
field_defn = ogr.FieldDefn( fld_name, flds_dict[fld_name] )
if out_lyr_obj.CreateField ( field_defn ) != 0:
raise Exception("Creating '{}' field failed; becareful with case.".format(fld_name))
lsr_beam_pth = '{}/land_segments'.format(beam_name)
cnpy_info_pth = '{}/land_segments/canopy'.format(beam_name)
trn_info_pth = '{}/land_segments/terrain'.format(beam_name)
land_segs_dir = fH5[lsr_beam_pth]
cnpy_info_dir = fH5[cnpy_info_pth]
trn_info_dir = fH5[trn_info_pth]
# General
segment_id = land_segs_dir['segment_id']
segment_id_beg = land_segs_dir['segment_id_beg']
segment_id_end = land_segs_dir['segment_id_end']
latitude = land_segs_dir['latitude']
longitude = land_segs_dir['longitude']
solar_azimuth = land_segs_dir['solar_azimuth']
solar_elevation = land_segs_dir['solar_elevation']
delta_time = land_segs_dir['delta_time']
delta_time_beg = land_segs_dir['delta_time_beg']
delta_time_end = land_segs_dir['delta_time_end']
night_flag = land_segs_dir['night_flag']
dem_h = land_segs_dir['dem_h']
dem_flag = land_segs_dir['dem_flag']
dem_removal_flag = land_segs_dir['dem_removal_flag']
h_dif_ref = land_segs_dir['h_dif_ref']
terrain_flg = land_segs_dir['terrain_flg']
segment_landcover = land_segs_dir['segment_landcover']
segment_watermask = land_segs_dir['segment_watermask']
segment_snowcover = land_segs_dir['segment_snowcover']
urban_flag = land_segs_dir['urban_flag']
last_seg_extend = land_segs_dir['last_seg_extend']
cloud_flag_asr = land_segs_dir['cloud_flag_asr']
snr = land_segs_dir['snr']
# Terrain
h_te_mean = trn_info_dir['h_te_mean']
h_te_median = trn_info_dir['h_te_median']
h_te_min = trn_info_dir['h_te_min']
h_te_max = trn_info_dir['h_te_max']
h_te_mode = trn_info_dir['h_te_mode']
h_te_skew = trn_info_dir['h_te_skew']
n_te_photons = trn_info_dir['n_te_photons']
h_te_interp = trn_info_dir['h_te_interp']
h_te_std = trn_info_dir['h_te_std']
h_te_uncertainty = trn_info_dir['h_te_uncertainty']
terrain_slope = trn_info_dir['terrain_slope']
h_te_best_fit = trn_info_dir['h_te_best_fit']
# Canopy
canopy_h_metrics_abs = cnpy_info_dir['canopy_h_metrics_abs']
canopy_h_metrics = cnpy_info_dir['canopy_h_metrics']
h_canopy_abs = cnpy_info_dir['h_canopy_abs']
h_canopy = cnpy_info_dir['h_canopy']
h_mean_canopy_abs = cnpy_info_dir['h_mean_canopy_abs']
h_mean_canopy = cnpy_info_dir['h_mean_canopy']
h_dif_canopy = cnpy_info_dir['h_dif_canopy']
h_min_canopy_abs = cnpy_info_dir['h_min_canopy_abs']
h_min_canopy = cnpy_info_dir['h_min_canopy']
h_max_canopy_abs = cnpy_info_dir['h_max_canopy_abs']
h_max_canopy = cnpy_info_dir['h_max_canopy']
h_canopy_uncertainty = cnpy_info_dir['h_canopy_uncertainty']
canopy_openness = cnpy_info_dir['canopy_openness']
toc_roughness = cnpy_info_dir['toc_roughness']
h_canopy_quad = cnpy_info_dir['h_canopy_quad']
n_ca_photons = cnpy_info_dir['n_ca_photons']
n_toc_photons = cnpy_info_dir['n_toc_photons']
centroid_height = cnpy_info_dir['centroid_height']
canopy_rh_conf = cnpy_info_dir['canopy_rh_conf']
canopy_flag = cnpy_info_dir['canopy_flag']
landsat_flag = cnpy_info_dir['landsat_flag']
landsat_perc = cnpy_info_dir['landsat_perc']
open_transaction = False
n_feats = latitude.shape[0]
for i in range(n_feats):
if not open_transaction:
out_lyr_obj.StartTransaction()
open_transaction = True
out_feat = ogr.Feature(feat_defn)
pt = ogr.Geometry(ogr.wkbPoint)
pt.AddPoint(float(longitude[i]), float(latitude[i]))
out_feat.SetGeometry(pt)
# General
out_feat.SetField('segment_id', int(segment_id[i]))
out_feat.SetField('segment_id_beg', int(segment_id_beg[i]))
out_feat.SetField('segment_id_end', int(segment_id_end[i]))
out_feat.SetField('latitude', float(latitude[i]))
out_feat.SetField('longitude', float(longitude[i]))
out_feat.SetField('solar_azimuth', float(solar_azimuth[i]))
out_feat.SetField('solar_elevation', float(solar_elevation[i]))
out_feat.SetField('delta_time', float(delta_time[i]))
out_feat.SetField('delta_time_beg', float(delta_time_beg[i]))
out_feat.SetField('delta_time_end', float(delta_time_end[i]))
out_feat.SetField('night_flag', int(night_flag[i]))
out_feat.SetField('dem_h', float(dem_h[i]))
out_feat.SetField('dem_flag', int(dem_flag[i]))
out_feat.SetField('dem_removal_flag', int(dem_removal_flag[i]))
out_feat.SetField('h_dif_ref', float(h_dif_ref[i]))
out_feat.SetField('terrain_flg', int(terrain_flg[i]))
out_feat.SetField('segment_landcover', int(segment_landcover[i]))
out_feat.SetField('segment_watermask', int(segment_watermask[i]))
out_feat.SetField('segment_snowcover', int(segment_snowcover[i]))
out_feat.SetField('urban_flag', int(urban_flag[i]))
out_feat.SetField('cloud_flag_asr', int(cloud_flag_asr[i]))
out_feat.SetField('snr', float(snr[i]))
# Terrain
out_feat.SetField('h_te_mean', float(h_te_mean[i]))
out_feat.SetField('h_te_median', float(h_te_median[i]))
out_feat.SetField('h_te_min', float(h_te_min[i]))
out_feat.SetField('h_te_max', float(h_te_max[i]))
out_feat.SetField('h_te_mode', float(h_te_mode[i]))
out_feat.SetField('h_te_skew', float(h_te_skew[i]))
out_feat.SetField('n_te_photons', int(n_te_photons[i]))
out_feat.SetField('h_te_interp', float(h_te_interp[i]))
out_feat.SetField('h_te_std', float(h_te_std[i]))
out_feat.SetField('h_te_uncertainty', float(h_te_uncertainty[i]))
out_feat.SetField('terrain_slope', float(terrain_slope[i]))
out_feat.SetField('h_te_best_fit', float(h_te_best_fit[i]))
# Canopy
out_feat.SetField('canopy_h_metrics_abs_p25', float(canopy_h_metrics_abs[i][0]))
out_feat.SetField('canopy_h_metrics_abs_p50', float(canopy_h_metrics_abs[i][1]))
out_feat.SetField('canopy_h_metrics_abs_p60', float(canopy_h_metrics_abs[i][2]))
out_feat.SetField('canopy_h_metrics_abs_p70', float(canopy_h_metrics_abs[i][3]))
out_feat.SetField('canopy_h_metrics_abs_p75', float(canopy_h_metrics_abs[i][4]))
out_feat.SetField('canopy_h_metrics_abs_p80', float(canopy_h_metrics_abs[i][5]))
out_feat.SetField('canopy_h_metrics_abs_p85', float(canopy_h_metrics_abs[i][6]))
out_feat.SetField('canopy_h_metrics_abs_p90', float(canopy_h_metrics_abs[i][7]))
out_feat.SetField('canopy_h_metrics_abs_p95', float(canopy_h_metrics_abs[i][8]))
out_feat.SetField('canopy_h_metrics_p25', float(canopy_h_metrics[i][0]))
out_feat.SetField('canopy_h_metrics_p50', float(canopy_h_metrics[i][1]))
out_feat.SetField('canopy_h_metrics_p60', float(canopy_h_metrics[i][2]))
out_feat.SetField('canopy_h_metrics_p70', float(canopy_h_metrics[i][3]))
out_feat.SetField('canopy_h_metrics_p75', float(canopy_h_metrics[i][4]))
out_feat.SetField('canopy_h_metrics_p80', float(canopy_h_metrics[i][5]))
out_feat.SetField('canopy_h_metrics_p85', float(canopy_h_metrics[i][6]))
out_feat.SetField('canopy_h_metrics_p90', float(canopy_h_metrics[i][7]))
out_feat.SetField('canopy_h_metrics_p95', float(canopy_h_metrics[i][8]))
out_feat.SetField('h_canopy_abs', float(h_canopy_abs[i]))
out_feat.SetField('h_canopy', float(h_canopy[i]))
out_feat.SetField('h_mean_canopy_abs', float(h_mean_canopy_abs[i]))
out_feat.SetField('h_mean_canopy', float(h_mean_canopy[i]))
out_feat.SetField('h_dif_canopy', float(h_dif_canopy[i]))
out_feat.SetField('h_min_canopy_abs', float(h_min_canopy_abs[i]))
out_feat.SetField('h_min_canopy', float(h_min_canopy[i]))
out_feat.SetField('h_max_canopy_abs', float(h_max_canopy_abs[i]))
out_feat.SetField('h_max_canopy', float(h_max_canopy[i]))
out_feat.SetField('h_canopy_uncertainty', float(h_canopy_uncertainty[i]))
out_feat.SetField('canopy_openness', float(canopy_openness[i]))
out_feat.SetField('toc_roughness', float(toc_roughness[i]))
out_feat.SetField('h_canopy_quad', float(h_canopy_quad[i]))
out_feat.SetField('n_ca_photons', int(n_ca_photons[i]))
out_feat.SetField('n_toc_photons', int(n_toc_photons[i]))
out_feat.SetField('centroid_height', float(centroid_height[i]))
out_feat.SetField('canopy_rh_conf', int(canopy_rh_conf[i]))
out_feat.SetField('canopy_flag', int(canopy_flag[i]))
out_feat.SetField('landsat_flag', int(landsat_flag[i]))
out_feat.SetField('landsat_perc', float(landsat_perc[i]))
out_lyr_obj.CreateFeature(out_feat)
out_feat = None
if ((i % 20000) == 0) and open_transaction:
out_lyr_obj.CommitTransaction()
open_transaction = False
if open_transaction:
out_lyr_obj.CommitTransaction()
open_transaction = False
out_lyr_obj.SyncToDisk()
fH5 = None
vecDS = None
def ogr_dxf_18():
ds = ogr.GetDriverByName('DXF').CreateDataSource(
'tmp/dxf_18.dxf', ['HEADER=data/header_extended.dxf'])
lyr = ds.CreateLayer('entities')
# Write a feature with a predefined LTYPE in the header.
dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn())
dst_feat.SetGeometryDirectly(
ogr.CreateGeometryFromWkt('LINESTRING(0 0,25 25)'))
dst_feat.SetField('Linetype', 'DASHED')
dst_feat.SetStyleString('PEN(c:#ffff00,w:2g,p:"12.0g 6.0g")')
lyr.CreateFeature(dst_feat)
dst_feat.Destroy()
# Write a feature with a named linetype but that isn't predefined in the header.
dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn())
dst_feat.SetGeometryDirectly(
ogr.CreateGeometryFromWkt('LINESTRING(5 5,30 30)'))
dst_feat.SetField('Linetype', 'DOTTED')
dst_feat.SetStyleString('PEN(c:#ffff00,w:2g,p:"0.0g 4.0g")')
lyr.CreateFeature(dst_feat)
dst_feat.Destroy()
# Write a feature without a linetype name - it will be created.
dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn())
dst_feat.SetGeometryDirectly(
ogr.CreateGeometryFromWkt('LINESTRING(5 5,40 30)'))
dst_feat.SetStyleString('PEN(c:#ffff00,w:2g,p:"3.0g 4.0g")')
lyr.CreateFeature(dst_feat)
dst_feat.Destroy()
ds = None
# Reopen and check contents.
ds = ogr.Open('tmp/dxf_18.dxf')
lyr = ds.GetLayer(0)
# Check first feature.
feat = lyr.GetNextFeature()
if feat.GetField('Linetype') != 'DASHED':
gdaltest.post_reason('Got wrong linetype. (1)')
return 'fail'
if feat.GetStyleString(
) != 'PEN(c:#ffff00,w:2g,p:"12.6999999999999993g 6.3499999999999996g")':
print(feat.GetStyleString())
gdaltest.post_reason("got wrong style string (1)")
return 'fail'
if ogrtest.check_feature_geometry(feat, 'LINESTRING (0 0,25 25)'):
return 'fail'
# Check second feature.
feat = lyr.GetNextFeature()
if feat.GetField('Linetype') != 'DOTTED':
gdaltest.post_reason('Got wrong linetype. (2)')
return 'fail'
if feat.GetStyleString() != 'PEN(c:#ffff00,w:2g,p:"0.0g 4.0g")':
print(feat.GetStyleString())
gdaltest.post_reason("got wrong style string (2)")
return 'fail'
if ogrtest.check_feature_geometry(feat, 'LINESTRING (5 5,30 30)'):
return 'fail'
# Check third feature.
feat = lyr.GetNextFeature()
if feat.GetField('Linetype') != 'AutoLineType-1':
gdaltest.post_reason('Got wrong linetype. (3)')
return 'fail'
if feat.GetStyleString() != 'PEN(c:#ffff00,w:2g,p:"3.0g 4.0g")':
print(feat.GetStyleString())
gdaltest.post_reason("got wrong style string (3)")
return 'fail'
if ogrtest.check_feature_geometry(feat, 'LINESTRING (5 5,40 30)'):
return 'fail'
# Cleanup
lyr = None
ds = None
os.unlink('tmp/dxf_18.dxf')
return 'success'
def ogr_dxf_17():
ds = ogr.GetDriverByName('DXF').CreateDataSource(
'tmp/dxf_17.dxf', ['HEADER=data/header_extended.dxf'])
blyr = ds.CreateLayer('blocks')
lyr = ds.CreateLayer('entities')
dst_feat = ogr.Feature(feature_def=blyr.GetLayerDefn())
dst_feat.SetGeometryDirectly(
ogr.CreateGeometryFromWkt(
'GEOMETRYCOLLECTION( LINESTRING(0 0,1 1),LINESTRING(1 0,0 1))'))
dst_feat.SetField('BlockName', 'XMark')
blyr.CreateFeature(dst_feat)
dst_feat.Destroy()
# Write a block reference feature.
dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn())
dst_feat.SetGeometryDirectly(ogr.CreateGeometryFromWkt('POINT(200 100)'))
dst_feat.SetField('Layer', 'abc')
dst_feat.SetField('BlockName', 'XMark')
lyr.CreateFeature(dst_feat)
dst_feat.Destroy()
# Write a block reference feature for a non-existant block.
dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn())
dst_feat.SetGeometryDirectly(ogr.CreateGeometryFromWkt('POINT(300 50)'))
dst_feat.SetField('Layer', 'abc')
dst_feat.SetField('BlockName', 'DoesNotExist')
lyr.CreateFeature(dst_feat)
dst_feat.Destroy()
# Write a block reference feature for a template defined block
dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn())
dst_feat.SetGeometryDirectly(ogr.CreateGeometryFromWkt('POINT(250 200)'))
dst_feat.SetField('Layer', 'abc')
dst_feat.SetField('BlockName', 'STAR')
lyr.CreateFeature(dst_feat)
dst_feat.Destroy()
# Write a block reference feature with scaling and rotation
dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn())
dst_feat.SetGeometryDirectly(ogr.CreateGeometryFromWkt('POINT(300 100)'))
dst_feat.SetField('BlockName', 'XMark')
dst_feat.SetField('BlockAngle', '30')
dst_feat.SetFieldDoubleList(lyr.GetLayerDefn().GetFieldIndex('BlockScale'),
[4.0, 5.0, 6.0])
lyr.CreateFeature(dst_feat)
dst_feat.Destroy()
ds = None
# Reopen and check contents.
ds = ogr.Open('tmp/dxf_17.dxf')
lyr = ds.GetLayer(0)
# Check first feature.
feat = lyr.GetNextFeature()
if feat.GetField('SubClasses') != 'AcDbEntity:AcDbBlockReference':
gdaltest.post_reason('Got wrong subclasses for feature 1.')
return 'fail'
if ogrtest.check_feature_geometry(
feat,
'GEOMETRYCOLLECTION (LINESTRING (200 100,201 101),LINESTRING (201 100,200 101))'
):
print('Feature 1')
return 'fail'
# Check second feature.
feat = lyr.GetNextFeature()
if feat.GetField('SubClasses') != 'AcDbEntity:AcDbPoint':
gdaltest.post_reason('Got wrong subclasses for feature 2.')
return 'fail'
if ogrtest.check_feature_geometry(feat, 'POINT (300 50)'):
print('Feature 2')
return 'fail'
# Check third feature.
feat = lyr.GetNextFeature()
if feat.GetField('SubClasses') != 'AcDbEntity:AcDbBlockReference':
gdaltest.post_reason('Got wrong subclasses for feature 3.')
return 'fail'
if ogrtest.check_feature_geometry(
feat,
'GEOMETRYCOLLECTION (LINESTRING (249.971852502328943 201.04145741382942 0,250.619244948763452 198.930395088499495 0),LINESTRING (250.619244948763452 198.930395088499495 0,249.042985079183779 200.47850746040811 0),LINESTRING (249.042985079183779 200.47850746040811 0,251.04145741382942 200.365917469723854 0),LINESTRING (251.04145741382942 200.365917469723854 0,249.52149253959189 198.95854258617058 0),LINESTRING (249.52149253959189 198.95854258617058 0,249.943705004657858 201.013309916158363 0))'
):
print('Feature 3')
return 'fail'
# Check fourth feature (scaled and rotated)
feat = lyr.GetNextFeature()
if feat.GetField('SubClasses') != 'AcDbEntity:AcDbBlockReference':
gdaltest.post_reason('Got wrong subclasses for feature 4.')
return 'fail'
if ogrtest.check_feature_geometry(
feat,
'GEOMETRYCOLLECTION (LINESTRING (300 100,300.964101615137736 106.330127018922198),LINESTRING (303.464101615137736 102.0,297.5 104.330127018922198))'
):
print('Feature 4')
return 'fail'
# Cleanup
lyr = None
ds = None
os.unlink('tmp/dxf_17.dxf')
return 'success'
def ogr_dxf_15():
ds = ogr.GetDriverByName('DXF').CreateDataSource('tmp/dxf_14.dxf',
['FIRST_ENTITY=80'])
lyr = ds.CreateLayer('entities')
dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn())
dst_feat.SetGeometryDirectly(
ogr.CreateGeometryFromWkt('LINESTRING(10 12, 60 65)'))
dst_feat.SetField('Layer', 'abc')
lyr.CreateFeature(dst_feat)
dst_feat.Destroy()
dst_feat = ogr.Feature(feature_def=lyr.GetLayerDefn())
dst_feat.SetGeometryDirectly(
ogr.CreateGeometryFromWkt('POLYGON((0 0,100 0,100 100,0 0))'))
lyr.CreateFeature(dst_feat)
dst_feat.Destroy()
lyr = None
ds = None
# Read back.
ds = ogr.Open('tmp/dxf_14.dxf')
lyr = ds.GetLayer(0)
# Check first feature
feat = lyr.GetNextFeature()
if ogrtest.check_feature_geometry(feat, 'LINESTRING(10 12, 60 65)'):
print(feat.GetGeometryRef().ExportToWkt())
return 'fail'
if feat.GetGeometryRef().GetGeometryType() == ogr.wkbLineString25D:
gdaltest.post_reason('not linestring 2D')
return 'fail'
if feat.GetField('Layer') != 'abc':
gdaltest.post_reason('Did not get expected layer, abc.')
return 'fail'
feat.Destroy()
# Check second point.
feat = lyr.GetNextFeature()
if ogrtest.check_feature_geometry(feat,
'POLYGON((0 0,100 0,100 100,0 0))'):
print(feat.GetGeometryRef().ExportToWkt())
return 'fail'
if feat.GetGeometryRef().GetGeometryType() == ogr.wkbPolygon25D:
gdaltest.post_reason('not keeping polygon 2D')
return 'fail'
if feat.GetField('Layer') != '0':
print(feat.GetField('Layer'))
gdaltest.post_reason('Did not get expected layer, 0.')
return 'fail'
feat.Destroy()
lyr = None
ds.Destroy()
ds = None
# Check the DXF file itself to try and ensure that the layer
# is defined essentially as we expect. We assume the only thing
# that will be different is the layer name is 'abc' instead of '0'
# and the entity id.
outdxf = open('tmp/dxf_14.dxf').read()
start_1 = outdxf.find(' 0\nLAYER')
start_2 = outdxf.find(' 0\nLAYER', start_1 + 10)
txt_1 = outdxf[start_1:start_2]
txt_2 = outdxf[start_2:start_2 + len(txt_1) + 2]
abc_off = txt_2.find('abc\n')
if txt_2[16:abc_off] + '0' + txt_2[abc_off + 3:] != txt_1[16:]:
print(txt_2[abc_off] + '0' + txt_2[abc_off + 3:])
print(txt_1)
gdaltest.post_reason('Layer abc does not seem to match layer 0.')
return 'fail'
# Check that $HANDSEED was set as expected.
start_seed = outdxf.find('$HANDSEED')
handseed = outdxf[start_seed + 10 + 4:start_seed + 10 + 4 + 8]
if handseed != '00000053':
gdaltest.post_reason('Did not get expected HANDSEED, got %s.' %
handseed)
return 'fail'
os.unlink('tmp/dxf_14.dxf')
return 'success'
def db2Feat(self, parent, table, results, columns, geom=""):
#Execute the export process
#Create driver
drv = ogr.GetDriverByName(self.getDriverName())
if drv is None:
raise Exception("{0} driver not available.".format(
self.getDriverName()))
#Create data source
self._ds = drv.CreateDataSource(self._targetFile)
if self._ds is None:
raise Exception("Creation of output file failed.")
#Create layer
if geom != "":
pgGeomType, srid = geometryType(table, geom)
geomType = wkbTypes[pgGeomType]
else:
geomType = ogr.wkbNone
lyr = self._ds.CreateLayer(self.getLayerName(), None, geomType)
if lyr is None:
raise Exception("Layer creation failed")
#Create fields
for c in columns:
#SQLAlchemy string values are in unicode so decoding is required in order to use in OGR
encodedFieldName = c.encode('utf-8')
field_defn = self.createField(table, encodedFieldName)
if lyr.CreateField(field_defn) != 0:
raise Exception("Creating %s field failed" % (c))
#Add Geometry column to list for referencing in the result set
if geom != "":
columns.append(geom)
featGeom = None
#Configure progress dialog
initVal = 0
numFeat = results.rowcount
progress = QProgressDialog("", "&Cancel", initVal, numFeat, parent)
progress.setWindowModality(Qt.WindowModal)
lblMsgTemp = "Writing {0} of {1} to file..."
#Iterate the result set
for r in results:
#Progress dialog
progress.setValue(initVal)
progressMsg = lblMsgTemp.format(str(initVal + 1), str(numFeat))
progress.setLabelText(progressMsg)
if progress.wasCanceled():
break
#Create OGR Feature
feat = ogr.Feature(lyr.GetLayerDefn())
for i in range(len(columns)):
colName = columns[i]
#Check if its the geometry column in the iteration
if colName == geom:
if r[i] is not None:
featGeom = ogr.CreateGeometryFromWkt(r[i])
else:
featGeom = ogr.CreateGeometryFromWkt("")
feat.SetGeometry(featGeom)
else:
fieldValue = r[i]
if isinstance(fieldValue, unicode):
fieldValue = fieldValue.encode('utf-8')
feat.SetField(i, fieldValue)
if lyr.CreateFeature(feat) != 0:
progress.close()
raise Exception("Failed to create feature in %s" %
(self._targetFile))
if featGeom is not None:
featGeom.Destroy()
feat.Destroy()
initVal += 1
progress.setValue(numFeat)
def mask_from_geom(geom,
rds,
band_num=1,
epsg=32760,
nodata_value=None,
all_touched=False,
full_extent=False):
"""
Return a binary mask to mask off everything outside of geom.
Parameters
----------
geom : shapely.geometry
Cells inside this geometry will be `False`. Cells outside will be `True`
rds : RasterDS
The raster dataset to create a mask for.
full_extent : bool
If `True`, return a mask that's the full extent of `rds`. If `False`
(default), return a mask that's the extent of `geom`.
Returns
-------
numpy boolean array
An array with `True` outside `geom` and `False` inside.
"""
spatial_ref = osr.SpatialReference()
spatial_ref.ImportFromEPSG(epsg)
mem_drv = ogr.GetDriverByName('Memory')
driver = gdal.GetDriverByName('MEM')
rb = rds.gdal_ds.GetRasterBand(band_num)
rgt = rds.gdal_ds.GetGeoTransform()
rsize = (rds.gdal_ds.RasterXSize, rds.gdal_ds.RasterYSize)
if nodata_value is not None:
nodata_value = float(nodata_value)
rb.SetNoDataValue(nodata_value)
else:
nodata_value = rb.GetNoDataValue()
# Point and MultiPoint don't play well with GDALRasterize
# convert them into box polygons the size of a raster cell
# buff = rgt[1] / 2.0
# if geom.type == "MultiPoint":
# geom = MultiPolygon([box(*(pt.buffer(buff).bounds))
# for pt in geom.geoms])
# elif geom.type == 'Point':
# geom = box(*(geom.buffer(buff).bounds))
ogr_geom_type = shapely_to_ogr_type(geom.type)
if full_extent:
geom_bounds = list(rds.raster_extent.bounds)
else:
geom_bounds = list(geom.bounds)
# calculate new pixel coordinates of the feature subset
src_offset = bbox_to_pixel_offsets(rgt, geom_bounds, rsize)
new_gt = ((rgt[0] + (src_offset[0] * rgt[1])), rgt[1], 0.0,
(rgt[3] + (src_offset[1] * rgt[5])), 0.0, rgt[5])
if src_offset[2] <= 0 or src_offset[3] <= 0:
# we're off the raster completely, no overlap at all
# so there's no need to even bother trying to calculate
return None
else:
# use feature's source extent and read directly from source
# fastest option when you have fast disks and well-indexed raster
# advantage: each feature uses the smallest raster chunk
# disadvantage: lots of disk reads on the source raster
#src_array = rb.ReadAsArray(*src_offset)
# Create a temporary vector layer in memory
mem_ds = mem_drv.CreateDataSource('out')
mem_layer = mem_ds.CreateLayer('out', spatial_ref, ogr_geom_type)
ogr_feature = ogr.Feature(feature_def=mem_layer.GetLayerDefn())
ogr_geom = ogr.CreateGeometryFromWkt(geom.wkt)
ogr_feature.SetGeometryDirectly(ogr_geom)
mem_layer.CreateFeature(ogr_feature)
# Rasterize it
rvds = driver.Create('rvds', src_offset[2], src_offset[3], 1,
gdal.GDT_Byte)
rvds.SetGeoTransform(new_gt)
if all_touched:
gdal.RasterizeLayer(rvds, [1],
mem_layer,
None,
None,
burn_values=[1],
options=['ALL_TOUCHED=True'])
else:
gdal.RasterizeLayer(rvds, [1],
mem_layer,
None,
None,
burn_values=[1],
options=['ALL_TOUCHED=False'])
rv_array = rvds.ReadAsArray()
# Mask the source data array with our current feature
# we take the logical_not to flip 0<->1 to get the correct mask effect
# we also mask out nodata values explictly
# masked = np.ma.MaskedArray(
# src_array,
# mask=np.logical_or(
# src_array == nodata_value,
# np.logical_not(rv_array)
# )
# )
# return masked
# return np.logical_or( src_array == nodata_value, np.logical_not( rv_array ) )
return ~rv_array.astype('bool')
def processAlgorithm(self, progress):
""" Based on code by Matthew Perry
https://gist.github.com/perrygeo/5667173
"""
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_VECTOR))
rasterPath = str(self.getParameterValue(self.INPUT_RASTER))
bandNumber = self.getParameterValue(self.RASTER_BAND)
columnPrefix = self.getParameterValue(self.COLUMN_PREFIX)
useGlobalExtent = self.getParameterValue(self.GLOBAL_EXTENT)
rasterDS = gdal.Open(rasterPath, gdal.GA_ReadOnly)
geoTransform = rasterDS.GetGeoTransform()
rasterBand = rasterDS.GetRasterBand(bandNumber)
noData = rasterBand.GetNoDataValue()
cellXSize = abs(geoTransform[1])
cellYSize = abs(geoTransform[5])
rasterXSize = rasterDS.RasterXSize
rasterYSize = rasterDS.RasterYSize
rasterBBox = QgsRectangle(geoTransform[0],
geoTransform[3] - cellYSize * rasterYSize,
geoTransform[0] + cellXSize * rasterXSize,
geoTransform[3])
rasterGeom = QgsGeometry.fromRect(rasterBBox)
crs = osr.SpatialReference()
crs.ImportFromProj4(str(layer.crs().toProj4()))
if useGlobalExtent:
xMin = rasterBBox.xMinimum()
xMax = rasterBBox.xMaximum()
yMin = rasterBBox.yMinimum()
yMax = rasterBBox.yMaximum()
(startColumn, startRow) = mapToPixel(xMin, yMax, geoTransform)
(endColumn, endRow) = mapToPixel(xMax, yMin, geoTransform)
width = endColumn - startColumn
height = endRow - startRow
srcOffset = (startColumn, startRow, width, height)
srcArray = rasterBand.ReadAsArray(*srcOffset)
srcArray = srcArray * rasterBand.GetScale() + rasterBand.GetOffset(
)
newGeoTransform = (
geoTransform[0] + srcOffset[0] * geoTransform[1],
geoTransform[1],
0.0,
geoTransform[3] + srcOffset[1] * geoTransform[5],
0.0,
geoTransform[5],
)
memVectorDriver = ogr.GetDriverByName('Memory')
memRasterDriver = gdal.GetDriverByName('MEM')
fields = layer.fields()
(idxMin, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'min', 21,
6)
(idxMax, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'max', 21,
6)
(idxSum, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'sum', 21,
6)
(idxCount, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'count',
21, 6)
(idxMean, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'mean', 21,
6)
(idxStd, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'std', 21,
6)
(idxUnique, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'unique',
21, 6)
(idxRange, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'range',
21, 6)
(idxVar, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'var', 21,
6)
(idxMedian, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'median',
21, 6)
if hasSciPy:
(idxMode,
fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'mode', 21, 6)
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
fields.toList(), layer.wkbType(), layer.crs())
outFeat = QgsFeature()
outFeat.initAttributes(len(fields))
outFeat.setFields(fields)
features = vector.features(layer)
total = 100.0 / len(features)
for current, f in enumerate(features):
geom = f.geometry()
intersectedGeom = rasterGeom.intersection(geom)
ogrGeom = ogr.CreateGeometryFromWkt(intersectedGeom.exportToWkt())
if not useGlobalExtent:
bbox = intersectedGeom.boundingBox()
xMin = bbox.xMinimum()
xMax = bbox.xMaximum()
yMin = bbox.yMinimum()
yMax = bbox.yMaximum()
(startColumn, startRow) = mapToPixel(xMin, yMax, geoTransform)
(endColumn, endRow) = mapToPixel(xMax, yMin, geoTransform)
width = endColumn - startColumn
height = endRow - startRow
if width == 0 or height == 0:
continue
srcOffset = (startColumn, startRow, width, height)
srcArray = rasterBand.ReadAsArray(*srcOffset)
srcArray = srcArray * rasterBand.GetScale(
) + rasterBand.GetOffset()
newGeoTransform = (
geoTransform[0] + srcOffset[0] * geoTransform[1],
geoTransform[1],
0.0,
geoTransform[3] + srcOffset[1] * geoTransform[5],
0.0,
geoTransform[5],
)
# Create a temporary vector layer in memory
memVDS = memVectorDriver.CreateDataSource('out')
memLayer = memVDS.CreateLayer('poly', crs, ogr.wkbPolygon)
ft = ogr.Feature(memLayer.GetLayerDefn())
ft.SetGeometry(ogrGeom)
memLayer.CreateFeature(ft)
ft.Destroy()
# Rasterize it
rasterizedDS = memRasterDriver.Create('', srcOffset[2],
srcOffset[3], 1,
gdal.GDT_Byte)
rasterizedDS.SetGeoTransform(newGeoTransform)
gdal.RasterizeLayer(rasterizedDS, [1], memLayer, burn_values=[1])
rasterizedArray = rasterizedDS.ReadAsArray()
srcArray = numpy.nan_to_num(srcArray)
masked = numpy.ma.MaskedArray(
srcArray,
mask=numpy.logical_or(srcArray == noData,
numpy.logical_not(rasterizedArray)))
outFeat.setGeometry(geom)
attrs = f.attributes()
v = float(masked.min())
attrs.insert(idxMin, None if numpy.isnan(v) else v)
v = float(masked.max())
attrs.insert(idxMax, None if numpy.isnan(v) else v)
v = float(masked.sum())
attrs.insert(idxSum, None if numpy.isnan(v) else v)
attrs.insert(idxCount, int(masked.count()))
v = float(masked.mean())
attrs.insert(idxMean, None if numpy.isnan(v) else v)
v = float(masked.std())
attrs.insert(idxStd, None if numpy.isnan(v) else v)
attrs.insert(idxUnique, numpy.unique(masked.compressed()).size)
v = float(masked.max()) - float(masked.min())
attrs.insert(idxRange, None if numpy.isnan(v) else v)
v = float(masked.var())
attrs.insert(idxVar, None if numpy.isnan(v) else v)
v = float(numpy.ma.median(masked))
attrs.insert(idxMedian, None if numpy.isnan(v) else v)
if hasSciPy:
attrs.insert(idxMode, float(mode(masked, axis=None)[0][0]))
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
memVDS = None
rasterizedDS = None
progress.setPercentage(int(current * total))
rasterDS = None
del writer
idx = [
j for j, x in enumerate(SOIL_ID_List2)
if (x == s and LAYER_NO_List[j] == '1')
]
#idx = [j for j, x in enumerate(SOIL_ID_List2) if x == s]
#for id in idx:
# LAYER_NO_List[j]
KSATav += float(KSAT_List[idx[0]]) * p / 100
KSATav = KSATav / 2.54 # cm/h to in/h
if KSATav < 0.:
KSATav = 0.0
print KSATav, 'in in/h'
# create a new feature
outFeature = ogr.Feature(featureDefn)
outFeature.SetGeometry(inFeature.GetGeometryRef())
# Set the field content
for field in fields:
outFeature.SetField(field, inFeature.GetField(field))
outFeature.SetField('KSAT_IN_HR', KSATav)
# add the feature to the output layer
outLayer.CreateFeature(outFeature)
# destroy the features
inFeature.Destroy()
outFeature.Destroy()
inFeature = inLayer.GetNextFeature()
i += 1
def main():
i = 1
output_format = None
in_filename = None
out_filename = None
ovr_level = None
while i < len(sys.argv):
if sys.argv[i] == "-f":
output_format = sys.argv[i + 1]
i = i + 1
elif sys.argv[i] == "-ovr":
ovr_level = int(sys.argv[i + 1])
i = i + 1
elif sys.argv[i][0] == '-':
return Usage()
elif in_filename is None:
in_filename = sys.argv[i]
elif out_filename is None:
out_filename = sys.argv[i]
else:
return Usage()
i = i + 1
if out_filename is None:
return Usage()
if output_format is None:
output_format = GetOutputDriverFor(out_filename)
src_ds = gdal.Open(in_filename)
out_ds = gdal.GetDriverByName(output_format).Create(
out_filename, 0, 0, 0, gdal.GDT_Unknown)
first_band = src_ds.GetRasterBand(1)
main_gt = src_ds.GetGeoTransform()
for i in ([ovr_level] if ovr_level is not None else
range(1 + first_band.GetOverviewCount())):
src_band = first_band if i == 0 else first_band.GetOverview(i - 1)
out_lyr = out_ds.CreateLayer('main_image' if i == 0 else
('overview_%d' % i),
geom_type=ogr.wkbPolygon,
srs=src_ds.GetSpatialRef())
blockxsize, blockysize = src_band.GetBlockSize()
nxblocks = (src_band.XSize + blockxsize - 1) // blockxsize
nyblocks = (src_band.YSize + blockysize - 1) // blockysize
gt = [
main_gt[0], main_gt[1] * first_band.XSize / src_band.XSize, 0,
main_gt[3], 0, main_gt[5] * first_band.YSize / src_band.YSize
]
for y in range(nyblocks):
ymax = gt[3] + y * blockysize * gt[5]
ymin = ymax + blockysize * gt[5]
for x in range(nxblocks):
xmin = gt[0] + x * blockxsize * gt[1]
xmax = xmin + blockxsize * gt[1]
f = ogr.Feature(out_lyr.GetLayerDefn())
wkt = 'POLYGON((%.18g %.18g,%.18g %.18g,%.18g %.18g,%.18g %.18g,%.18g %.18g))' % (
xmin, ymin, xmin, ymax, xmax, ymax, xmax, ymin, xmin, ymin)
f.SetGeometryDirectly(ogr.CreateGeometryFromWkt(wkt))
out_lyr.CreateFeature(f)
out_ds = None
)
transform = osr.CoordinateTransformation(srcProjection, dstProjection)
# Create the dest shapefile, and give it the new projection.
driver = ogr.GetDriverByName("ESRI Shapefile")
if os.path.exists(shpOutFileName): driver.DeleteDataSource(shpOutFileName)
dstFile = driver.CreateDataSource(shpOutFileName)
dstLayer = dstFile.CreateLayer("layer", dstProjection)
# Copy fields to the layer
fieldIndices = range(layerDefn.GetFieldCount())
for fieldIndex in fieldIndices:
dstLayer.CreateField(layerDefn.GetFieldDefn(fieldIndex))
# Reproject each feature in turn.
for i in range(srcLayer.GetFeatureCount()):
feature = srcLayer.GetFeature(i)
geometry = feature.GetGeometryRef()
newGeometry = geometry.Clone()
newGeometry.Transform(transform)
newFeature = ogr.Feature(dstLayer.GetLayerDefn())
newFeature.SetGeometry(newGeometry)
# Copy field values
for fieldIndex in fieldIndices:
fieldName = layerDefn.GetFieldDefn(fieldIndex).GetName()
fieldValue = feature.GetFieldAsString(fieldName)
newFeature.SetField(fieldName, fieldValue)
dstLayer.CreateFeature(newFeature)
newFeature.Destroy()
# All done.
srcFile.Destroy()
dstFile.Destroy()
def boundary_polygonup(self, path, destination):
# ogrsql
'''
python process.py --path ../../test/data/boundary-polygon.shp
ogr2ogr -f "ESRI Shapefile" ../../test/result.shp ../../test/data/boundary-polygon.shp -dialect sqlite \
-sql "select ST_buffer(Geometry,0.001) from boundary-polygon"
'''
from osgeo import ogr
'''
ogr_ds = ogr.Open(path)
TEST=3
sql = "SELECT upper_polygon.NAME FROM \"boundary-polygon\" current_polygon, \"boundary-polygon\" upper_polygon ON ST_Intersects(ST_PointOnSurface(current_polygon.GEOMETRY), upper_polygon.GEOMETRY)=1 WHERE ADMIN_LVL = '6'"
sql = "SELECT current_polygon.NAME AS name_c, upper_polygon.NAME,ST_Intersects(ST_Centroid(current_polygon.GEOMETRY), upper_polygon.GEOMETRY) AS val FROM \"boundary-polygon\" current_polygon, \"boundary-polygon\" upper_polygon ON 1=1 WHERE current_polygon.ADMIN_LVL = '6' AND upper_polygon.ADMIN_LVL = '4' LIMIT 100"
sql = "select GEOMETRY, NAME as name from \"boundary-polygon\" WHERE ADMIN_LVL = '6'"
layer = ogr_ds.ExecuteSQL(sql,None,'SQLITE')
'''
defaultDestination = os.path.dirname(path), "test.shp"
driver = ogr.GetDriverByName("ESRI Shapefile")
if os.path.isfile(path) == False:
raise IOError('file {path} does not exist.'.format(path=path))
quit()
dataSource = driver.Open(path, 0)
layer = dataSource.GetLayer()
#get physical filename for destination
#By default in emporary folder
temp_destination_folder = ''
if destination is None:
import tempfile
import shutil
folder_was_temp = True
temp_destination_folder = tempfile.mkdtemp()
outShapefile = os.path.join(temp_destination_folder,
'boundary-polygon.shp')
else:
# Save to a new Shapefile
outShapefile = destination
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)
srs = osr.SpatialReference()
srs.ImportFromEPSG(4326)
outLayer = outDataSource.CreateLayer("test",
srs=srs,
geom_type=ogr.wkbMultiPolygon,
options=["ENCODING=UTF-8"])
# Add input Layer Fields to the output Layer
inLayerDefn = layer.GetLayerDefn()
for i in range(0, inLayerDefn.GetFieldCount()):
fieldDefn = inLayerDefn.GetFieldDefn(i)
outLayer.CreateField(fieldDefn)
# Add special fields
outLayer.CreateField(ogr.FieldDefn('ADMIN_L1', ogr.OFTString))
outLayer.CreateField(ogr.FieldDefn('ADMIN_L2', ogr.OFTString))
outLayer.CreateField(ogr.FieldDefn('ADMIN_L3', ogr.OFTString))
outLayer.CreateField(ogr.FieldDefn('ADMIN_L4', ogr.OFTString))
outLayer.CreateField(ogr.FieldDefn('ADMIN_L5', ogr.OFTString))
outLayer.CreateField(ogr.FieldDefn('ADMIN_L6', ogr.OFTString))
outLayer.CreateField(ogr.FieldDefn('ADMIN_L7', ogr.OFTString))
outLayer.CreateField(ogr.FieldDefn('ADMIN_L8', ogr.OFTString))
outLayer.CreateField(ogr.FieldDefn('ADMIN_L9', ogr.OFTString))
# Get the output Layer's Feature Definition
outLayerDefn = outLayer.GetLayerDefn()
# Also open source layer several times for search
# Apply attribute filter for search upper names
dataSource_admlevel1 = driver.Open(path, 0)
layer_admlevel1 = dataSource_admlevel1.GetLayer()
layer_admlevel1.SetAttributeFilter("ADMIN_LVL = '1'")
dataSource_admlevel2 = driver.Open(path, 0)
layer_admlevel2 = dataSource_admlevel2.GetLayer()
layer_admlevel2.SetAttributeFilter("ADMIN_LVL = '2'")
dataSource_admlevel3 = driver.Open(path, 0)
layer_admlevel3 = dataSource_admlevel3.GetLayer()
layer_admlevel3.SetAttributeFilter("ADMIN_LVL = '3'")
dataSource_admlevel4 = driver.Open(path, 0)
layer_admlevel4 = dataSource_admlevel4.GetLayer()
layer_admlevel4.SetAttributeFilter("ADMIN_LVL = '4'")
dataSource_admlevel5 = driver.Open(path, 0)
layer_admlevel5 = dataSource_admlevel5.GetLayer()
layer_admlevel5.SetAttributeFilter("ADMIN_LVL = '5'")
dataSource_admlevel6 = driver.Open(path, 0)
layer_admlevel6 = dataSource_admlevel6.GetLayer()
layer_admlevel6.SetAttributeFilter("ADMIN_LVL = '6'")
dataSource_admlevel7 = driver.Open(path, 0)
layer_admlevel7 = dataSource_admlevel7.GetLayer()
layer_admlevel7.SetAttributeFilter("ADMIN_LVL = '7'")
dataSource_admlevel8 = driver.Open(path, 0)
layer_admlevel8 = dataSource_admlevel8.GetLayer()
layer_admlevel8.SetAttributeFilter("ADMIN_LVL = '8'")
dataSource_admlevel9 = driver.Open(path, 0)
layer_admlevel9 = dataSource_admlevel9.GetLayer()
layer_admlevel9.SetAttributeFilter("ADMIN_LVL = '9'")
# Add features to the ouput Layer
bar = progressbar.ProgressBar(widgets=[
' [',
progressbar.Timer(),
'] ',
progressbar.Bar(),
' (',
progressbar.ETA(),
') ',
])
for i in bar(range(0, layer.GetFeatureCount())):
#for i in range(0, layer.GetFeatureCount()):
# Get the input Feature
inFeature = layer.GetFeature(i)
geom = inFeature.GetGeometryRef()
#Perform a spatial query
query_geometry = geom.PointOnSurface().Buffer(0.009)
layer_admlevel1.SetSpatialFilter(query_geometry)
layer_admlevel2.SetSpatialFilter(query_geometry)
layer_admlevel3.SetSpatialFilter(query_geometry)
layer_admlevel4.SetSpatialFilter(query_geometry)
layer_admlevel5.SetSpatialFilter(query_geometry)
layer_admlevel6.SetSpatialFilter(query_geometry)
layer_admlevel7.SetSpatialFilter(query_geometry)
layer_admlevel8.SetSpatialFilter(query_geometry)
layer_admlevel9.SetSpatialFilter(query_geometry)
##according to documentation, it return "all features whose envelope (as returned by OGRGeometry::getEnvelope()) overlaps the envelope of the spatial filter".
#may be faster to ..rect
#Get name of upper region
layer_admlevel1.ResetReading()
upFeature_admlevel1 = layer_admlevel1.GetNextFeature()
layer_admlevel2.ResetReading()
upFeature_admlevel2 = layer_admlevel2.GetNextFeature()
layer_admlevel3.ResetReading()
upFeature_admlevel3 = layer_admlevel3.GetNextFeature()
layer_admlevel4.ResetReading()
upFeature_admlevel4 = layer_admlevel4.GetNextFeature()
layer_admlevel5.ResetReading()
upFeature_admlevel5 = layer_admlevel5.GetNextFeature()
layer_admlevel6.ResetReading()
upFeature_admlevel6 = layer_admlevel6.GetNextFeature()
layer_admlevel7.ResetReading()
upFeature_admlevel7 = layer_admlevel7.GetNextFeature()
layer_admlevel8.ResetReading()
upFeature_admlevel8 = layer_admlevel8.GetNextFeature()
layer_admlevel9.ResetReading()
upFeature_admlevel9 = layer_admlevel9.GetNextFeature()
# Create output Feature
outFeature = ogr.Feature(outLayerDefn)
# Add field values from input Layer
for f in range(0, inLayerDefn.GetFieldCount()):
outFeature.SetField(
outLayerDefn.GetFieldDefn(f).GetNameRef(),
inFeature.GetField(f))
#Add name of upper region
current_ADMIN_LVL = inFeature.GetField('ADMIN_LVL')
if current_ADMIN_LVL in [
'2', '3', '4', '5', '6', '7', '8', '9', '10'
] and upFeature_admlevel1 is not None:
outFeature.SetField('ADMIN_L1',
upFeature_admlevel1.GetField('NAME'))
if current_ADMIN_LVL in ['3', '4', '5', '6', '7', '8', '9', '10'
] and upFeature_admlevel2 is not None:
outFeature.SetField('ADMIN_L2',
upFeature_admlevel2.GetField('NAME'))
if current_ADMIN_LVL in ['4', '5', '6', '7', '8', '9', '10'
] and upFeature_admlevel3 is not None:
outFeature.SetField('ADMIN_L3',
upFeature_admlevel3.GetField('NAME'))
if current_ADMIN_LVL in ['5', '6', '7', '8', '9', '10'
] and upFeature_admlevel4 is not None:
outFeature.SetField('ADMIN_L4',
upFeature_admlevel4.GetField('NAME'))
if current_ADMIN_LVL in ['6', '7', '8', '9', '10'
] and upFeature_admlevel5 is not None:
outFeature.SetField('ADMIN_L5',
upFeature_admlevel5.GetField('NAME'))
if current_ADMIN_LVL in ['7', '8', '9', '10'
] and upFeature_admlevel6 is not None:
outFeature.SetField('ADMIN_L6',
upFeature_admlevel6.GetField('NAME'))
if current_ADMIN_LVL in ['8', '9', '10'
] and upFeature_admlevel7 is not None:
outFeature.SetField('ADMIN_L7',
upFeature_admlevel7.GetField('NAME'))
if current_ADMIN_LVL in ['9', '10'
] and upFeature_admlevel8 is not None:
outFeature.SetField('ADMIN_L8',
upFeature_admlevel8.GetField('NAME'))
if current_ADMIN_LVL in ['10'] and upFeature_admlevel9 is not None:
outFeature.SetField('ADMIN_L9',
upFeature_admlevel9.GetField('NAME'))
# Set geometry as copy of source
outFeature.SetGeometry(geom)
#inFeature = None
outLayer.CreateFeature(outFeature)
outFeature = None
upFeature_admlevel1 = None
upFeature_admlevel2 = None
upFeature_admlevel3 = None
upFeature_admlevel4 = None
upFeature_admlevel5 = None
upFeature_admlevel6 = None
upFeature_admlevel7 = None
upFeature_admlevel8 = None
upFeature_admlevel9 = None
# Save and close DataSources
inDataSource = None
outDataSource = None
if destination is None:
shutil.move(
os.path.join(temp_destination_folder, 'boundary-polygon.shp'),
os.path.join(os.path.dirname(path), 'boundary-polygon.shp'))
shutil.move(
os.path.join(temp_destination_folder, 'boundary-polygon.shx'),
os.path.join(os.path.dirname(path), 'boundary-polygon.shx'))
shutil.move(
os.path.join(temp_destination_folder, 'boundary-polygon.cpg'),
os.path.join(os.path.dirname(path), 'boundary-polygon.cpg'))
shutil.move(
os.path.join(temp_destination_folder, 'boundary-polygon.dbf'),
os.path.join(os.path.dirname(path), 'boundary-polygon.dbf'))
shutil.move(
os.path.join(temp_destination_folder, 'boundary-polygon.prj'),
os.path.join(os.path.dirname(path), 'boundary-polygon.prj'))
shutil.rmtree(temp_destination_folder)
from osgeo import ogr
import os,math
driver = ogr.GetDriverByName("ESRI Shapefile")
extfile = 'rect_demo.shp'
if os.access( extfile, os.F_OK ):
driver.DeleteDataSource( extfile )
extent = [400, 1100, 300, 600]
newds = driver.CreateDataSource(extfile)
layernew = newds.CreateLayer('rect',None,ogr.wkbPolygon)
width = math.fabs(extent[1]-extent[0])
height = math.fabs(extent[3]-extent[2])
tw = width/2
th = width/2
extnew = extent[0]+tw
wkt = 'POLYGON ((%f %f,%f %f,%f %f,%f %f,%f %f))' % (extent[0],extent[3],
extent[1],extent[3], extent[1],extent[2],
extent[0],extent[2], extent[0],extent[3])
geom = ogr.CreateGeometryFromWkt(wkt)
feat = ogr.Feature(layernew.GetLayerDefn())
feat.SetGeometry(geom)
layernew.CreateFeature(feat)
newds.Destroy()
def test_point_snapping_multipoint(self):
"""DelineateIt: test multi-point snapping."""
from natcap.invest.delineateit import delineateit
srs = osr.SpatialReference()
srs.ImportFromEPSG(32731) # WGS84/UTM zone 31s
wkt = srs.ExportToWkt()
# need stream layer, points
stream_matrix = numpy.array(
[[0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1], [0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0]],
dtype=numpy.int8)
stream_raster_path = os.path.join(self.workspace_dir, 'streams.tif')
# byte datatype
pygeoprocessing.numpy_array_to_raster(stream_matrix, 255, (2, -2),
(2, -2), wkt, stream_raster_path)
source_points_path = os.path.join(self.workspace_dir,
'source_features.gpkg')
gpkg_driver = gdal.GetDriverByName('GPKG')
points_vector = gpkg_driver.Create(source_points_path, 0, 0, 0,
gdal.GDT_Unknown)
layer_name = os.path.splitext(os.path.basename(source_points_path))[0]
points_layer = points_vector.CreateLayer(layer_name,
points_vector.GetSpatialRef(),
ogr.wkbUnknown)
# Create a bunch of points for the various OGR multipoint types and
# make sure that they are all snapped to exactly the same place.
points_layer.StartTransaction()
for multipoint_type in (ogr.wkbMultiPoint, ogr.wkbMultiPointM,
ogr.wkbMultiPointZM, ogr.wkbMultiPoint25D):
new_feature = ogr.Feature(points_layer.GetLayerDefn())
new_geom = ogr.Geometry(multipoint_type)
component_point = ogr.Geometry(ogr.wkbPoint)
component_point.AddPoint(3, -5)
new_geom.AddGeometry(component_point)
new_feature.SetGeometry(new_geom)
points_layer.CreateFeature(new_feature)
# Verify point snapping will run if we give it empty multipoints.
for point_type in (ogr.wkbPoint, ogr.wkbMultiPoint):
new_feature = ogr.Feature(points_layer.GetLayerDefn())
new_geom = ogr.Geometry(point_type)
new_feature.SetGeometry(new_geom)
points_layer.CreateFeature(new_feature)
points_layer.CommitTransaction()
snapped_points_path = os.path.join(self.workspace_dir,
'snapped_points.gpkg')
snap_distance = 10 # large enough to get multiple streams per point.
delineateit.snap_points_to_nearest_stream(source_points_path,
(stream_raster_path, 1),
snap_distance,
snapped_points_path)
try:
snapped_points_vector = gdal.OpenEx(snapped_points_path,
gdal.OF_VECTOR)
snapped_points_layer = snapped_points_vector.GetLayer()
# All 4 multipoints should have been snapped to the same place and
# should all be Point geometries.
self.assertEqual(4, snapped_points_layer.GetFeatureCount())
expected_feature = shapely.geometry.Point(5, -5)
for feature in snapped_points_layer:
shapely_feature = shapely.wkb.loads(
feature.GetGeometryRef().ExportToWkb())
self.assertTrue(shapely_feature.equals(expected_feature))
finally:
snapped_points_layer = None
snapped_points_vector = None
in_dataset = sys.argv[i]
elif out_dataset is None:
out_dataset = sys.argv[i]
else:
Usage()
i+= 1
if out_dataset is None:
Usage()
ds = gdal.Open(in_dataset)
out_ds = ogr.GetDriverByName('ESRI Shapefile').CreateDataSource(out_dataset)
sr = None
wkt = ds.GetGCPProjection()
if wkt != '':
sr = osr.SpatialReference(wkt)
out_lyr = out_ds.CreateLayer('gcps', geom_type = ogr.wkbPoint, srs = sr)
out_lyr.CreateField(ogr.FieldDefn('Id', ogr.OFTString))
out_lyr.CreateField(ogr.FieldDefn('Info', ogr.OFTString))
out_lyr.CreateField(ogr.FieldDefn('X', ogr.OFTReal))
out_lyr.CreateField(ogr.FieldDefn('Y', ogr.OFTReal))
gcps = ds.GetGCPs()
for i in range(len(gcps)):
f = ogr.Feature(out_lyr.GetLayerDefn())
f.SetField('Id', gcps[i].Id)
f.SetField('Info', gcps[i].Info)
f.SetField('X', gcps[i].GCPPixel)
f.SetField('Y', gcps[i].GCPLine)
f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(%f %f)' % (gcps[i].GCPX, gcps[i].GCPY)))
out_lyr.CreateFeature(f)
def testSubsetStringFids(self):
"""
- tests that feature ids are stable even if a subset string is set
- tests that the subset string is correctly set on the ogr layer event when reloading the data source (issue #17122)
"""
tmpfile = os.path.join(self.basetestpath, 'subsetStringFids.sqlite')
ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test',
geom_type=ogr.wkbPoint,
options=['FID=fid'])
lyr.CreateField(ogr.FieldDefn('type', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('value', ogr.OFTInteger))
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(0)
f.SetField(0, 1)
f.SetField(1, 11)
f.SetGeometry(ogr.CreateGeometryFromWkt('Point (0 0)'))
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(1)
f.SetField(0, 1)
f.SetField(1, 12)
f.SetGeometry(ogr.CreateGeometryFromWkt('Point (1 1)'))
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(2)
f.SetField(0, 1)
f.SetField(1, 13)
f.SetGeometry(ogr.CreateGeometryFromWkt('Point (2 2)'))
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(3)
f.SetField(0, 2)
f.SetField(1, 14)
f.SetGeometry(ogr.CreateGeometryFromWkt('Point (3 3)'))
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(4)
f.SetField(0, 2)
f.SetField(1, 15)
f.SetGeometry(ogr.CreateGeometryFromWkt('Point (4 4)'))
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(5)
f.SetField(0, 2)
f.SetField(1, 16)
f.SetGeometry(ogr.CreateGeometryFromWkt('Point (5 5)'))
lyr.CreateFeature(f)
f = None
ds = None
vl = QgsVectorLayer(tmpfile, 'test', 'ogr')
self.assertTrue(vl.isValid())
self.assertEqual([f.name() for f in vl.fields()],
['fid', 'type', 'value'])
original_fields = vl.fields()
vl = QgsVectorLayer(tmpfile + "|subset=type=2", 'test', 'ogr')
self.assertTrue(vl.isValid())
def run_checks():
self.assertEqual([f.name() for f in vl.fields()],
['fid', 'type', 'value'])
# expression
req = QgsFeatureRequest()
req.setFilterExpression("value=16")
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter fid
req = QgsFeatureRequest()
req.setFilterFid(5)
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter fids
req = QgsFeatureRequest()
req.setFilterFids([5])
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# check with subset of attributes
req = QgsFeatureRequest()
req.setFilterFids([5])
req.setSubsetOfAttributes([2])
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes()[2], 16)
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter rect and expression
req = QgsFeatureRequest()
req.setFilterExpression("value=16 or value=14")
req.setFilterRect(QgsRectangle(4.5, 4.5, 5.5, 5.5))
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter rect and fids
req = QgsFeatureRequest()
req.setFilterFids([3, 5])
req.setFilterRect(QgsRectangle(4.5, 4.5, 5.5, 5.5))
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# Ensure that orig_ogc_fid is still retrieved even if attribute subset is passed
req = QgsFeatureRequest()
req.setSubsetOfAttributes([])
it = vl.getFeatures(req)
ids = []
geoms = {}
while it.nextFeature(f):
ids.append(f.id())
geoms[f.id()] = f.geometry().asWkt()
self.assertCountEqual(ids, [3, 4, 5])
self.assertEqual(geoms, {
3: 'Point (3 3)',
4: 'Point (4 4)',
5: 'Point (5 5)'
})
run_checks()
# Check that subset string is correctly set on reload
vl.reload()
run_checks()
def save_shapefile_from_polygons(polygons,
image_filepath,
output_shapefile_filepath,
properties_list=None):
"""
https://gis.stackexchange.com/a/52708/8104
"""
if properties_list is not None:
assert len(polygons) == len(
properties_list
), "polygons and properties_list should have the same length"
coor, gt, coor_system = get_coor_in_space(image_filepath)
transform_mat = compute_image_to_epsg_mat(coor, gt)
# Convert polygons to ogr_polygons
ogr_polygons = create_ogr_polygons(polygons, transform_mat)
driver = ogr.GetDriverByName('Esri Shapefile')
ds = driver.CreateDataSource(output_shapefile_filepath)
# create the spatial reference, WGS84
srs = osr.SpatialReference()
srs.ImportFromEPSG(4326)
layer = ds.CreateLayer('', None, ogr.wkbPolygon)
# Add one attribute
field_name_list = []
field_type_list = []
if properties_list is not None:
for properties in properties_list:
for (key, value) in properties.items():
if key not in field_name_list:
field_name_list.append(key)
field_type_list.append(type(value))
for (name, py_type) in zip(field_name_list, field_type_list):
if py_type == int:
ogr_type = ogr.OFTInteger
elif py_type == float:
print("is float")
ogr_type = ogr.OFTReal
elif py_type == str:
ogr_type = ogr.OFTString
else:
ogr_type = ogr.OFTInteger
layer.CreateField(ogr.FieldDefn(name, ogr_type))
defn = layer.GetLayerDefn()
for index in range(len(ogr_polygons)):
ogr_polygon = ogr_polygons[index]
if properties_list is not None:
properties = properties_list[index]
else:
properties = {}
# Create a new feature (attribute and geometry)
feat = ogr.Feature(defn)
for (key, value) in properties.items():
feat.SetField(key, value)
# Make a geometry, from Shapely object
geom = ogr.CreateGeometryFromWkt(ogr_polygon)
feat.SetGeometry(geom)
layer.CreateFeature(feat)
feat = geom = None # destroy these
# Save and close everything
ds = layer = feat = geom = None
def testSubsetStringFids(self):
"""
- tests that feature ids are stable even if a subset string is set
- tests that the subset string is correctly set on the ogr layer event when reloading the data source (issue #17122)
"""
tmpfile = os.path.join(self.basetestpath, 'subsetStringFids.sqlite')
ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test',
geom_type=ogr.wkbPoint,
options=['FID=fid'])
lyr.CreateField(ogr.FieldDefn('type', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('value', ogr.OFTInteger))
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(0)
f.SetField(0, 1)
f.SetField(1, 11)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(1)
f.SetField(0, 1)
f.SetField(1, 12)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(2)
f.SetField(0, 1)
f.SetField(1, 13)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(3)
f.SetField(0, 2)
f.SetField(1, 14)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(4)
f.SetField(0, 2)
f.SetField(1, 15)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(5)
f.SetField(0, 2)
f.SetField(1, 16)
lyr.CreateFeature(f)
f = None
ds = None
vl = QgsVectorLayer(tmpfile + "|subset=type=2", 'test', 'ogr')
self.assertTrue(vl.isValid())
self.assertTrue(vl.fields().at(vl.fields().count() -
1).name() == "orig_ogc_fid")
req = QgsFeatureRequest()
req.setFilterExpression("value=16")
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertTrue(f.id() == 5)
# Ensure that orig_ogc_fid is still retrieved even if attribute subset is passed
req = QgsFeatureRequest()
req.setSubsetOfAttributes([])
it = vl.getFeatures(req)
ids = []
while it.nextFeature(f):
ids.append(f.id())
self.assertTrue(len(ids) == 3)
self.assertTrue(3 in ids)
self.assertTrue(4 in ids)
self.assertTrue(5 in ids)
# Check that subset string is correctly set on reload
vl.reload()
self.assertTrue(vl.fields().at(vl.fields().count() -
1).name() == "orig_ogc_fid")
def ogr_rfc35_mitab_2():
ds = ogr.Open('/vsimem/rfc35_test.tab', update=1)
lyr = ds.GetLayer(0)
if lyr.TestCapability(ogr.OLCReorderFields) != 1:
gdaltest.post_reason('fail')
return 'fail'
feat = ogr.Feature(lyr.GetLayerDefn())
feat.SetField(0, 'foo3')
feat.SetField(1, 'bar3_01234')
feat.SetField(2, 'baz3_0123456789')
feat.SetField(3, 'baw3_012345678901234')
lyr.CreateFeature(feat)
feat = None
if lyr.ReorderField(1, 3) != 0:
gdaltest.post_reason('fail')
return 'fail'
# ds = None
# ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1)
# lyr = ds.GetLayer(0)
ret = Check(lyr, ['foo5', 'baz15', 'baw20', 'bar10'])
if ret != 'success':
gdaltest.post_reason(ret)
return ret
lyr.ReorderField(3, 1)
# ds = None
# ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1)
# lyr = ds.GetLayer(0)
ret = Check(lyr, ['foo5', 'bar10', 'baz15', 'baw20'])
if ret != 'success':
gdaltest.post_reason(ret)
return ret
lyr.ReorderField(0, 2)
# ds = None
# ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1)
# lyr = ds.GetLayer(0)
ret = Check(lyr, ['bar10', 'baz15', 'foo5', 'baw20'])
if ret != 'success':
gdaltest.post_reason(ret)
return ret
lyr.ReorderField(2, 0)
# ds = None
# ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1)
# lyr = ds.GetLayer(0)
ret = Check(lyr, ['foo5', 'bar10', 'baz15', 'baw20'])
if ret != 'success':
gdaltest.post_reason(ret)
return ret
lyr.ReorderField(0, 1)
# ds = None
# ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1)
# lyr = ds.GetLayer(0)
ret = Check(lyr, ['bar10', 'foo5', 'baz15', 'baw20'])
if ret != 'success':
gdaltest.post_reason(ret)
return ret
lyr.ReorderField(1, 0)
# ds = None
# ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1)
# lyr = ds.GetLayer(0)
ret = Check(lyr, ['foo5', 'bar10', 'baz15', 'baw20'])
if ret != 'success':
gdaltest.post_reason(ret)
return ret
lyr.ReorderFields([3, 2, 1, 0])
# ds = None
# ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1)
# lyr = ds.GetLayer(0)
ret = Check(lyr, ['baw20', 'baz15', 'bar10', 'foo5'])
if ret != 'success':
gdaltest.post_reason(ret)
return ret
lyr.ReorderFields([3, 2, 1, 0])
# ds = None
# ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1)
# lyr = ds.GetLayer(0)
ret = Check(lyr, ['foo5', 'bar10', 'baz15', 'baw20'])
if ret != 'success':
gdaltest.post_reason(ret)
return ret
gdal.PushErrorHandler('CPLQuietErrorHandler')
ret = lyr.ReorderFields([0, 0, 0, 0])
gdal.PopErrorHandler()
if ret == 0:
gdaltest.post_reason('fail')
return 'fail'
# ds = None
# ds = ogr.Open('/vsimem/rfc35_test.tab', update = 1)
lyr = ds.GetLayer(0)
ret = CheckColumnOrder(lyr, ['foo5', 'bar10', 'baz15', 'baw20'])
if ret != 'success':
gdaltest.post_reason(ret)
return ret
ret = CheckFeatures(lyr)
if ret != 'success':
gdaltest.post_reason(ret)
return ret
return 'success'
def _write_summary_vector(source_aoi_vector_path,
target_vector_path,
runoff_ret_stats,
runoff_ret_vol_stats,
flood_volume_stats,
damage_per_aoi_stats=None):
"""Write a vector with summary statistics.
This vector will always contain two fields::
* ``'flood_vol'``: The volume of flood (runoff), in m3, per watershed.
* ``'rnf_rt_idx'``: Average of runoff retention values per watershed
* ``'rnf_rt_m3'``: Sum of runoff retention volumes, in m3,
per watershed.
If ``damage_per_aoi_stats`` is provided, then these additional columns will
be written to the vector::
* ``'aff_bld'``: Potential damage to built infrastructure in $,
per watershed.
* ``'serv_blt'``: Spatial indicator of the importance of the runoff
retention service
Args:
source_aoi_vector_path (str): The path to a GDAL vector that exists on
disk.
target_vector_path (str): The path to a vector that will be
created. If a file already exists at this path, it will be deleted
before the new file is created. This filepath must end with the
extension ``.shp``, as the file created will be an ESRI Shapefile.
runoff_ret_stats (dict): A dict representing summary statistics of the
runoff raster. If provided, it must be a dictionary mapping feature
IDs from ``source_aoi_vector_path`` to dicts with ``'count'`` and
``'sum'`` keys.
runoff_ret_vol_stats (dict): A dict representing summary statistics of
the runoff volume raster. If provided, it must be a dictionary
mapping feature IDs from ``source_aoi_vector_path`` to dicts with
``'count'`` and ``'sum'`` keys.
flood_volume_stats(dict): A dict mapping feature IDs from
``source_aoi_vector_path`` to float values representing the flood
volume over the AOI.
damage_per_aoi_stats (dict): A dict mapping feature IDs from
``source_aoi_vector_path`` to float values representing the total
damage to built infrastructure in that watershed.
Returns:
``None``
"""
source_aoi_vector = gdal.OpenEx(source_aoi_vector_path, gdal.OF_VECTOR)
source_aoi_layer = source_aoi_vector.GetLayer()
source_geom_type = source_aoi_layer.GetGeomType()
source_srs_wkt = pygeoprocessing.get_vector_info(
source_aoi_vector_path)['projection_wkt']
source_srs = osr.SpatialReference()
source_srs.ImportFromWkt(source_srs_wkt)
esri_driver = gdal.GetDriverByName('ESRI Shapefile')
target_watershed_vector = esri_driver.Create(target_vector_path, 0, 0, 0,
gdal.GDT_Unknown)
layer_name = os.path.splitext(os.path.basename(target_vector_path))[0]
LOGGER.debug("creating layer %s", layer_name)
target_watershed_layer = target_watershed_vector.CreateLayer(
layer_name, source_srs, source_geom_type)
target_fields = ['rnf_rt_idx', 'rnf_rt_m3', 'flood_vol']
if not damage_per_aoi_stats:
damage_per_aoi_stats = {}
else:
target_fields += ['aff_bld', 'serv_blt']
for field_name in target_fields:
field_def = ogr.FieldDefn(field_name, ogr.OFTReal)
field_def.SetWidth(36)
field_def.SetPrecision(11)
target_watershed_layer.CreateField(field_def)
target_layer_defn = target_watershed_layer.GetLayerDefn()
for base_feature in source_aoi_layer:
feature_id = base_feature.GetFID()
target_feature = ogr.Feature(target_layer_defn)
base_geom_ref = base_feature.GetGeometryRef()
target_feature.SetGeometry(base_geom_ref.Clone())
base_geom_ref = None
if feature_id in runoff_ret_stats:
pixel_count = runoff_ret_stats[feature_id]['count']
if pixel_count > 0:
mean_value = (runoff_ret_stats[feature_id]['sum'] /
float(pixel_count))
target_feature.SetField('rnf_rt_idx', float(mean_value))
if feature_id in runoff_ret_vol_stats:
target_feature.SetField(
'rnf_rt_m3', float(runoff_ret_vol_stats[feature_id]['sum']))
if feature_id in damage_per_aoi_stats:
pixel_count = runoff_ret_vol_stats[feature_id]['count']
if pixel_count > 0:
damage_sum = damage_per_aoi_stats[feature_id]
target_feature.SetField('aff_bld', damage_sum)
# This is the service_built equation.
target_feature.SetField(
'serv_blt',
(damage_sum * runoff_ret_vol_stats[feature_id]['sum']))
if feature_id in flood_volume_stats:
target_feature.SetField(
'flood_vol', float(flood_volume_stats[feature_id]['sum']))
target_watershed_layer.CreateFeature(target_feature)
target_watershed_layer.SyncToDisk()
target_watershed_layer = None
target_watershed_vector = None
def testGeopackageTwoLayerEdition(self):
''' test https://issues.qgis.org/issues/17034 '''
tmpfile = os.path.join(self.basetestpath,
'testGeopackageTwoLayerEdition.gpkg')
ds = ogr.GetDriverByName('GPKG').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('layer1', geom_type=ogr.wkbPoint)
lyr.CreateField(ogr.FieldDefn('attr', ogr.OFTInteger))
f = ogr.Feature(lyr.GetLayerDefn())
f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(0 0)'))
lyr.CreateFeature(f)
f = None
lyr = ds.CreateLayer('layer2', geom_type=ogr.wkbPoint)
lyr.CreateField(ogr.FieldDefn('attr', ogr.OFTInteger))
f = ogr.Feature(lyr.GetLayerDefn())
f.SetGeometry(ogr.CreateGeometryFromWkt('POINT(1 1)'))
lyr.CreateFeature(f)
f = None
ds = None
vl1 = QgsVectorLayer(u'{}'.format(tmpfile) + "|layername=layer1",
u'layer1', u'ogr')
vl2 = QgsVectorLayer(u'{}'.format(tmpfile) + "|layername=layer2",
u'layer2', u'ogr')
# Edit vl1, vl2 multiple times
self.assertTrue(vl1.startEditing())
self.assertTrue(vl2.startEditing())
self.assertTrue(
vl1.changeGeometry(1, QgsGeometry.fromWkt('Point (2 2)')))
self.assertTrue(
vl2.changeGeometry(1, QgsGeometry.fromWkt('Point (3 3)')))
self.assertTrue(vl1.commitChanges())
self.assertTrue(vl2.commitChanges())
self.assertTrue(vl1.startEditing())
self.assertTrue(vl2.startEditing())
self.assertTrue(vl1.changeAttributeValue(1, 1, 100))
self.assertTrue(vl2.changeAttributeValue(1, 1, 101))
self.assertTrue(vl1.commitChanges())
self.assertTrue(vl2.commitChanges())
self.assertTrue(vl1.startEditing())
self.assertTrue(vl2.startEditing())
self.assertTrue(
vl1.changeGeometry(1, QgsGeometry.fromWkt('Point (4 4)')))
self.assertTrue(
vl2.changeGeometry(1, QgsGeometry.fromWkt('Point (5 5)')))
self.assertTrue(vl1.commitChanges())
self.assertTrue(vl2.commitChanges())
vl1 = None
vl2 = None
# Check everything is as expected after re-opening
vl1 = QgsVectorLayer(u'{}'.format(tmpfile) + "|layername=layer1",
u'layer1', u'ogr')
vl2 = QgsVectorLayer(u'{}'.format(tmpfile) + "|layername=layer2",
u'layer2', u'ogr')
got = [feat for feat in vl1.getFeatures()][0]
got_geom = got.geometry()
self.assertEqual(got['attr'], 100)
reference = QgsGeometry.fromWkt('Point (4 4)')
self.assertEqual(
got_geom.asWkb(), reference.asWkb(),
'Expected {}, got {}'.format(reference.asWkt(), got_geom.asWkt()))
got = [feat for feat in vl2.getFeatures()][0]
got_geom = got.geometry()
self.assertEqual(got['attr'], 101)
reference = QgsGeometry.fromWkt('Point (5 5)')
self.assertEqual(
got_geom.asWkb(), reference.asWkb(),
'Expected {}, got {}'.format(reference.asWkt(), got_geom.asWkt()))
