def test_create_layer(self):
"""Test create layer work"""
# Lines
line_layer = QgsVectorLayer(
self.line_before + '.shp', 'test', 'ogr')
new_layer = create_layer(line_layer)
self.assertEquals(new_layer.geometryType(), line_layer.geometryType())
self.assertEquals(new_layer.crs(), line_layer.crs())
fields = line_layer.dataProvider().fields()
new_fields = new_layer.dataProvider().fields()
self.assertEquals(new_fields.toList(), fields.toList())
# Polygon
polygon_layer = QgsVectorLayer(
self.polygon_base + '.shp', 'test', 'ogr')
new_layer = create_layer(polygon_layer)
self.assertEquals(
new_layer.geometryType(),
polygon_layer.geometryType()
)
self.assertEquals(new_layer.crs(), polygon_layer.crs())
fields = polygon_layer.dataProvider().fields()
new_fields = new_layer.dataProvider().fields()
self.assertEquals(new_fields.toList(), fields.toList())
def test_create_layer(self):
"""Test create layer work"""
# Lines
line_layer = QgsVectorLayer(
self.line_before + '.shp', 'test', 'ogr')
new_layer = create_layer(line_layer)
self.assertEquals(new_layer.geometryType(), line_layer.geometryType())
self.assertEquals(new_layer.crs(), line_layer.crs())
fields = line_layer.dataProvider().fields()
new_fields = new_layer.dataProvider().fields()
self.assertEquals(new_fields.toList(), fields.toList())
# Polygon
polygon_layer = QgsVectorLayer(
self.polygon_base + '.shp', 'test', 'ogr')
new_layer = create_layer(polygon_layer)
self.assertEquals(
new_layer.geometryType(),
polygon_layer.geometryType()
)
self.assertEquals(new_layer.crs(), polygon_layer.crs())
fields = polygon_layer.dataProvider().fields()
new_fields = new_layer.dataProvider().fields()
self.assertEquals(new_fields.toList(), fields.toList())
def test_interpolation_from_polygons_one_poly(self):
"""Point interpolation using one polygon from Maumere works
There's a test with the same name in test_engine.py not using QGIS API.
This one deals correctly with holes in polygons,
so the resulting numbers are a bit different.
"""
# Name file names for hazard level and exposure
hazard_filename = ('%s/tsunami_polygon_WGS84.shp' % TESTDATA)
exposure_filename = ('%s/building_Maumere.shp' % TESTDATA)
# Read input data
H_all = QgsVectorLayer(hazard_filename, 'Hazard', 'ogr')
# Cut down to make test quick
# Polygon #799 is the one used in separate test
H = create_layer(H_all)
polygon799 = H_all.getFeatures(QgsFeatureRequest(799)).next()
H.dataProvider().addFeatures([polygon799])
E = QgsVectorLayer(exposure_filename, 'Exposure', 'ogr')
# Test interpolation function
I = interpolate_polygon_polygon(H, E, E.extent())
N = I.dataProvider().featureCount()
assert N == I.dataProvider().featureCount()
# Assert that expected attribute names exist
I_names = [field.name() for field in I.dataProvider().fields()]
for field in H.dataProvider().fields():
name = field.name()
msg = 'Did not find hazard name "%s" in %s' % (name, I_names)
assert name in I_names, msg
for field in E.dataProvider().fields():
name = field.name()
msg = 'Did not find exposure name "%s" in %s' % (name, I_names)
assert name in I_names, msg
# Verify interpolated values with test result
count = 0
for f in I.getFeatures():
category = f['Category']
if category is not None:
count += 1
msg = ('Expected 453 points tagged with category, '
'but got only %i' % count)
assert count == 453, msg
def test_raster_to_vector_and_line_intersection(self):
"""Test the core part of the analysis.
1. Test creation of spatial index of flood cells
2. Test intersection of flood cells with roads layer
"""
raster_name = standard_data_path(
'hazard',
'tsunami_wgs84.tif')
exposure_name = standard_data_path(
'exposure',
'roads_osm_4326.shp')
raster = QgsRasterLayer(raster_name, 'Flood')
exposure = QgsVectorLayer(exposure_name, 'Exposure', 'ogr')
ranges = OrderedDict()
ranges[0] = [0, 1]
ranges[1] = [1, 2]
ranges[2] = [2, 100]
index, flood_cells_map = _raster_to_vector_cells(
raster, ranges, exposure.crs())
self.assertEqual(len(flood_cells_map), 4198)
rect_with_all_cells = raster.extent()
rect_with_4_cells = QgsRectangle(106.824, -6.177, 106.825, -6.179)
rect_with_0_cells = QgsRectangle(106.818, -6.168, 106.828, -6.175)
self.assertEqual(len(index.intersects(rect_with_all_cells)), 4198)
self.assertEqual(len(index.intersects(rect_with_4_cells)), 43)
self.assertEqual(len(index.intersects(rect_with_0_cells)), 504)
layer = create_layer(exposure)
new_field = QgsField('flooded', QVariant.Int)
layer.dataProvider().addAttributes([new_field])
request = QgsFeatureRequest()
_intersect_lines_with_vector_cells(
exposure, request, index, flood_cells_map, layer, 'flooded')
feature_count = layer.featureCount()
self.assertEqual(feature_count, 388)
flooded = 0
iterator = layer.getFeatures()
for feature in iterator:
attributes = feature.attributes()
if attributes[3] == 1:
flooded += 1
self.assertEqual(flooded, 40)
def test_raster_to_vector_and_line_intersection(self):
"""Test the core part of the analysis.
1. Test creation of spatial index of flood cells
2. Test intersection of flood cells with roads layer
"""
raster_name = test_data_path('hazard', 'tsunami_wgs84.tif')
exposure_name = test_data_path('exposure', 'roads_osm_4326.shp')
raster = QgsRasterLayer(raster_name, 'Flood')
exposure = QgsVectorLayer(exposure_name, 'Exposure', 'ogr')
ranges = OrderedDict()
ranges[0] = [0, 1]
ranges[1] = [1, 2]
ranges[2] = [2, 100]
index, flood_cells_map = _raster_to_vector_cells(
raster, ranges, exposure.crs())
self.assertEqual(len(flood_cells_map), 4198)
rect_with_all_cells = raster.extent()
rect_with_4_cells = QgsRectangle(106.824, -6.177, 106.825, -6.179)
rect_with_0_cells = QgsRectangle(106.818, -6.168, 106.828, -6.175)
self.assertEqual(len(index.intersects(rect_with_all_cells)), 4198)
self.assertEqual(len(index.intersects(rect_with_4_cells)), 43)
self.assertEqual(len(index.intersects(rect_with_0_cells)), 504)
layer = create_layer(exposure)
new_field = QgsField('flooded', QVariant.Int)
layer.dataProvider().addAttributes([new_field])
request = QgsFeatureRequest()
_intersect_lines_with_vector_cells(exposure, request, index,
flood_cells_map, layer, 'flooded')
feature_count = layer.featureCount()
self.assertEqual(feature_count, 388)
flooded = 0
iterator = layer.getFeatures()
for feature in iterator:
attributes = feature.attributes()
if attributes[3] == 1:
flooded += 1
self.assertEqual(flooded, 40)
def test_raster_to_vector_and_line_intersection(self):
"""Test the core part of the analysis.
1. Test creation of spatial index of flood cells
2. Test intersection of flood cells with roads layer
"""
raster_name = standard_data_path('hazard', 'jakarta_flood_design.tif')
exposure_name = standard_data_path('exposure', 'roads_osm_4326.shp')
raster = QgsRasterLayer(raster_name, 'Flood')
exposure = QgsVectorLayer(exposure_name, 'Exposure', 'ogr')
index, flood_cells_map = _raster_to_vector_cells(
raster, 0.1, 1e10, exposure.crs())
self.assertEqual(len(flood_cells_map), 221)
rect_with_all_cells = raster.extent()
rect_with_4_cells = QgsRectangle(106.824, -6.177, 106.825, -6.179)
rect_with_0_cells = QgsRectangle(106.818, -6.168, 106.828, -6.175)
self.assertEqual(len(index.intersects(rect_with_all_cells)), 221)
self.assertEqual(len(index.intersects(rect_with_4_cells)), 4)
self.assertEqual(len(index.intersects(rect_with_0_cells)), 0)
layer = create_layer(exposure)
new_field = QgsField('flooded', QVariant.Int)
layer.dataProvider().addAttributes([new_field])
request = QgsFeatureRequest()
_intersect_lines_with_vector_cells(exposure, request, index,
flood_cells_map, layer, 'flooded')
feature_count = layer.featureCount()
self.assertEqual(feature_count, 184)
flooded = 0
iterator = layer.getFeatures()
for feature in iterator:
attributes = feature.attributes()
if attributes[3] == 1:
flooded += 1
self.assertEqual(flooded, 25)
def run(self):
"""Run the impact function.
:returns: A new line layer with inundated roads marked.
:type: safe_layer
"""
self.validate()
self.prepare()
target_field = self.target_field
# Get parameters from layer's keywords
road_class_field = self.exposure.keyword('road_class_field')
# Get parameters from IF parameter
threshold_min = self.parameters['min threshold'].value
threshold_max = self.parameters['max threshold'].value
if threshold_min > threshold_max:
message = tr(
'The minimal threshold is greater than the maximal specified '
'threshold. Please check the values.')
raise GetDataError(message)
# reproject self.extent to the hazard projection
hazard_crs = self.hazard.layer.crs()
hazard_authid = hazard_crs.authid()
if hazard_authid == 'EPSG:4326':
viewport_extent = self.requested_extent
else:
geo_crs = QgsCoordinateReferenceSystem()
geo_crs.createFromSrid(4326)
viewport_extent = extent_to_geo_array(
QgsRectangle(*self.requested_extent), geo_crs, hazard_crs)
# Align raster extent and viewport
# assuming they are both in the same projection
raster_extent = self.hazard.layer.dataProvider().extent()
clip_xmin = raster_extent.xMinimum()
# clip_xmax = raster_extent.xMaximum()
clip_ymin = raster_extent.yMinimum()
# clip_ymax = raster_extent.yMaximum()
if viewport_extent[0] > clip_xmin:
clip_xmin = viewport_extent[0]
if viewport_extent[1] > clip_ymin:
clip_ymin = viewport_extent[1]
# TODO: Why have these two clauses when they are not used?
# Commenting out for now.
# if viewport_extent[2] < clip_xmax:
# clip_xmax = viewport_extent[2]
# if viewport_extent[3] < clip_ymax:
# clip_ymax = viewport_extent[3]
height = ((viewport_extent[3] - viewport_extent[1]) /
self.hazard.layer.rasterUnitsPerPixelY())
height = int(height)
width = ((viewport_extent[2] - viewport_extent[0]) /
self.hazard.layer.rasterUnitsPerPixelX())
width = int(width)
raster_extent = self.hazard.layer.dataProvider().extent()
xmin = raster_extent.xMinimum()
xmax = raster_extent.xMaximum()
ymin = raster_extent.yMinimum()
ymax = raster_extent.yMaximum()
x_delta = (xmax - xmin) / self.hazard.layer.width()
x = xmin
for i in range(self.hazard.layer.width()):
if abs(x - clip_xmin) < x_delta:
# We have found the aligned raster boundary
break
x += x_delta
_ = i
y_delta = (ymax - ymin) / self.hazard.layer.height()
y = ymin
for i in range(self.hazard.layer.width()):
if abs(y - clip_ymin) < y_delta:
# We have found the aligned raster boundary
break
y += y_delta
clip_extent = [x, y, x + width * x_delta, y + height * y_delta]
# Clip hazard raster
small_raster = clip_raster(self.hazard.layer, width, height,
QgsRectangle(*clip_extent))
# Create vector features from the flood raster
# For each raster cell there is one rectangular polygon
# Data also get spatially indexed for faster operation
index, flood_cells_map = _raster_to_vector_cells(
small_raster, threshold_min, threshold_max,
self.exposure.layer.crs())
# Filter geometry and data using the extent
ct = QgsCoordinateTransform(QgsCoordinateReferenceSystem("EPSG:4326"),
self.exposure.layer.crs())
extent = ct.transformBoundingBox(QgsRectangle(*self.requested_extent))
request = QgsFeatureRequest()
request.setFilterRect(extent)
if len(flood_cells_map) == 0:
message = tr(
'There are no objects in the hazard layer with "value" > %s. '
'Please check the value or use other extent.' %
(threshold_min, ))
raise GetDataError(message)
# create template for the output layer
line_layer_tmp = create_layer(self.exposure.layer)
new_field = QgsField(target_field, QVariant.Int)
line_layer_tmp.dataProvider().addAttributes([new_field])
line_layer_tmp.updateFields()
# create empty output layer and load it
filename = unique_filename(suffix='.shp')
QgsVectorFileWriter.writeAsVectorFormat(line_layer_tmp, filename,
"utf-8", None,
"ESRI Shapefile")
line_layer = QgsVectorLayer(filename, "flooded roads", "ogr")
# Do the heavy work - for each road get flood polygon for that area and
# do the intersection/difference to find out which parts are flooded
_intersect_lines_with_vector_cells(self.exposure.layer, request, index,
flood_cells_map, line_layer,
target_field)
target_field_index = line_layer.dataProvider().\
fieldNameIndex(target_field)
# Generate simple impact report
epsg = get_utm_epsg(self.requested_extent[0], self.requested_extent[1])
output_crs = QgsCoordinateReferenceSystem(epsg)
transform = QgsCoordinateTransform(self.exposure.layer.crs(),
output_crs)
flooded_keyword = tr('Flooded in the threshold (m)')
self.affected_road_categories = [flooded_keyword]
self.affected_road_lengths = OrderedDict([(flooded_keyword, {})])
self.road_lengths = OrderedDict()
if line_layer.featureCount() < 1:
raise ZeroImpactException()
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_class_field)
for road in roads_data:
attributes = road.attributes()
road_type = attributes[road_type_field_index]
if road_type.__class__.__name__ == 'QPyNullVariant':
road_type = tr('Other')
geom = road.geometry()
geom.transform(transform)
length = geom.length()
if road_type not in self.road_lengths:
self.affected_road_lengths[flooded_keyword][road_type] = 0
self.road_lengths[road_type] = 0
self.road_lengths[road_type] += length
if attributes[target_field_index] == 1:
self.affected_road_lengths[flooded_keyword][
road_type] += length
impact_summary = self.html_report()
# For printing map purpose
map_title = tr('Roads inundated')
legend_title = tr('Road inundated status')
style_classes = [
dict(label=tr('Not Inundated'),
value=0,
colour='#1EFC7C',
transparency=0,
size=0.5),
dict(label=tr('Inundated'),
value=1,
colour='#F31A1C',
transparency=0,
size=0.5)
]
style_info = dict(target_field=target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
# Convert QgsVectorLayer to inasafe layer and return it
line_layer = Vector(data=line_layer,
name=tr('Flooded roads'),
keywords={
'impact_summary': impact_summary,
'map_title': map_title,
'legend_title': legend_title,
'target_field': target_field
},
style_info=style_info)
self._impact = line_layer
return line_layer
def run(self):
"""Run the impact function.
:returns: A new line layer with inundated roads marked.
:type: safe_layer
"""
target_field = self.target_field
# Get parameters from layer's keywords
road_class_field = self.exposure.keyword('road_class_field')
exposure_value_mapping = self.exposure.keyword('value_mapping')
# Get parameters from IF parameter
threshold_min = self.parameters['min threshold'].value
threshold_max = self.parameters['max threshold'].value
if threshold_min > threshold_max:
message = tr(
'The minimal threshold is greater than the maximal specified '
'threshold. Please check the values.')
raise GetDataError(message)
# reproject self.extent to the hazard projection
hazard_crs = self.hazard.layer.crs()
hazard_authid = hazard_crs.authid()
if hazard_authid == 'EPSG:4326':
viewport_extent = self.requested_extent
else:
geo_crs = QgsCoordinateReferenceSystem()
geo_crs.createFromSrid(4326)
viewport_extent = extent_to_geo_array(
QgsRectangle(*self.requested_extent), geo_crs, hazard_crs)
# Clip hazard raster
small_raster = align_clip_raster(self.hazard.layer, viewport_extent)
# Filter geometry and data using the extent
ct = QgsCoordinateTransform(
QgsCoordinateReferenceSystem("EPSG:4326"),
self.exposure.layer.crs())
extent = ct.transformBoundingBox(QgsRectangle(*self.requested_extent))
request = QgsFeatureRequest()
request.setFilterRect(extent)
# create template for the output layer
line_layer_tmp = create_layer(self.exposure.layer)
new_field = QgsField(target_field, QVariant.Int)
line_layer_tmp.dataProvider().addAttributes([new_field])
line_layer_tmp.updateFields()
# create empty output layer and load it
filename = unique_filename(suffix='.shp')
QgsVectorFileWriter.writeAsVectorFormat(
line_layer_tmp, filename, "utf-8", None, "ESRI Shapefile")
line_layer = QgsVectorLayer(filename, "flooded roads", "ogr")
# Create vector features from the flood raster
# For each raster cell there is one rectangular polygon
# Data also get spatially indexed for faster operation
index, flood_cells_map = _raster_to_vector_cells(
small_raster,
threshold_min,
threshold_max,
self.exposure.layer.crs())
if len(flood_cells_map) == 0:
message = tr(
'There are no objects in the hazard layer with "value" > %s. '
'Please check the value or use other extent.' % (
threshold_min, ))
raise GetDataError(message)
# Do the heavy work - for each road get flood polygon for that area and
# do the intersection/difference to find out which parts are flooded
_intersect_lines_with_vector_cells(
self.exposure.layer,
request,
index,
flood_cells_map,
line_layer,
target_field)
target_field_index = line_layer.dataProvider().\
fieldNameIndex(target_field)
# Generate simple impact report
epsg = get_utm_epsg(self.requested_extent[0], self.requested_extent[1])
output_crs = QgsCoordinateReferenceSystem(epsg)
transform = QgsCoordinateTransform(
self.exposure.layer.crs(), output_crs)
classes = [tr('Flooded in the threshold (m)')]
self.init_report_var(classes)
if line_layer.featureCount() < 1:
raise ZeroImpactException()
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_class_field)
for road in roads_data:
attributes = road.attributes()
usage = attributes[road_type_field_index]
usage = main_type(usage, exposure_value_mapping)
geom = road.geometry()
geom.transform(transform)
length = geom.length()
affected = False
if attributes[target_field_index] == 1:
affected = True
self.classify_feature(classes[0], usage, length, affected)
self.reorder_dictionaries()
style_classes = [
dict(
label=tr('Not Inundated'), value=0,
colour='#1EFC7C', transparency=0, size=0.5),
dict(
label=tr('Inundated'), value=1,
colour='#F31A1C', transparency=0, size=0.5)]
style_info = dict(
target_field=target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
impact_data = self.generate_data()
extra_keywords = {
'map_title': self.metadata().key('map_title'),
'legend_title': self.metadata().key('legend_title'),
'target_field': target_field
}
impact_layer_keywords = self.generate_impact_keywords(extra_keywords)
# Convert QgsVectorLayer to inasafe layer and return it
impact_layer = Vector(
data=line_layer,
name=self.metadata().key('layer_name'),
keywords=impact_layer_keywords,
style_info=style_info)
impact_layer.impact_data = impact_data
self._impact = impact_layer
return impact_layer
def run(self):
"""Run the impact function.
:returns: A new line layer with inundated roads marked.
:type: safe_layer
"""
self.validate()
self.prepare()
self.provenance.append_step(
'Calculating Step', 'Impact function is calculating the impact.')
# Thresholds for tsunami hazard zone breakdown.
low_max = self.parameters['low_threshold'].value
medium_max = self.parameters['medium_threshold'].value
high_max = self.parameters['high_threshold'].value
target_field = self.target_field
# Get parameters from layer's keywords
road_class_field = self.exposure.keyword('road_class_field')
# reproject self.extent to the hazard projection
hazard_crs = self.hazard.layer.crs()
hazard_authid = hazard_crs.authid()
if hazard_authid == 'EPSG:4326':
viewport_extent = self.requested_extent
else:
geo_crs = QgsCoordinateReferenceSystem()
geo_crs.createFromSrid(4326)
viewport_extent = extent_to_geo_array(
QgsRectangle(*self.requested_extent), geo_crs, hazard_crs)
# Align raster extent and viewport
# assuming they are both in the same projection
raster_extent = self.hazard.layer.dataProvider().extent()
clip_xmin = raster_extent.xMinimum()
# clip_xmax = raster_extent.xMaximum()
clip_ymin = raster_extent.yMinimum()
# clip_ymax = raster_extent.yMaximum()
if viewport_extent[0] > clip_xmin:
clip_xmin = viewport_extent[0]
if viewport_extent[1] > clip_ymin:
clip_ymin = viewport_extent[1]
height = ((viewport_extent[3] - viewport_extent[1]) /
self.hazard.layer.rasterUnitsPerPixelY())
height = int(height)
width = ((viewport_extent[2] - viewport_extent[0]) /
self.hazard.layer.rasterUnitsPerPixelX())
width = int(width)
raster_extent = self.hazard.layer.dataProvider().extent()
xmin = raster_extent.xMinimum()
xmax = raster_extent.xMaximum()
ymin = raster_extent.yMinimum()
ymax = raster_extent.yMaximum()
x_delta = (xmax - xmin) / self.hazard.layer.width()
x = xmin
for i in range(self.hazard.layer.width()):
if abs(x - clip_xmin) < x_delta:
# We have found the aligned raster boundary
break
x += x_delta
_ = i
y_delta = (ymax - ymin) / self.hazard.layer.height()
y = ymin
for i in range(self.hazard.layer.width()):
if abs(y - clip_ymin) < y_delta:
# We have found the aligned raster boundary
break
y += y_delta
clip_extent = [x, y, x + width * x_delta, y + height * y_delta]
# Clip hazard raster
small_raster = clip_raster(self.hazard.layer, width, height,
QgsRectangle(*clip_extent))
# Create vector features from the flood raster
# For each raster cell there is one rectangular polygon
# Data also get spatially indexed for faster operation
ranges = OrderedDict()
ranges[0] = [0.0, 0.0]
ranges[1] = [0.0, low_max]
ranges[2] = [low_max, medium_max]
ranges[3] = [medium_max, high_max]
ranges[4] = [high_max, None]
index, flood_cells_map = _raster_to_vector_cells(
small_raster, ranges, self.exposure.layer.crs())
# Filter geometry and data using the extent
ct = QgsCoordinateTransform(QgsCoordinateReferenceSystem("EPSG:4326"),
self.exposure.layer.crs())
extent = ct.transformBoundingBox(QgsRectangle(*self.requested_extent))
request = QgsFeatureRequest()
request.setFilterRect(extent)
"""
if len(low_max_flood_cells_map) == 0 and \
len(medium_max_flood_cells_map) == 0 and \
len(high_max_flood_cells_map) == 0 and \
len(high_min_flood_cells_map) == 0:
message = tr(
'There are no objects in the hazard layer with "value" > 0. '
'Please check the value or use other extent.' % (
threshold_min, ))
raise GetDataError(message)
"""
# create template for the output layer
line_layer_tmp = create_layer(self.exposure.layer)
new_field = QgsField(target_field, QVariant.Int)
line_layer_tmp.dataProvider().addAttributes([new_field])
line_layer_tmp.updateFields()
# create empty output layer and load it
filename = unique_filename(suffix='.shp')
QgsVectorFileWriter.writeAsVectorFormat(line_layer_tmp, filename,
"utf-8", None,
"ESRI Shapefile")
line_layer = QgsVectorLayer(filename, "flooded roads", "ogr")
# Do the heavy work - for each road get flood polygon for that area and
# do the intersection/difference to find out which parts are flooded
_intersect_lines_with_vector_cells(self.exposure.layer, request, index,
flood_cells_map, line_layer,
target_field)
target_field_index = line_layer.dataProvider().\
fieldNameIndex(target_field)
# Generate simple impact report
epsg = get_utm_epsg(self.requested_extent[0], self.requested_extent[1])
output_crs = QgsCoordinateReferenceSystem(epsg)
transform = QgsCoordinateTransform(self.exposure.layer.crs(),
output_crs)
# Roads breakdown
self.road_lengths = OrderedDict()
self.affected_road_categories = self.hazard_classes
# Impacted roads breakdown
self.affected_road_lengths = OrderedDict([
(self.hazard_classes[0], {}),
(self.hazard_classes[1], {}),
(self.hazard_classes[2], {}),
(self.hazard_classes[3], {}),
(self.hazard_classes[4], {}),
])
if line_layer.featureCount() < 1:
raise ZeroImpactException()
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_class_field)
for road in roads_data:
attributes = road.attributes()
affected = attributes[target_field_index]
hazard_zone = self.hazard_classes[affected]
road_type = attributes[road_type_field_index]
if road_type.__class__.__name__ == 'QPyNullVariant':
road_type = tr('Other')
geom = road.geometry()
geom.transform(transform)
length = geom.length()
if road_type not in self.road_lengths:
self.road_lengths[road_type] = 0
if hazard_zone not in self.affected_road_lengths:
self.affected_road_lengths[hazard_zone] = {}
if road_type not in self.affected_road_lengths[hazard_zone]:
self.affected_road_lengths[hazard_zone][road_type] = 0
self.road_lengths[road_type] += length
num_classes = len(self.hazard_classes)
if attributes[target_field_index] in range(num_classes):
self.affected_road_lengths[hazard_zone][road_type] += length
impact_summary = self.html_report()
# For printing map purpose
map_title = tr('Roads inundated')
legend_title = tr('Road inundated status')
style_classes = [
# FIXME 0 - 0.1
dict(label=self.hazard_classes[0] + ': 0m',
value=0,
colour='#00FF00',
transparency=0,
size=1),
dict(label=self.hazard_classes[1] + ': <0 - %.1f m' % low_max,
value=1,
colour='#FFFF00',
transparency=0,
size=1),
dict(label=self.hazard_classes[2] + ': %.1f - %.1f m' %
(low_max + 0.1, medium_max),
value=2,
colour='#FFB700',
transparency=0,
size=1),
dict(label=self.hazard_classes[3] + ': %.1f - %.1f m' %
(medium_max + 0.1, high_max),
value=3,
colour='#FF6F00',
transparency=0,
size=1),
dict(label=self.hazard_classes[4] + ' > %.1f m' % high_max,
value=4,
colour='#FF0000',
transparency=0,
size=1),
]
style_info = dict(target_field=target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
extra_keywords = {
'impact_summary': impact_summary,
'map_title': map_title,
'legend_title': legend_title,
'target_field': target_field
}
self.set_if_provenance()
impact_layer_keywords = self.generate_impact_keywords(extra_keywords)
# Convert QgsVectorLayer to inasafe layer and return it
line_layer = Vector(data=line_layer,
name=tr('Flooded roads'),
keywords=impact_layer_keywords,
style_info=style_info)
self._impact = line_layer
return line_layer
def run(self):
"""Run the impact function.
:returns: A new line layer with inundated roads marked.
:type: safe_layer
"""
self.validate()
self.prepare()
self.provenance.append_step(
'Calculating Step',
'Impact function is calculating the impact.')
# Thresholds for tsunami hazard zone breakdown.
low_max = self.parameters['low_threshold'].value
medium_max = self.parameters['medium_threshold'].value
high_max = self.parameters['high_threshold'].value
target_field = self.target_field
# Get parameters from layer's keywords
road_class_field = self.exposure.keyword('road_class_field')
# reproject self.extent to the hazard projection
hazard_crs = self.hazard.layer.crs()
hazard_authid = hazard_crs.authid()
if hazard_authid == 'EPSG:4326':
viewport_extent = self.requested_extent
else:
geo_crs = QgsCoordinateReferenceSystem()
geo_crs.createFromSrid(4326)
viewport_extent = extent_to_geo_array(
QgsRectangle(*self.requested_extent), geo_crs, hazard_crs)
# Align raster extent and viewport
# assuming they are both in the same projection
raster_extent = self.hazard.layer.dataProvider().extent()
clip_xmin = raster_extent.xMinimum()
# clip_xmax = raster_extent.xMaximum()
clip_ymin = raster_extent.yMinimum()
# clip_ymax = raster_extent.yMaximum()
if viewport_extent[0] > clip_xmin:
clip_xmin = viewport_extent[0]
if viewport_extent[1] > clip_ymin:
clip_ymin = viewport_extent[1]
height = ((viewport_extent[3] - viewport_extent[1]) /
self.hazard.layer.rasterUnitsPerPixelY())
height = int(height)
width = ((viewport_extent[2] - viewport_extent[0]) /
self.hazard.layer.rasterUnitsPerPixelX())
width = int(width)
raster_extent = self.hazard.layer.dataProvider().extent()
xmin = raster_extent.xMinimum()
xmax = raster_extent.xMaximum()
ymin = raster_extent.yMinimum()
ymax = raster_extent.yMaximum()
x_delta = (xmax - xmin) / self.hazard.layer.width()
x = xmin
for i in range(self.hazard.layer.width()):
if abs(x - clip_xmin) < x_delta:
# We have found the aligned raster boundary
break
x += x_delta
_ = i
y_delta = (ymax - ymin) / self.hazard.layer.height()
y = ymin
for i in range(self.hazard.layer.width()):
if abs(y - clip_ymin) < y_delta:
# We have found the aligned raster boundary
break
y += y_delta
clip_extent = [x, y, x + width * x_delta, y + height * y_delta]
# Clip hazard raster
small_raster = clip_raster(
self.hazard.layer, width, height, QgsRectangle(*clip_extent))
# Create vector features from the flood raster
# For each raster cell there is one rectangular polygon
# Data also get spatially indexed for faster operation
ranges = OrderedDict()
ranges[0] = [0.0, 0.0]
ranges[1] = [0.0, low_max]
ranges[2] = [low_max, medium_max]
ranges[3] = [medium_max, high_max]
ranges[4] = [high_max, None]
index, flood_cells_map = _raster_to_vector_cells(
small_raster,
ranges,
self.exposure.layer.crs())
# Filter geometry and data using the extent
ct = QgsCoordinateTransform(
QgsCoordinateReferenceSystem("EPSG:4326"),
self.exposure.layer.crs())
extent = ct.transformBoundingBox(QgsRectangle(*self.requested_extent))
request = QgsFeatureRequest()
request.setFilterRect(extent)
"""
if len(low_max_flood_cells_map) == 0 and \
len(medium_max_flood_cells_map) == 0 and \
len(high_max_flood_cells_map) == 0 and \
len(high_min_flood_cells_map) == 0:
message = tr(
'There are no objects in the hazard layer with "value" > 0. '
'Please check the value or use other extent.' % (
threshold_min, ))
raise GetDataError(message)
"""
# create template for the output layer
line_layer_tmp = create_layer(self.exposure.layer)
new_field = QgsField(target_field, QVariant.Int)
line_layer_tmp.dataProvider().addAttributes([new_field])
line_layer_tmp.updateFields()
# create empty output layer and load it
filename = unique_filename(suffix='.shp')
QgsVectorFileWriter.writeAsVectorFormat(
line_layer_tmp, filename, "utf-8", None, "ESRI Shapefile")
line_layer = QgsVectorLayer(filename, "flooded roads", "ogr")
# Do the heavy work - for each road get flood polygon for that area and
# do the intersection/difference to find out which parts are flooded
_intersect_lines_with_vector_cells(
self.exposure.layer,
request,
index,
flood_cells_map,
line_layer,
target_field)
target_field_index = line_layer.dataProvider().\
fieldNameIndex(target_field)
# Generate simple impact report
epsg = get_utm_epsg(self.requested_extent[0], self.requested_extent[1])
output_crs = QgsCoordinateReferenceSystem(epsg)
transform = QgsCoordinateTransform(
self.exposure.layer.crs(), output_crs)
# Roads breakdown
self.road_lengths = OrderedDict()
self.affected_road_categories = self.hazard_classes
# Impacted roads breakdown
self.affected_road_lengths = OrderedDict([
(self.hazard_classes[0], {}),
(self.hazard_classes[1], {}),
(self.hazard_classes[2], {}),
(self.hazard_classes[3], {}),
(self.hazard_classes[4], {}),
])
if line_layer.featureCount() < 1:
raise ZeroImpactException()
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_class_field)
for road in roads_data:
attributes = road.attributes()
affected = attributes[target_field_index]
hazard_zone = self.hazard_classes[affected]
road_type = attributes[road_type_field_index]
if road_type.__class__.__name__ == 'QPyNullVariant':
road_type = tr('Other')
geom = road.geometry()
geom.transform(transform)
length = geom.length()
if road_type not in self.road_lengths:
self.road_lengths[road_type] = 0
if hazard_zone not in self.affected_road_lengths:
self.affected_road_lengths[hazard_zone] = {}
if road_type not in self.affected_road_lengths[hazard_zone]:
self.affected_road_lengths[hazard_zone][road_type] = 0
self.road_lengths[road_type] += length
num_classes = len(self.hazard_classes)
if attributes[target_field_index] in range(num_classes):
self.affected_road_lengths[hazard_zone][road_type] += length
impact_summary = self.html_report()
# For printing map purpose
map_title = tr('Roads inundated')
legend_title = tr('Road inundated status')
style_classes = [
# FIXME 0 - 0.1
dict(
label=self.hazard_classes[0] + ': 0m',
value=0,
colour='#00FF00',
transparency=0,
size=1
),
dict(
label=self.hazard_classes[1] + ': <0 - %.1f m' % low_max,
value=1,
colour='#FFFF00',
transparency=0,
size=1
),
dict(
label=self.hazard_classes[2] + ': %.1f - %.1f m' % (
low_max + 0.1, medium_max),
value=2,
colour='#FFB700',
transparency=0,
size=1
),
dict(
label=self.hazard_classes[3] + ': %.1f - %.1f m' % (
medium_max + 0.1, high_max),
value=3,
colour='#FF6F00',
transparency=0,
size=1
),
dict(
label=self.hazard_classes[4] + ' > %.1f m' % high_max,
value=4,
colour='#FF0000',
transparency=0,
size=1
),
]
style_info = dict(
target_field=target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
extra_keywords = {
'impact_summary': impact_summary,
'map_title': map_title,
'legend_title': legend_title,
'target_field': target_field
}
self.set_if_provenance()
impact_layer_keywords = self.generate_impact_keywords(extra_keywords)
# Convert QgsVectorLayer to inasafe layer and return it
line_layer = Vector(
data=line_layer,
name=tr('Flooded roads'),
keywords=impact_layer_keywords,
style_info=style_info)
self._impact = line_layer
return line_layer
def run(self):
"""Run the impact function.
:returns: A new line layer with inundated roads marked.
:type: safe_layer
"""
target_field = self.target_field
# Get parameters from layer's keywords
road_class_field = self.exposure.keyword('road_class_field')
exposure_value_mapping = self.exposure.keyword('value_mapping')
# Get parameters from IF parameter
threshold_min = self.parameters['min threshold'].value
threshold_max = self.parameters['max threshold'].value
if threshold_min > threshold_max:
message = tr(
'The minimal threshold is greater than the maximal specified '
'threshold. Please check the values.')
raise GetDataError(message)
# reproject self.extent to the hazard projection
hazard_crs = self.hazard.layer.crs()
hazard_authid = hazard_crs.authid()
if hazard_authid == 'EPSG:4326':
viewport_extent = self.requested_extent
else:
geo_crs = QgsCoordinateReferenceSystem()
geo_crs.createFromSrid(4326)
viewport_extent = extent_to_geo_array(
QgsRectangle(*self.requested_extent), geo_crs, hazard_crs)
# Clip hazard raster
small_raster = align_clip_raster(self.hazard.layer, viewport_extent)
# Filter geometry and data using the extent
ct = QgsCoordinateTransform(
QgsCoordinateReferenceSystem("EPSG:4326"),
self.exposure.layer.crs())
extent = ct.transformBoundingBox(QgsRectangle(*self.requested_extent))
request = QgsFeatureRequest()
request.setFilterRect(extent)
# create template for the output layer
line_layer_tmp = create_layer(self.exposure.layer)
new_field = QgsField(target_field, QVariant.Int)
line_layer_tmp.dataProvider().addAttributes([new_field])
line_layer_tmp.updateFields()
# create empty output layer and load it
filename = unique_filename(suffix='.shp')
QgsVectorFileWriter.writeAsVectorFormat(
line_layer_tmp, filename, "utf-8", None, "ESRI Shapefile")
line_layer = QgsVectorLayer(filename, "flooded roads", "ogr")
# Create vector features from the flood raster
# For each raster cell there is one rectangular polygon
# Data also get spatially indexed for faster operation
index, flood_cells_map = _raster_to_vector_cells(
small_raster,
threshold_min,
threshold_max,
self.exposure.layer.crs())
if len(flood_cells_map) == 0:
message = tr(
'There are no objects in the hazard layer with "value" > %s. '
'Please check the value or use other extent.' % (
threshold_min, ))
raise GetDataError(message)
# Do the heavy work - for each road get flood polygon for that area and
# do the intersection/difference to find out which parts are flooded
_intersect_lines_with_vector_cells(
self.exposure.layer,
request,
index,
flood_cells_map,
line_layer,
target_field)
target_field_index = line_layer.dataProvider().\
fieldNameIndex(target_field)
# Generate simple impact report
epsg = get_utm_epsg(self.requested_extent[0], self.requested_extent[1])
output_crs = QgsCoordinateReferenceSystem(epsg)
transform = QgsCoordinateTransform(
self.exposure.layer.crs(), output_crs)
classes = [tr('Flooded in the threshold (m)')]
self.init_report_var(classes)
if line_layer.featureCount() < 1:
raise ZeroImpactException()
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_class_field)
for road in roads_data:
attributes = road.attributes()
usage = attributes[road_type_field_index]
usage = main_type(usage, exposure_value_mapping)
geom = road.geometry()
geom.transform(transform)
length = geom.length()
affected = False
if attributes[target_field_index] == 1:
affected = True
self.classify_feature(classes[0], usage, length, affected)
self.reorder_dictionaries()
style_classes = [
dict(
label=tr('Not Inundated'), value=0,
colour='#1EFC7C', transparency=0, size=0.5),
dict(
label=tr('Inundated'), value=1,
colour='#F31A1C', transparency=0, size=0.5)]
style_info = dict(
target_field=target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
impact_data = self.generate_data()
extra_keywords = {
'map_title': self.map_title(),
'legend_title': self.metadata().key('legend_title'),
'target_field': target_field
}
impact_layer_keywords = self.generate_impact_keywords(extra_keywords)
# Convert QgsVectorLayer to inasafe layer and return it
impact_layer = Vector(
data=line_layer,
name=self.map_title(),
keywords=impact_layer_keywords,
style_info=style_info)
impact_layer.impact_data = impact_data
self._impact = impact_layer
return impact_layer
def run(self):
"""Run the impact function.
:returns: A new line layer with inundated roads marked.
:type: safe_layer
"""
# Thresholds for tsunami hazard zone breakdown.
low_max = self.parameters['low_threshold'].value
medium_max = self.parameters['medium_threshold'].value
high_max = self.parameters['high_threshold'].value
target_field = self.target_field
# Get parameters from layer's keywords
road_class_field = self.exposure.keyword('road_class_field')
exposure_value_mapping = self.exposure.keyword('value_mapping')
# reproject self.extent to the hazard projection
hazard_crs = self.hazard.layer.crs()
hazard_authid = hazard_crs.authid()
if hazard_authid == 'EPSG:4326':
viewport_extent = self.requested_extent
else:
geo_crs = QgsCoordinateReferenceSystem()
geo_crs.createFromSrid(4326)
viewport_extent = extent_to_geo_array(
QgsRectangle(*self.requested_extent), geo_crs, hazard_crs)
# Clip hazard raster
small_raster = align_clip_raster(self.hazard.layer, viewport_extent)
# Create vector features from the flood raster
# For each raster cell there is one rectangular polygon
# Data also get spatially indexed for faster operation
ranges = ranges_according_thresholds(low_max, medium_max, high_max)
index, flood_cells_map = _raster_to_vector_cells(
small_raster,
ranges,
self.exposure.layer.crs())
# Filter geometry and data using the extent
ct = QgsCoordinateTransform(
QgsCoordinateReferenceSystem("EPSG:4326"),
self.exposure.layer.crs())
extent = ct.transformBoundingBox(QgsRectangle(*self.requested_extent))
request = QgsFeatureRequest()
request.setFilterRect(extent)
# create template for the output layer
line_layer_tmp = create_layer(self.exposure.layer)
new_field = QgsField(target_field, QVariant.Int)
line_layer_tmp.dataProvider().addAttributes([new_field])
line_layer_tmp.updateFields()
# create empty output layer and load it
filename = unique_filename(suffix='.shp')
QgsVectorFileWriter.writeAsVectorFormat(
line_layer_tmp, filename, "utf-8", None, "ESRI Shapefile")
line_layer = QgsVectorLayer(filename, "flooded roads", "ogr")
# Do the heavy work - for each road get flood polygon for that area and
# do the intersection/difference to find out which parts are flooded
_intersect_lines_with_vector_cells(
self.exposure.layer,
request,
index,
flood_cells_map,
line_layer,
target_field)
target_field_index = line_layer.dataProvider().\
fieldNameIndex(target_field)
# Generate simple impact report
epsg = get_utm_epsg(self.requested_extent[0], self.requested_extent[1])
output_crs = QgsCoordinateReferenceSystem(epsg)
transform = QgsCoordinateTransform(
self.exposure.layer.crs(), output_crs)
# Roads breakdown
self.init_report_var(self.hazard_classes)
if line_layer.featureCount() < 1:
raise ZeroImpactException()
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_class_field)
for road in roads_data:
attributes = road.attributes()
affected = attributes[target_field_index]
if isinstance(affected, QPyNullVariant):
continue
else:
hazard_zone = self.hazard_classes[affected]
usage = attributes[road_type_field_index]
usage = main_type(usage, exposure_value_mapping)
geom = road.geometry()
geom.transform(transform)
length = geom.length()
affected = False
num_classes = len(self.hazard_classes)
if attributes[target_field_index] in range(num_classes):
affected = True
self.classify_feature(hazard_zone, usage, length, affected)
self.reorder_dictionaries()
style_classes = [
# FIXME 0 - 0.1
dict(
label=self.hazard_classes[0] + ': 0m',
value=0,
colour='#00FF00',
transparency=0,
size=1
),
dict(
label=self.hazard_classes[1] + ': >0 - %.1f m' % low_max,
value=1,
colour='#FFFF00',
transparency=0,
size=1
),
dict(
label=self.hazard_classes[2] + ': %.1f - %.1f m' % (
low_max + 0.1, medium_max),
value=2,
colour='#FFB700',
transparency=0,
size=1
),
dict(
label=self.hazard_classes[3] + ': %.1f - %.1f m' % (
medium_max + 0.1, high_max),
value=3,
colour='#FF6F00',
transparency=0,
size=1
),
dict(
label=self.hazard_classes[4] + ' > %.1f m' % high_max,
value=4,
colour='#FF0000',
transparency=0,
size=1
),
]
style_info = dict(
target_field=target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
impact_data = self.generate_data()
extra_keywords = {
'map_title': self.metadata().key('map_title'),
'legend_title': self.metadata().key('legend_title'),
'target_field': target_field
}
impact_layer_keywords = self.generate_impact_keywords(extra_keywords)
# Convert QgsVectorLayer to inasafe layer and return it
impact_layer = Vector(
data=line_layer,
name=self.metadata().key('layer_name'),
keywords=impact_layer_keywords,
style_info=style_info)
impact_layer.impact_data = impact_data
self._impact = impact_layer
return impact_layer
def run(self):
"""Run the impact function.
:returns: A new line layer with inundated roads marked.
:type: safe_layer
"""
# Thresholds for tsunami hazard zone breakdown.
low_max = self.parameters['low_threshold'].value
medium_max = self.parameters['medium_threshold'].value
high_max = self.parameters['high_threshold'].value
target_field = self.target_field
# Get parameters from layer's keywords
road_class_field = self.exposure.keyword('road_class_field')
exposure_value_mapping = self.exposure.keyword('value_mapping')
# reproject self.extent to the hazard projection
hazard_crs = self.hazard.layer.crs()
hazard_authid = hazard_crs.authid()
if hazard_authid == 'EPSG:4326':
viewport_extent = self.requested_extent
else:
geo_crs = QgsCoordinateReferenceSystem()
geo_crs.createFromSrid(4326)
viewport_extent = extent_to_geo_array(
QgsRectangle(*self.requested_extent), geo_crs, hazard_crs)
# Clip hazard raster
small_raster = align_clip_raster(self.hazard.layer, viewport_extent)
# Create vector features from the flood raster
# For each raster cell there is one rectangular polygon
# Data also get spatially indexed for faster operation
ranges = ranges_according_thresholds(low_max, medium_max, high_max)
index, flood_cells_map = _raster_to_vector_cells(
small_raster, ranges, self.exposure.layer.crs())
# Filter geometry and data using the extent
ct = QgsCoordinateTransform(QgsCoordinateReferenceSystem("EPSG:4326"),
self.exposure.layer.crs())
extent = ct.transformBoundingBox(QgsRectangle(*self.requested_extent))
request = QgsFeatureRequest()
request.setFilterRect(extent)
# create template for the output layer
line_layer_tmp = create_layer(self.exposure.layer)
new_field = QgsField(target_field, QVariant.Int)
line_layer_tmp.dataProvider().addAttributes([new_field])
line_layer_tmp.updateFields()
# create empty output layer and load it
filename = unique_filename(suffix='.shp')
QgsVectorFileWriter.writeAsVectorFormat(line_layer_tmp, filename,
"utf-8", None,
"ESRI Shapefile")
line_layer = QgsVectorLayer(filename, "flooded roads", "ogr")
# Do the heavy work - for each road get flood polygon for that area and
# do the intersection/difference to find out which parts are flooded
_intersect_lines_with_vector_cells(self.exposure.layer, request, index,
flood_cells_map, line_layer,
target_field)
target_field_index = line_layer.dataProvider().\
fieldNameIndex(target_field)
# Generate simple impact report
epsg = get_utm_epsg(self.requested_extent[0], self.requested_extent[1])
output_crs = QgsCoordinateReferenceSystem(epsg)
transform = QgsCoordinateTransform(self.exposure.layer.crs(),
output_crs)
# Roads breakdown
self.init_report_var(self.hazard_classes)
if line_layer.featureCount() < 1:
raise ZeroImpactException()
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_class_field)
for road in roads_data:
attributes = road.attributes()
affected = attributes[target_field_index]
if isinstance(affected, QPyNullVariant):
continue
else:
hazard_zone = self.hazard_classes[affected]
usage = attributes[road_type_field_index]
usage = main_type(usage, exposure_value_mapping)
geom = road.geometry()
geom.transform(transform)
length = geom.length()
affected = False
num_classes = len(self.hazard_classes)
if attributes[target_field_index] in range(num_classes):
affected = True
self.classify_feature(hazard_zone, usage, length, affected)
self.reorder_dictionaries()
style_classes = [
# FIXME 0 - 0.1
dict(label=self.hazard_classes[0] + ': 0m',
value=0,
colour='#00FF00',
transparency=0,
size=1),
dict(label=self.hazard_classes[1] + ': >0 - %.1f m' % low_max,
value=1,
colour='#FFFF00',
transparency=0,
size=1),
dict(label=self.hazard_classes[2] + ': %.1f - %.1f m' %
(low_max + 0.1, medium_max),
value=2,
colour='#FFB700',
transparency=0,
size=1),
dict(label=self.hazard_classes[3] + ': %.1f - %.1f m' %
(medium_max + 0.1, high_max),
value=3,
colour='#FF6F00',
transparency=0,
size=1),
dict(label=self.hazard_classes[4] + ' > %.1f m' % high_max,
value=4,
colour='#FF0000',
transparency=0,
size=1),
]
style_info = dict(target_field=target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
impact_data = self.generate_data()
extra_keywords = {
'map_title': self.map_title(),
'legend_title': self.metadata().key('legend_title'),
'target_field': target_field
}
impact_layer_keywords = self.generate_impact_keywords(extra_keywords)
# Convert QgsVectorLayer to inasafe layer and return it
impact_layer = Vector(data=line_layer,
name=self.map_title(),
keywords=impact_layer_keywords,
style_info=style_info)
impact_layer.impact_data = impact_data
self._impact = impact_layer
return impact_layer
def interpolate_polygon_polygon(source, target, wgs84_extent):
""" Transfer values from source polygon layer to the target polygon layer.
This method will do a spatial join: the output layer will contain all
features from target layer, with the addition of attributes of intersecting
feature from the source layer. If there is not intersecting source feature,
the output layer will still contain the target feature, with null
attributes from the source layer.
The intersection test considers only centroids of target features
(not the whole polygon geometry).
If more features from source layer intersect a target feature, only
the first intersecting source feature will be used.
:param source: Source polygon layer
:type source: QgsVectorLayer
:param target: Target polygon layer
:type target: QgsVectorLayer
:param wgs84_extent: Requested extent for analysis, in WGS84 coordinates
:type wgs84_extent: QgsRectangle
:return: output layer
:rtype: QgsVectorLayer
"""
source_field_count = source.dataProvider().fields().count()
target_field_count = target.dataProvider().fields().count()
# Create new layer for writing resulting features.
# It will contain attributes of both target and source layers
result = create_layer(target)
new_fields = source.dataProvider().fields().toList()
new_fields.append(QgsField('polygon_id', QVariant.Int))
result.dataProvider().addAttributes(new_fields)
result.updateFields()
result_fields = result.dataProvider().fields()
# setup transform objects between different CRS
crs_wgs84 = QgsCoordinateReferenceSystem("EPSG:4326")
wgs84_to_source = QgsCoordinateTransform(crs_wgs84, source.crs())
wgs84_to_target = QgsCoordinateTransform(crs_wgs84, target.crs())
source_to_target = QgsCoordinateTransform(source.crs(), target.crs())
# compute extents in CRS of layers
source_extent = wgs84_to_source.transformBoundingBox(wgs84_extent)
target_extent = wgs84_to_target.transformBoundingBox(wgs84_extent)
# cache source layer (in CRS of target layer)
source_index = QgsSpatialIndex()
source_geometries = {} # key = feature ID, value = QgsGeometry
source_attributes = {}
for f in source.getFeatures(QgsFeatureRequest(source_extent)):
f.geometry().transform(source_to_target)
source_index.insertFeature(f)
source_geometries[f.id()] = QgsGeometry(f.geometry())
source_attributes[f.id()] = f.attributes()
# Go through all features in target layer and for each decide
# whether it is intersected by any source feature
result_features = []
for f in target.getFeatures(QgsFeatureRequest(target_extent)):
# we use just centroids of target polygons
centroid_geometry = f.geometry().centroid()
centroid = centroid_geometry.asPoint()
rect = QgsRectangle(
centroid.x(), centroid.y(),
centroid.x(), centroid.y())
ids = source_index.intersects(rect)
has_matching_source = False
for source_id in ids:
if source_geometries[source_id].intersects(centroid_geometry):
# we have found intersection between source and target
f_result = QgsFeature(result_fields)
f_result.setGeometry(f.geometry())
for i in xrange(target_field_count):
f_result[i] = f[i]
for i in xrange(source_field_count):
f_result[i + target_field_count] = source_attributes[
source_id][i]
f_result['polygon_id'] = source_id
result_features.append(f_result)
has_matching_source = True
break # assuming just one source for each target feature
# if there is no intersecting feature from source layer,
# we will keep the source attributes null
if not has_matching_source:
f_result = QgsFeature(result_fields)
f_result.setGeometry(f.geometry())
for i in xrange(target_field_count):
f_result[i] = f[i]
result_features.append(f_result)
if len(result_features) == 1000:
result.dataProvider().addFeatures(result_features)
result_features = []
result.dataProvider().addFeatures(result_features)
return result
def run(self):
"""Run the impact function.
:returns: A new line layer with inundated roads marked.
:type: safe_layer
"""
self.validate()
self.prepare()
target_field = self.target_field
# Get parameters from layer's keywords
road_class_field = self.exposure.keyword('road_class_field')
# Get parameters from IF parameter
threshold_min = self.parameters['min threshold'].value
threshold_max = self.parameters['max threshold'].value
if threshold_min > threshold_max:
message = tr(
'The minimal threshold is greater than the maximal specified '
'threshold. Please check the values.')
raise GetDataError(message)
# reproject self.extent to the hazard projection
hazard_crs = self.hazard.layer.crs()
hazard_authid = hazard_crs.authid()
if hazard_authid == 'EPSG:4326':
viewport_extent = self.requested_extent
else:
geo_crs = QgsCoordinateReferenceSystem()
geo_crs.createFromSrid(4326)
viewport_extent = extent_to_geo_array(
QgsRectangle(*self.requested_extent), geo_crs, hazard_crs)
# Align raster extent and viewport
# assuming they are both in the same projection
raster_extent = self.hazard.layer.dataProvider().extent()
clip_xmin = raster_extent.xMinimum()
# clip_xmax = raster_extent.xMaximum()
clip_ymin = raster_extent.yMinimum()
# clip_ymax = raster_extent.yMaximum()
if viewport_extent[0] > clip_xmin:
clip_xmin = viewport_extent[0]
if viewport_extent[1] > clip_ymin:
clip_ymin = viewport_extent[1]
# TODO: Why have these two clauses when they are not used?
# Commenting out for now.
# if viewport_extent[2] < clip_xmax:
# clip_xmax = viewport_extent[2]
# if viewport_extent[3] < clip_ymax:
# clip_ymax = viewport_extent[3]
height = ((viewport_extent[3] - viewport_extent[1]) /
self.hazard.layer.rasterUnitsPerPixelY())
height = int(height)
width = ((viewport_extent[2] - viewport_extent[0]) /
self.hazard.layer.rasterUnitsPerPixelX())
width = int(width)
raster_extent = self.hazard.layer.dataProvider().extent()
xmin = raster_extent.xMinimum()
xmax = raster_extent.xMaximum()
ymin = raster_extent.yMinimum()
ymax = raster_extent.yMaximum()
x_delta = (xmax - xmin) / self.hazard.layer.width()
x = xmin
for i in range(self.hazard.layer.width()):
if abs(x - clip_xmin) < x_delta:
# We have found the aligned raster boundary
break
x += x_delta
_ = i
y_delta = (ymax - ymin) / self.hazard.layer.height()
y = ymin
for i in range(self.hazard.layer.width()):
if abs(y - clip_ymin) < y_delta:
# We have found the aligned raster boundary
break
y += y_delta
clip_extent = [x, y, x + width * x_delta, y + height * y_delta]
# Clip hazard raster
small_raster = clip_raster(
self.hazard.layer, width, height, QgsRectangle(*clip_extent))
# Create vector features from the flood raster
# For each raster cell there is one rectangular polygon
# Data also get spatially indexed for faster operation
index, flood_cells_map = _raster_to_vector_cells(
small_raster,
threshold_min,
threshold_max,
self.exposure.layer.crs())
# Filter geometry and data using the extent
ct = QgsCoordinateTransform(
QgsCoordinateReferenceSystem("EPSG:4326"),
self.exposure.layer.crs())
extent = ct.transformBoundingBox(QgsRectangle(*self.requested_extent))
request = QgsFeatureRequest()
request.setFilterRect(extent)
if len(flood_cells_map) == 0:
message = tr(
'There are no objects in the hazard layer with "value" > %s. '
'Please check the value or use other extent.' % (
threshold_min, ))
raise GetDataError(message)
# create template for the output layer
line_layer_tmp = create_layer(self.exposure.layer)
new_field = QgsField(target_field, QVariant.Int)
line_layer_tmp.dataProvider().addAttributes([new_field])
line_layer_tmp.updateFields()
# create empty output layer and load it
filename = unique_filename(suffix='.shp')
QgsVectorFileWriter.writeAsVectorFormat(
line_layer_tmp, filename, "utf-8", None, "ESRI Shapefile")
line_layer = QgsVectorLayer(filename, "flooded roads", "ogr")
# Do the heavy work - for each road get flood polygon for that area and
# do the intersection/difference to find out which parts are flooded
_intersect_lines_with_vector_cells(
self.exposure.layer,
request,
index,
flood_cells_map,
line_layer,
target_field)
target_field_index = line_layer.dataProvider().\
fieldNameIndex(target_field)
# Generate simple impact report
epsg = get_utm_epsg(self.requested_extent[0], self.requested_extent[1])
output_crs = QgsCoordinateReferenceSystem(epsg)
transform = QgsCoordinateTransform(
self.exposure.layer.crs(), output_crs)
flooded_keyword = tr('Flooded in the threshold (m)')
self.affected_road_categories = [flooded_keyword]
self.affected_road_lengths = OrderedDict([
(flooded_keyword, {})])
self.road_lengths = OrderedDict()
if line_layer.featureCount() < 1:
raise ZeroImpactException()
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_class_field)
for road in roads_data:
attributes = road.attributes()
road_type = attributes[road_type_field_index]
if road_type.__class__.__name__ == 'QPyNullVariant':
road_type = tr('Other')
geom = road.geometry()
geom.transform(transform)
length = geom.length()
if road_type not in self.road_lengths:
self.affected_road_lengths[flooded_keyword][road_type] = 0
self.road_lengths[road_type] = 0
self.road_lengths[road_type] += length
if attributes[target_field_index] == 1:
self.affected_road_lengths[
flooded_keyword][road_type] += length
impact_summary = self.html_report()
# For printing map purpose
map_title = tr('Roads inundated')
legend_title = tr('Road inundated status')
style_classes = [
dict(
label=tr('Not Inundated'), value=0,
colour='#1EFC7C', transparency=0, size=0.5),
dict(
label=tr('Inundated'), value=1,
colour='#F31A1C', transparency=0, size=0.5)]
style_info = dict(
target_field=target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
# Convert QgsVectorLayer to inasafe layer and return it
line_layer = Vector(
data=line_layer,
name=tr('Flooded roads'),
keywords={
'impact_summary': impact_summary,
'map_title': map_title,
'legend_title': legend_title,
'target_field': target_field},
style_info=style_info)
self._impact = line_layer
return line_layer