def test_clip_raster(self):
"""Test clip_raster work"""
new_raster = clip_raster(self.raster, self.raster.width(),
self.raster.height(), self.extent)
self.assertEqual(self.raster.rasterUnitsPerPixelY(),
new_raster.rasterUnitsPerPixelY())
self.assertEqual(self.raster.rasterUnitsPerPixelX(),
new_raster.rasterUnitsPerPixelX())
self.assertEqual(self.raster.extent(), new_raster.extent())
self.assertEqual(self.raster.width(), new_raster.width())
self.assertEqual(self.raster.height(), new_raster.height())
# Set extent as 1/2 of self.extent
center = self.extent.center()
x_max, y_max = center.x(), center.y()
new_extent = QgsRectangle(self.extent.xMinimum(),
self.extent.yMinimum(), x_max, y_max)
new_raster = clip_raster(self.raster, self.raster.width(),
self.raster.height(), new_extent)
self.assertAlmostEquals(self.raster.rasterUnitsPerPixelY(),
2 * new_raster.rasterUnitsPerPixelY())
self.assertAlmostEquals(self.raster.rasterUnitsPerPixelX(),
2 * new_raster.rasterUnitsPerPixelX())
self.assertEqual(new_extent, new_raster.extent())
self.assertEqual(self.raster.width(), new_raster.width())
self.assertEqual(self.raster.height(), new_raster.height())
def test_clip_raster(self):
"""Test clip_raster work"""
new_raster = clip_raster(
self.raster,
self.raster.width(),
self.raster.height(),
self.extent
)
self.assertEqual(self.raster.rasterUnitsPerPixelY(),
new_raster.rasterUnitsPerPixelY())
self.assertEqual(self.raster.rasterUnitsPerPixelX(),
new_raster.rasterUnitsPerPixelX())
self.assertEqual(self.raster.extent(),
new_raster.extent())
self.assertEqual(self.raster.width(),
new_raster.width())
self.assertEqual(self.raster.height(),
new_raster.height())
# Set extent as 1/2 of self.extent
center = self.extent.center()
x_max, y_max = center.x(), center.y()
new_extent = QgsRectangle(
self.extent.xMinimum(),
self.extent.yMinimum(),
x_max,
y_max
)
new_raster = clip_raster(
self.raster,
self.raster.width(),
self.raster.height(),
new_extent
)
self.assertAlmostEquals(
self.raster.rasterUnitsPerPixelY(),
2 * new_raster.rasterUnitsPerPixelY())
self.assertAlmostEquals(
self.raster.rasterUnitsPerPixelX(),
2 * new_raster.rasterUnitsPerPixelX())
self.assertEqual(new_extent, new_raster.extent())
self.assertEqual(self.raster.width(), new_raster.width())
self.assertEqual(self.raster.height(), new_raster.height())
def run(self, layers=None):
"""Run the impact function.
:param layers: List of layers expected to contain at least:
H: Polygon layer of inundation areas
E: Vector layer of roads
:type layers: list
:returns: A new line layer with inundated roads marked.
:type: safe_layer
"""
self.validate()
self.prepare(layers)
target_field = self.target_field
road_type_field = self.parameters['road_type_field']
threshold_min = self.parameters['min threshold [m]']
threshold_max = self.parameters['max threshold [m]']
if threshold_min > threshold_max:
message = tr(
'The minimal threshold is greater then the maximal specified '
'threshold. Please check the values.')
raise GetDataError(message)
# Extract data
H = self.hazard # Flood
E = self.exposure # Roads
H = H.get_layer()
E = E.get_layer()
# reproject self.extent to the hazard projection
hazard_crs = H.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 = H.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]) /
H.rasterUnitsPerPixelY())
height = int(height)
width = ((viewport_extent[2] - viewport_extent[0]) /
H.rasterUnitsPerPixelX())
width = int(width)
raster_extent = H.dataProvider().extent()
xmin = raster_extent.xMinimum()
xmax = raster_extent.xMaximum()
ymin = raster_extent.yMinimum()
ymax = raster_extent.yMaximum()
x_delta = (xmax - xmin) / H.width()
x = xmin
for i in range(H.width()):
if abs(x - clip_xmin) < x_delta:
# We have found the aligned raster boundary
break
x += x_delta
_ = i
y_delta = (ymax - ymin) / H.height()
y = ymin
for i in range(H.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 and polygonize
small_raster = clip_raster(H, width, height,
QgsRectangle(*clip_extent))
(flooded_polygon_inside,
flooded_polygon_outside) = polygonize_gdal(small_raster,
threshold_min,
threshold_max)
# Filter geometry and data using the extent
extent = QgsRectangle(*self.requested_extent)
request = QgsFeatureRequest()
request.setFilterRect(extent)
if flooded_polygon_inside is None:
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)
# reproject the flood polygons to exposure projection
exposure_crs = E.crs()
exposure_authid = exposure_crs.authid()
if hazard_authid != exposure_authid:
flooded_polygon_inside = reproject_vector_layer(
flooded_polygon_inside, E.crs())
flooded_polygon_outside = reproject_vector_layer(
flooded_polygon_outside, E.crs())
# Clip exposure by the extent
# extent_as_polygon = QgsGeometry().fromRect(extent)
# no need to clip since It is using a bbox request
# line_layer = clip_by_polygon(
# E,
# extent_as_polygon
# )
# Find inundated roads, mark them
line_layer = split_by_polygon_in_out(E, flooded_polygon_inside,
flooded_polygon_outside,
target_field, 1, request)
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(E.crs(), output_crs)
road_len = flooded_len = 0 # Length of roads
roads_by_type = dict() # Length of flooded roads by types
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_type_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()
road_len += length
if road_type not in roads_by_type:
roads_by_type[road_type] = {'flooded': 0, 'total': 0}
roads_by_type[road_type]['total'] += length
if attributes[target_field_index] == 1:
flooded_len += length
roads_by_type[road_type]['flooded'] += length
table_body = self._tabulate(flooded_len, self.question, road_len,
roads_by_type)
impact_summary = Table(table_body).toNewlineFreeString()
map_title = tr('Roads inundated')
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,
'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
"""
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, layers=None):
"""Run the impact function.
:param layers: List of layers expected to contain at least:
H: Polygon layer of inundation areas
E: Vector layer of roads
:type layers: list
:returns: A new line layer with inundated roads marked.
:type: safe_layer
"""
self.validate()
self.prepare(layers)
target_field = self.target_field
road_type_field = self.parameters['road_type_field']
threshold_min = self.parameters['min threshold [m]']
threshold_max = self.parameters['max threshold [m]']
if threshold_min > threshold_max:
message = tr(
'The minimal threshold is greater then the maximal specified '
'threshold. Please check the values.')
raise GetDataError(message)
# Extract data
H = self.hazard # Flood
E = self.exposure # Roads
H = H.get_layer()
E = E.get_layer()
# reproject self.extent to the hazard projection
hazard_crs = H.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 = H.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]) /
H.rasterUnitsPerPixelY())
height = int(height)
width = ((viewport_extent[2] - viewport_extent[0]) /
H.rasterUnitsPerPixelX())
width = int(width)
raster_extent = H.dataProvider().extent()
xmin = raster_extent.xMinimum()
xmax = raster_extent.xMaximum()
ymin = raster_extent.yMinimum()
ymax = raster_extent.yMaximum()
x_delta = (xmax - xmin) / H.width()
x = xmin
for i in range(H.width()):
if abs(x - clip_xmin) < x_delta:
# We have found the aligned raster boundary
break
x += x_delta
_ = i
y_delta = (ymax - ymin) / H.height()
y = ymin
for i in range(H.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 and polygonize
small_raster = clip_raster(
H, width, height, QgsRectangle(*clip_extent))
(flooded_polygon_inside, flooded_polygon_outside) = polygonize_gdal(
small_raster, threshold_min, threshold_max)
# Filter geometry and data using the extent
extent = QgsRectangle(*self.requested_extent)
request = QgsFeatureRequest()
request.setFilterRect(extent)
if flooded_polygon_inside is None:
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)
# reproject the flood polygons to exposure projection
exposure_crs = E.crs()
exposure_authid = exposure_crs.authid()
if hazard_authid != exposure_authid:
flooded_polygon_inside = reproject_vector_layer(
flooded_polygon_inside, E.crs())
flooded_polygon_outside = reproject_vector_layer(
flooded_polygon_outside, E.crs())
# Clip exposure by the extent
# extent_as_polygon = QgsGeometry().fromRect(extent)
# no need to clip since It is using a bbox request
# line_layer = clip_by_polygon(
# E,
# extent_as_polygon
# )
# Find inundated roads, mark them
line_layer = split_by_polygon_in_out(
E,
flooded_polygon_inside,
flooded_polygon_outside,
target_field, 1, request)
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(E.crs(), output_crs)
road_len = flooded_len = 0 # Length of roads
roads_by_type = dict() # Length of flooded roads by types
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_type_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()
road_len += length
if road_type not in roads_by_type:
roads_by_type[road_type] = {'flooded': 0, 'total': 0}
roads_by_type[road_type]['total'] += length
if attributes[target_field_index] == 1:
flooded_len += length
roads_by_type[road_type]['flooded'] += length
table_body = self._tabulate(flooded_len, self.question, road_len,
roads_by_type)
impact_summary = Table(table_body).toNewlineFreeString()
map_title = tr('Roads inundated')
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,
'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
"""
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, layers=None):
"""Experimental impact function."""
self.validate()
self.prepare(layers)
target_field = self.target_field
road_type_field = self.parameters['road_type_field']
threshold_min = self.parameters['min threshold [m]']
threshold_max = self.parameters['max threshold [m]']
if threshold_min > threshold_max:
message = tr('''The minimal threshold is
greater then the maximal specified threshold.
Please check the values.''')
raise GetDataError(message)
# Extract data
H = self.hazard # Flood
E = self.exposure # Roads
H = H.get_layer()
E = E.get_layer()
# Get necessary width and height of raster
height = (self.requested_extent[3] -
self.requested_extent[1]) / (H.rasterUnitsPerPixelY())
height = int(height)
width = (self.requested_extent[2] -
self.requested_extent[0]) / (H.rasterUnitsPerPixelX())
width = int(width)
# Align raster extent and self.extent
raster_extent = H.dataProvider().extent()
xmin = raster_extent.xMinimum()
xmax = raster_extent.xMaximum()
ymin = raster_extent.yMinimum()
ymax = raster_extent.yMaximum()
x_delta = (xmax - xmin) / H.width()
x = xmin
for i in range(H.width()):
if abs(x - self.requested_extent[0]) < x_delta:
# We have found the aligned raster boundary
break
x += x_delta
_ = i
y_delta = (ymax - ymin) / H.height()
y = ymin
for i in range(H.width()):
if abs(y - self.requested_extent[1]) < 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 and polygonize
small_raster = clip_raster(H, width, height,
QgsRectangle(*clip_extent))
flooded_polygon = polygonize(small_raster, threshold_min,
threshold_max)
# Filter geometry and data using the extent
requested_extent = QgsRectangle(*self.requested_extent)
request = QgsFeatureRequest()
request.setFilterRect(requested_extent)
if flooded_polygon is None:
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)
# Clip exposure by the extent
extent_as_polygon = QgsGeometry().fromRect(requested_extent)
line_layer = clip_by_polygon(E, extent_as_polygon)
# Find inundated roads, mark them
line_layer = split_by_polygon(line_layer,
flooded_polygon,
request,
mark_value=(target_field, 1))
# Find inundated roads, mark them
# line_layer = split_by_polygon(
# E,
# flooded_polygon,
# request,
# mark_value=(target_field, 1))
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(E.crs(), output_crs)
road_len = flooded_len = 0 # Length of roads
roads_by_type = dict() # Length of flooded roads by types
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_type_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()
road_len += length
if road_type not in roads_by_type:
roads_by_type[road_type] = {'flooded': 0, 'total': 0}
roads_by_type[road_type]['total'] += length
if attributes[target_field_index] == 1:
flooded_len += length
roads_by_type[road_type]['flooded'] += length
table_body = self._tabulate(flooded_len, self.question, road_len,
roads_by_type)
impact_summary = Table(table_body).toNewlineFreeString()
map_title = tr('Roads inundated')
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,
'target_field': target_field
},
style_info=style_info)
self._impact = line_layer
return line_layer
def run(self, layers=None):
"""Experimental impact function."""
self.validate()
self.prepare(layers)
target_field = self.target_field
road_type_field = self.parameters['road_type_field']
threshold_min = self.parameters['min threshold [m]']
threshold_max = self.parameters['max threshold [m]']
if threshold_min > threshold_max:
message = tr('''The minimal threshold is
greater then the maximal specified threshold.
Please check the values.''')
raise GetDataError(message)
# Extract data
H = self.hazard # Flood
E = self.exposure # Roads
H = H.get_layer()
E = E.get_layer()
# Get necessary width and height of raster
height = (self.requested_extent[3] - self.requested_extent[1]) / (
H.rasterUnitsPerPixelY())
height = int(height)
width = (self.requested_extent[2] - self.requested_extent[0]) / (
H.rasterUnitsPerPixelX())
width = int(width)
# Align raster extent and self.extent
raster_extent = H.dataProvider().extent()
xmin = raster_extent.xMinimum()
xmax = raster_extent.xMaximum()
ymin = raster_extent.yMinimum()
ymax = raster_extent.yMaximum()
x_delta = (xmax - xmin) / H.width()
x = xmin
for i in range(H.width()):
if abs(x - self.requested_extent[0]) < x_delta:
# We have found the aligned raster boundary
break
x += x_delta
_ = i
y_delta = (ymax - ymin) / H.height()
y = ymin
for i in range(H.width()):
if abs(y - self.requested_extent[1]) < 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 and polygonize
small_raster = clip_raster(
H, width, height, QgsRectangle(*clip_extent))
flooded_polygon = polygonize(
small_raster, threshold_min, threshold_max)
# Filter geometry and data using the extent
requested_extent = QgsRectangle(*self.requested_extent)
request = QgsFeatureRequest()
request.setFilterRect(requested_extent)
if flooded_polygon is None:
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)
# Clip exposure by the extent
extent_as_polygon = QgsGeometry().fromRect(requested_extent)
line_layer = clip_by_polygon(
E,
extent_as_polygon
)
# Find inundated roads, mark them
line_layer = split_by_polygon(
line_layer,
flooded_polygon,
request,
mark_value=(target_field, 1))
# Find inundated roads, mark them
# line_layer = split_by_polygon(
# E,
# flooded_polygon,
# request,
# mark_value=(target_field, 1))
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(E.crs(), output_crs)
road_len = flooded_len = 0 # Length of roads
roads_by_type = dict() # Length of flooded roads by types
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(road_type_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()
road_len += length
if road_type not in roads_by_type:
roads_by_type[road_type] = {'flooded': 0, 'total': 0}
roads_by_type[road_type]['total'] += length
if attributes[target_field_index] == 1:
flooded_len += length
roads_by_type[road_type]['flooded'] += length
table_body = self._tabulate(flooded_len, self.question, road_len,
roads_by_type)
impact_summary = Table(table_body).toNewlineFreeString()
map_title = tr('Roads inundated')
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,
'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
"""
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
