def read_from_qgis_native(self, qgis_layer):
"""Read raster data from qgis layer QgsRasterLayer.
A stub is used now:
save all data in a file,
then call safe.read_from_file
Raises:
* TypeError if qgis is not avialable
* IOError if can't store temporary file
* GetDataError if can't create copy of qgis_layer's
dataProvider
"""
base_name = unique_filename()
file_name = base_name + '.tif'
file_writer = QgsRasterFileWriter(file_name)
pipe = QgsRasterPipe()
provider = qgis_layer.dataProvider()
if not pipe.set(provider.clone()):
msg = "Cannot set pipe provider"
raise GetDataError(msg)
file_writer.writeRaster(pipe, provider.xSize(), provider.ySize(),
provider.extent(), provider.crs())
# Write keywords if any
write_keywords(self.keywords, base_name + '.keywords')
self.read_from_file(file_name)
def polygonize_gdal(
raster,
threshold_min=0.0,
threshold_max=float('inf')):
"""
Function to polygonize raster. Areas (pixels) with threshold_min <
pixel_values < threshold_max will be converted to polygons.
:param raster: Raster layer
:type raster: QgsRasterLayer
:param threshold_min: Value that splits raster to flooded or not flooded.
:type threshold_min: float
:param threshold_max: Value that splits raster to flooded or not flooded.
:type threshold_max: float
:returns: Polygonal geometry
:rtype: QgsGeometry
"""
# save qgis raster to disk
base_name = unique_filename()
file_name = base_name + '.tif'
file_writer = QgsRasterFileWriter(file_name)
pipe = QgsRasterPipe()
provider = raster.dataProvider()
if not pipe.set(provider.clone()):
msg = "Cannot set pipe provider"
raise GetDataError(msg)
file_writer.writeRaster(
pipe,
provider.xSize(),
provider.ySize(),
provider.extent(),
provider.crs())
(
inside_file_name,
inside_layer_name,
outside_file_name,
outside_layer_name
) = polygonize_thresholds(file_name, threshold_min, threshold_max)
inside_layer = \
QgsVectorLayer(inside_file_name, inside_layer_name, 'ogr')
outside_layer = \
QgsVectorLayer(outside_file_name, outside_layer_name, 'ogr')
if inside_layer.featureCount() == 0:
return None, None
else:
return inside_layer, outside_layer
def get_data(self, attribute=None, index=None, copy=False):
"""Get vector attributes
Note:
Data is returned as a list where each entry is a dictionary of
attributes for one feature. Entries in get_geometry() and
get_data() are related as 1-to-1
If optional argument attribute is specified and a valid name,
then the list of values for that attribute is returned.
If optional argument index is specified on the that value will
be returned. Any value of index is ignored if attribute is None.
If optional argument copy is True and all attributes are requested,
a copy will be returned. Otherwise a pointer to the data is
returned.
"""
if hasattr(self, 'data'):
if attribute is None:
if copy:
return copy_module.deepcopy(self.data)
else:
return self.data
else:
msg = ('Specified attribute %s does not exist in '
'vector layer %s. Valid names are %s'
'' % (attribute, self, self.data[0].keys()))
verify(attribute in self.data[0], msg)
if index is None:
# Return all values for specified attribute
return [x[attribute] for x in self.data]
else:
# Return value for specified attribute and index
msg = ('Specified index must be either None or '
'an integer. I got %s' % index)
verify(type(index) == type(0), msg)
msg = ('Specified index must lie within the bounds '
'of vector layer %s which is [%i, %i]'
'' % (self, 0, len(self) - 1))
verify(0 <= index < len(self), msg)
return self.data[index][attribute]
else:
msg = 'Vector data instance does not have any attributes'
raise GetDataError(msg)
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, layers):
"""Experimental impact function for flood polygons on roads.
:param layers: List of layers expected to contain H: Polygon layer of
inundation areas E: Vector layer of roads
"""
target_field = self.parameters['target_field']
road_type_field = self.parameters['road_type_field']
affected_field = self.parameters['affected_field']
affected_value = self.parameters['affected_value']
# Extract data
hazard = get_hazard_layer(layers) # Flood
exposure = get_exposure_layer(layers) # Roads
question = get_question(hazard.get_name(), exposure.get_name(), self)
hazard = hazard.get_layer()
hazard_provider = hazard.dataProvider()
affected_field_index = hazard_provider.fieldNameIndex(affected_field)
# see #818: should still work if there is no valid attribute
if affected_field_index == -1:
pass
# message = tr('''Parameter "Affected Field"(='%s')
# is not present in the attribute table of the hazard layer.
# ''' % (affected_field, ))
# raise GetDataError(message)
LOGGER.info('Affected field: %s' % affected_field)
LOGGER.info('Affected field index: %s' % affected_field_index)
exposure = exposure.get_layer()
# Filter geometry and data using the extent
extent = QgsRectangle(*self.extent)
request = QgsFeatureRequest()
request.setFilterRect(extent)
# Split line_layer by hazard and save as result:
# 1) Filter from hazard inundated features
# 2) Mark roads as inundated (1) or not inundated (0)
if affected_field_index != -1:
affected_field_type = hazard_provider.fields(
)[affected_field_index].typeName()
if affected_field_type in ['Real', 'Integer']:
affected_value = float(affected_value)
#################################
# REMARK 1
# In qgis 2.2 we can use request to filter inundated
# polygons directly (it allows QgsExpression). Then
# we can delete the lines and call
#
# request = ....
# hazard_poly = union_geometry(H, request)
#
################################
hazard_features = hazard.getFeatures(request)
hazard_poly = None
for feature in hazard_features:
attributes = feature.attributes()
if affected_field_index != -1:
if attributes[affected_field_index] != affected_value:
continue
if hazard_poly is None:
hazard_poly = QgsGeometry(feature.geometry())
else:
# Make geometry union of inundated polygons
# But some feature.geometry() could be invalid, skip them
tmp_geometry = hazard_poly.combine(feature.geometry())
try:
if tmp_geometry.isGeosValid():
hazard_poly = tmp_geometry
except AttributeError:
pass
###############################################
# END REMARK 1
###############################################
if hazard_poly is None:
message = tr(
'''There are no objects in the hazard layer with "Affected
value"='%s'. Please check the value or use a different
extent.''' % (affected_value, ))
raise GetDataError(message)
# Clip exposure by the extent
extent_as_polygon = QgsGeometry().fromRect(extent)
line_layer = clip_by_polygon(exposure, extent_as_polygon)
# Find inundated roads, mark them
line_layer = split_by_polygon(line_layer,
hazard_poly,
request,
mark_value=(target_field, 1))
# Generate simple impact report
epsg = get_utm_epsg(self.extent[0], self.extent[1])
destination_crs = QgsCoordinateReferenceSystem(epsg)
transform = QgsCoordinateTransform(exposure.crs(), destination_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)
target_field_index = line_layer.fieldNameIndex(target_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 = [
question,
TableRow([
tr('Road Type'),
tr('Temporarily closed (m)'),
tr('Total (m)')
],
header=True),
TableRow([tr('All'), int(flooded_len),
int(road_len)]),
TableRow(tr('Breakdown by road type'), header=True)
]
for road_type, value in roads_by_type.iteritems():
table_body.append(
TableRow(
[road_type,
int(value['flooded']),
int(value['total'])]))
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)
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 get_data(self, nan=True, scaling=None, copy=False):
"""Get raster data as numeric array
Args:
* nan: Optional flag controlling handling of missing values.
If keyword nan has a numeric value, nodata values will
be replaced by that value. E.g. to set missing values to 0,
do get_data(nan=0.0)
NOTE: The following behaviour is depricated,
since we handle this on file load:
[If nan is True (default), nodata values will be replaced
with numpy.nan]
* scaling: Optional flag controlling if data is to be scaled
if it has been resampled. Admissible values are
False: data is retrieved without modification.
True: Data is rescaled based on the squared ratio
between its current and native resolution. This
is typically required if raster data represents a
density such as population per km^2
None: The behaviour will depend on the keyword
"population" associated with the layer. If
it is "density", scaling will be applied
otherwise not. This is the default.
scalar value: If scaling takes a numerical scalar value,
that will be use to scale the data
* copy (optional): If present and True return copy
Note:
Scaling does not currently work with projected layers.
See issue #123
"""
if copy:
A = copy_module.deepcopy(self.data)
else:
A = self.data
verify(A.shape[0] == self.rows and A.shape[1] == self.columns)
# Handle no data value
# Must explicit comparison to False and True as nan can be a number
# so 0 would evaluate to False and e.g. 1 to True.
if type(nan) is not bool:
# We are handling all non-NaN's in read_from_file and
# assuming NaN's in internal numpy arrays [issue #297].
try:
# Use user specified number
new_nodata_value = float(nan)
except (ValueError, TypeError):
msg = ('Argument nan must be either True, False or a '
'number. I got "nan=%s"' % str(nan))
raise InaSAFEError(msg)
# Replace NODATA_VALUE with NaN array
NoData = numpy.ones(A.shape, A.dtype) * new_nodata_value
A = numpy.where(numpy.isnan(A), NoData, A)
# Take care of possible scaling
if scaling is None:
# Redefine scaling from density keyword if possible
kw = self.get_keywords()
if 'datatype' in kw and kw['datatype'].lower() == 'density':
scaling = True
else:
scaling = False
if scaling is False:
# No change
sigma = 1
elif scaling is True:
# Calculate scaling based on resolution change
actual_res = self.get_resolution(isotropic=True)
native_res = self.get_resolution(isotropic=True, native=True)
sigma = (actual_res / native_res)**2
else:
# See if scaling can work as a scalar value
try:
sigma = float(scaling)
except ValueError, e:
msg = ('Keyword scaling "%s" could not be converted to a '
'number. It must be either True, False, None or a '
'number: %s' % (scaling, str(e)))
raise GetDataError(msg)
def get_data(self, nan=True, scaling=None, copy=False):
"""Get raster data as numeric array
Args:
* nan: Optional flag controlling handling of missing values.
If nan is True (default), nodata values will be replaced
with numpy.nan
If keyword nan has a numeric value, nodata values will
be replaced by that value. E.g. to set missing values to 0,
do get_data(nan=0.0)
* scaling: Optional flag controlling if data is to be scaled
if it has been resampled. Admissible values are
False: data is retrieved without modification.
True: Data is rescaled based on the squared ratio
between its current and native resolution. This
is typically required if raster data represents a
density such as population per km^2
None: The behaviour will depend on the keyword
"population" associated with the layer. If
it is "density", scaling will be applied
otherwise not. This is the default.
scalar value: If scaling takes a numerical scalar value,
that will be use to scale the data
* copy (optional): If present and True return copy
Note:
Scaling does not currently work with projected layers.
See issue #123
"""
if hasattr(self, 'data') and self.data is not None:
# Return internal data grid
if copy:
A = copy_module.deepcopy(self.data)
else:
A = self.data
verify(A.shape[0] == self.rows and A.shape[1] == self.columns)
else:
# Force garbage collection to free up any memory we can (TS)
gc.collect()
# Read from raster file
# FIXME: This can be slow so should be moved to read_from_file
A = self.band.ReadAsArray()
# Convert to double precision (issue #75)
A = numpy.array(A, dtype=numpy.float64)
# Self check
M, N = A.shape
msg = ('Dimensions of raster array do not match those of '
'raster file %s' % self.filename)
verify(M == self.rows, msg)
verify(N == self.columns, msg)
# Handle no data value
# FIXME (Ole): This only pertains to data read from file
# and should be moved to read_from_file.
nodata = self.get_nodata_value()
# Must explicit comparison to False and True as nan can be a number
# so 0 would evaluate to False and e.g. 1 to True.
if nan is False:
# No change
pass
else:
# Nan value should be changed
if nan is True:
NAN = numpy.nan # Use numpy's nan value
else:
try:
# Use user specified number
NAN = float(nan)
except (ValueError, TypeError):
msg = ('Argument nan must be either True, False or a '
'number. I got "nan=%s"' % str(nan))
raise InaSAFEError(msg)
# Replace NODATA_VALUE with NaN array
#print 'Replacing', nodata, 'with', NAN
NaN = numpy.ones(A.shape, A.dtype) * NAN
A = numpy.where(A == nodata, NaN, A)
# Take care of possible scaling
if scaling is None:
# Redefine scaling from density keyword if possible
kw = self.get_keywords()
if 'datatype' in kw and kw['datatype'].lower() == 'density':
scaling = True
else:
scaling = False
if scaling is False:
# No change
sigma = 1
elif scaling is True:
# Calculate scaling based on resolution change
actual_res = self.get_resolution(isotropic=True)
native_res = self.get_resolution(isotropic=True, native=True)
#print
#print 'Actual res', actual_res
#print 'Native res', native_res
sigma = (actual_res / native_res)**2
#print 'Scaling', sigma
else:
# See if scaling can work as a scalar value
try:
sigma = float(scaling)
except ValueError, e:
msg = ('Keyword scaling "%s" could not be converted to a '
'number. It must be either True, False, None or a '
'number: %s' % (scaling, str(e)))
raise GetDataError(msg)
def run(self, layers):
"""Experimental impact function.
Input
layers: List of layers expected to contain
H: Polygon layer of inundation areas
E: Vector layer of roads
"""
target_field = self.parameters['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 = get_hazard_layer(layers) # Flood
E = get_exposure_layer(layers) # Roads
question = get_question(H.get_name(), E.get_name(), self)
H = H.get_layer()
E = E.get_layer()
# Get necessary width and height of raster
height = (self.extent[3] - self.extent[1]) / H.rasterUnitsPerPixelY()
height = int(height)
width = (self.extent[2] - self.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.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.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
extent = QgsRectangle(*self.extent)
request = QgsFeatureRequest()
request.setFilterRect(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(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.extent[0], self.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 = [
question,
TableRow([
tr('Road Type'),
tr('Flooded in the threshold (m)'),
tr('Total (m)')
],
header=True),
TableRow([tr('All'), int(flooded_len),
int(road_len)])
]
table_body.append(TableRow(tr('Breakdown by road type'), header=True))
for t, v in roads_by_type.iteritems():
table_body.append(TableRow([t,
int(v['flooded']),
int(v['total'])]))
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)
return line_layer
def run(self, layers):
"""Experimental impact function.
Input
layers: List of layers expected to contain
H: Polygon layer of inundation areas
E: Vector layer of roads
"""
target_field = self.parameters['target_field']
building_type_field = self.parameters['building_type_field']
affected_field = self.parameters['affected_field']
affected_value = self.parameters['affected_value']
# Extract data
H = get_hazard_layer(layers) # Flood
E = get_exposure_layer(layers) # Roads
question = get_question(H.get_name(), E.get_name(), self)
H = H.get_layer()
h_provider = H.dataProvider()
affected_field_index = h_provider.fieldNameIndex(affected_field)
if affected_field_index == -1:
message = tr('''Parameter "Affected Field"(='%s')
is not present in the
attribute table of the hazard layer.''' % (affected_field, ))
raise GetDataError(message)
E = E.get_layer()
srs = E.crs().toWkt()
e_provider = E.dataProvider()
fields = e_provider.fields()
# If target_field does not exist, add it:
if fields.indexFromName(target_field) == -1:
e_provider.addAttributes([QgsField(target_field, QVariant.Int)])
target_field_index = e_provider.fieldNameIndex(target_field)
fields = e_provider.fields()
# Create layer for store the lines from E and extent
building_layer = QgsVectorLayer('Polygon?crs=' + srs,
'impact_buildings', 'memory')
building_provider = building_layer.dataProvider()
# Set attributes
building_provider.addAttributes(fields.toList())
building_layer.startEditing()
building_layer.commitChanges()
# Filter geometry and data using the extent
extent = QgsRectangle(*self.extent)
request = QgsFeatureRequest()
request.setFilterRect(extent)
# Split building_layer by H and save as result:
# 1) Filter from H inundated features
# 2) Mark buildings as inundated (1) or not inundated (0)
affected_field_type = h_provider.fields(
)[affected_field_index].typeName()
if affected_field_type in ['Real', 'Integer']:
affected_value = float(affected_value)
h_data = H.getFeatures(request)
hazard_poly = None
for mpolygon in h_data:
attributes = mpolygon.attributes()
if attributes[affected_field_index] != affected_value:
continue
if hazard_poly is None:
hazard_poly = QgsGeometry(mpolygon.geometry())
else:
# Make geometry union of inundated polygons
# But some mpolygon.geometry() could be invalid, skip them
tmp_geometry = hazard_poly.combine(mpolygon.geometry())
try:
if tmp_geometry.isGeosValid():
hazard_poly = tmp_geometry
except AttributeError:
pass
if hazard_poly is None:
message = tr(
'''There are no objects in the hazard layer with "Affected
value"='%s'. Please check the value or use other extent.''' %
(affected_value, ))
raise GetDataError(message)
e_data = E.getFeatures(request)
for feat in e_data:
building_geom = feat.geometry()
attributes = feat.attributes()
l_feat = QgsFeature()
l_feat.setGeometry(building_geom)
l_feat.setAttributes(attributes)
if hazard_poly.intersects(building_geom):
l_feat.setAttribute(target_field_index, 1)
else:
l_feat.setAttribute(target_field_index, 0)
(_, __) = building_layer.dataProvider().addFeatures([l_feat])
building_layer.updateExtents()
# Generate simple impact report
building_count = flooded_count = 0 # Count of buildings
buildings_by_type = dict() # Length of flooded roads by types
buildings_data = building_layer.getFeatures()
building_type_field_index = building_layer.fieldNameIndex(
building_type_field)
for building in buildings_data:
building_count += 1
attributes = building.attributes()
building_type = attributes[building_type_field_index]
if building_type in [None, 'NULL', 'null', 'Null']:
building_type = 'Unknown type'
if building_type not in buildings_by_type:
buildings_by_type[building_type] = {'flooded': 0, 'total': 0}
buildings_by_type[building_type]['total'] += 1
if attributes[target_field_index] == 1:
flooded_count += 1
buildings_by_type[building_type]['flooded'] += 1
table_body = [
question,
TableRow([tr('Building Type'),
tr('Flooded'),
tr('Total')],
header=True),
TableRow([tr('All'),
int(flooded_count),
int(building_count)]),
TableRow(tr('Breakdown by building type'), header=True)
]
for t, v in buildings_by_type.iteritems():
table_body.append(TableRow([t,
int(v['flooded']),
int(v['total'])]))
impact_summary = Table(table_body).toNewlineFreeString()
map_title = tr('Buildings 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.
building_layer = Vector(data=building_layer,
name=tr('Flooded buildings'),
keywords={
'impact_summary': impact_summary,
'map_title': map_title,
'target_field': target_field
},
style_info=style_info)
return building_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):
"""Experimental impact function for flood polygons on roads."""
self.validate()
self.prepare()
# Get parameters from layer's keywords
self.hazard_class_attribute = self.hazard.keyword('field')
self.hazard_class_mapping = self.hazard.keyword('value_map')
self.exposure_class_attribute = self.exposure.keyword(
'road_class_field')
hazard_provider = self.hazard.layer.dataProvider()
affected_field_index = hazard_provider.fieldNameIndex(
self.hazard_class_attribute)
# see #818: should still work if there is no valid attribute
if affected_field_index == -1:
pass
# message = tr('''Parameter "Affected Field"(='%s')
# is not present in the attribute table of the hazard layer.
# ''' % (affected_field, ))
# raise GetDataError(message)
LOGGER.info('Affected field: %s' % self.hazard_class_attribute)
LOGGER.info('Affected field index: %s' % affected_field_index)
# Filter geometry and data using the extent
requested_extent = QgsRectangle(*self.requested_extent)
# This is a hack - we should be setting the extent CRS
# in the IF base class via safe/engine/core.py:calculate_impact
# for now we assume the extent is in 4326 because it
# is set to that from geo_extent
# See issue #1857
transform = QgsCoordinateTransform(
QgsCoordinateReferenceSystem('EPSG:%i' %
self._requested_extent_crs),
self.hazard.layer.crs())
projected_extent = transform.transformBoundingBox(requested_extent)
request = QgsFeatureRequest()
request.setFilterRect(projected_extent)
# Split line_layer by hazard and save as result:
# 1) Filter from hazard inundated features
# 2) Mark roads as inundated (1) or not inundated (0)
#################################
# REMARK 1
# In qgis 2.2 we can use request to filter inundated
# polygons directly (it allows QgsExpression). Then
# we can delete the lines and call
#
# request = ....
# hazard_poly = union_geometry(H, request)
#
################################
hazard_features = self.hazard.layer.getFeatures(request)
hazard_poly = None
for feature in hazard_features:
attributes = feature.attributes()
if affected_field_index != -1:
value = attributes[affected_field_index]
if value not in self.hazard_class_mapping[self.wet]:
continue
if hazard_poly is None:
hazard_poly = QgsGeometry(feature.geometry())
else:
# Make geometry union of inundated polygons
# But some feature.geometry() could be invalid, skip them
tmp_geometry = hazard_poly.combine(feature.geometry())
try:
if tmp_geometry.isGeosValid():
hazard_poly = tmp_geometry
except AttributeError:
pass
###############################################
# END REMARK 1
###############################################
if hazard_poly is None:
message = tr(
'There are no objects in the hazard layer with %s (Affected '
'Field) in %s (Affected Value). Please check the value or use '
'a different extent.' % (self.hazard_class_attribute,
self.hazard_class_mapping[self.wet]))
raise GetDataError(message)
# Clip exposure by the extent
extent_as_polygon = QgsGeometry().fromRect(requested_extent)
line_layer = clip_by_polygon(self.exposure.layer, extent_as_polygon)
# Find inundated roads, mark them
line_layer = split_by_polygon(line_layer,
hazard_poly,
request,
mark_value=(self.target_field, 1))
# Generate simple impact report
epsg = get_utm_epsg(self.requested_extent[0], self.requested_extent[1])
destination_crs = QgsCoordinateReferenceSystem(epsg)
transform = QgsCoordinateTransform(self.exposure.layer.crs(),
destination_crs)
roads_data = line_layer.getFeatures()
road_type_field_index = line_layer.fieldNameIndex(
self.exposure_class_attribute)
target_field_index = line_layer.fieldNameIndex(self.target_field)
flooded_keyword = tr('Temporarily closed (m)')
self.affected_road_categories = [flooded_keyword]
self.affected_road_lengths = OrderedDict([(flooded_keyword, {})])
self.road_lengths = OrderedDict()
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=self.target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
# Convert QgsVectorLayer to inasafe layer and return it
if line_layer.featureCount() == 0:
# Raising an exception seems poor semantics here....
raise ZeroImpactException(
tr('No roads are flooded in this scenario.'))
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': self.target_field
},
style_info=style_info)
self._impact = line_layer
return line_layer
def get_data(self, nan=True, scaling=None, copy=False,
rtol=1.0e-2, atol=1.0e-6):
"""Get raster data as numeric array
Args:
* nan: Optional flag controlling handling of missing values.
If nan is True (default), nodata values will be replaced
with numpy.nan
If keyword nan has a numeric value, nodata values will
be replaced by that value. E.g. to set missing values to 0,
do get_data(nan=0.0)
* scaling: Optional flag controlling if data is to be scaled
if it has been resampled. Admissible values are
False: data is retrieved without modification.
True: Data is rescaled based on the squared ratio
between its current and native resolution. This
is typically required if raster data represents a
density such as population per km^2
None: The behaviour will depend on the keyword
"population" associated with the layer. If
it is "density", scaling will be applied
otherwise not. This is the default.
scalar value: If scaling takes a numerical scalar value,
that will be use to scale the data
* copy (optional): If present and True return copy
* rtol, atol: Tolerances as to how much difference is accepted
between dx and dy when scaling is True.
Note:
Scaling does not currently work with projected layers.
See issue #123
"""
if hasattr(self, 'data') and self.data is not None:
if copy:
A = copy_module.deepcopy(self.data)
else:
A = self.data
verify(A.shape[0] == self.rows and A.shape[1] == self.columns)
else:
# Read from raster file
A = self.band.ReadAsArray()
# Convert to double precision (issue #75)
A = numpy.array(A, dtype=numpy.float64)
# Self check
M, N = A.shape
msg = ('Dimensions of raster array do not match those of '
'raster file %s' % self.filename)
verify(M == self.rows, msg)
verify(N == self.columns, msg)
# Handle no data value
if nan is False:
pass
else:
if nan is True:
NAN = numpy.nan
else:
# E.g. if nan is a number
NAN = nan
# Replace NODATA_VALUE with NaN
nodata = self.get_nodata_value()
NaN = numpy.ones(A.shape, A.dtype) * NAN
A = numpy.where(A == nodata, NaN, A)
# Take care of possible scaling
if scaling is None:
# Redefine scaling from density keyword if possible
kw = self.get_keywords()
if 'datatype' in kw and kw['datatype'].lower() == 'density':
scaling = True
else:
scaling = False
if scaling is False:
# No change
sigma = 1
elif scaling is True:
# Calculate scaling based on resolution change
actual_res = self.get_resolution(isotropic=True,
rtol=rtol, atol=atol)
native_res = self.get_resolution(isotropic=True,
rtol=rtol, atol=atol, native=True)
#print
#print 'Actual res', actual_res
#print 'Native res', native_res
sigma = (actual_res / native_res) ** 2
#print 'Scaling', sigma
else:
# See if scaling can work as a scalar value
try:
sigma = float(scaling)
except ValueError, e:
msg = ('Keyword scaling "%s" could not be converted to a '
'number. It must be either True, False, None or a '
'number: %s' % (scaling, str(e)))
raise GetDataError(msg)
def run(self):
"""Experimental impact function."""
self.validate()
self.prepare()
self.provenance.append_step(
'Calculating Step',
'Impact function is calculating the impact.')
# Get parameters from layer's keywords
self.hazard_class_attribute = self.hazard.keyword('field')
self.hazard_class_mapping = self.hazard.keyword('value_map')
self.exposure_class_attribute = self.exposure.keyword(
'structure_class_field')
# Prepare Hazard Layer
hazard_provider = self.hazard.layer.dataProvider()
# Check affected field exists in the hazard layer
affected_field_index = hazard_provider.fieldNameIndex(
self.hazard_class_attribute)
if affected_field_index == -1:
message = tr(
'Field "%s" is not present in the attribute table of the '
'hazard layer. Please change the Affected Field parameter in '
'the IF Option.') % self.hazard_class_attribute
raise GetDataError(message)
srs = self.exposure.layer.crs().toWkt()
exposure_provider = self.exposure.layer.dataProvider()
exposure_fields = exposure_provider.fields()
# Check self.exposure_class_attribute exists in exposure layer
building_type_field_index = exposure_provider.fieldNameIndex(
self.exposure_class_attribute)
if building_type_field_index == -1:
message = tr(
'Field "%s" is not present in the attribute table of '
'the exposure layer. Please change the Building Type '
'Field parameter in the IF Option.'
) % self.exposure_class_attribute
raise GetDataError(message)
# If target_field does not exist, add it:
if exposure_fields.indexFromName(self.target_field) == -1:
exposure_provider.addAttributes(
[QgsField(self.target_field, QVariant.Int)])
target_field_index = exposure_provider.fieldNameIndex(
self.target_field)
exposure_fields = exposure_provider.fields()
# Create layer to store the buildings from E and extent
buildings_are_points = is_point_layer(self.exposure.layer)
if buildings_are_points:
building_layer = QgsVectorLayer(
'Point?crs=' + srs, 'impact_buildings', 'memory')
else:
building_layer = QgsVectorLayer(
'Polygon?crs=' + srs, 'impact_buildings', 'memory')
building_provider = building_layer.dataProvider()
# Set attributes
building_provider.addAttributes(exposure_fields.toList())
building_layer.startEditing()
building_layer.commitChanges()
# Filter geometry and data using the requested extent
requested_extent = QgsRectangle(*self.requested_extent)
# This is a hack - we should be setting the extent CRS
# in the IF base class via safe/engine/core.py:calculate_impact
# for now we assume the extent is in 4326 because it
# is set to that from geo_extent
# See issue #1857
transform = QgsCoordinateTransform(
self.requested_extent_crs, self.hazard.crs())
projected_extent = transform.transformBoundingBox(requested_extent)
request = QgsFeatureRequest()
request.setFilterRect(projected_extent)
# Split building_layer by H and save as result:
# 1) Filter from H inundated features
# 2) Mark buildings as inundated (1) or not inundated (0)
# make spatial index of affected polygons
hazard_index = QgsSpatialIndex()
hazard_geometries = {} # key = feature id, value = geometry
has_hazard_objects = False
for feature in self.hazard.layer.getFeatures(request):
value = feature[affected_field_index]
if value not in self.hazard_class_mapping[self.wet]:
continue
hazard_index.insertFeature(feature)
hazard_geometries[feature.id()] = QgsGeometry(feature.geometry())
has_hazard_objects = True
if not has_hazard_objects:
message = tr(
'There are no objects in the hazard layer with %s '
'value in %s. Please check your data or use another '
'attribute.') % (
self.hazard_class_attribute,
', '.join(self.hazard_class_mapping[self.wet]))
raise GetDataError(message)
# Filter out just those EXPOSURE features in the analysis extents
transform = QgsCoordinateTransform(
self.requested_extent_crs, self.exposure.layer.crs())
projected_extent = transform.transformBoundingBox(requested_extent)
request = QgsFeatureRequest()
request.setFilterRect(projected_extent)
# We will use this transform to project each exposure feature into
# the CRS of the Hazard.
transform = QgsCoordinateTransform(
self.exposure.crs(), self.hazard.crs())
features = []
for feature in self.exposure.layer.getFeatures(request):
# Make a deep copy as the geometry is passed by reference
# If we don't do this, subsequent operations will affect the
# original feature geometry as well as the copy TS
building_geom = QgsGeometry(feature.geometry())
# Project the building geometry to hazard CRS
building_bounds = transform.transform(building_geom.boundingBox())
affected = False
# get tentative list of intersecting hazard features
# only based on intersection of bounding boxes
ids = hazard_index.intersects(building_bounds)
for fid in ids:
# run (slow) exact intersection test
building_geom.transform(transform)
if hazard_geometries[fid].intersects(building_geom):
affected = True
break
new_feature = QgsFeature()
# We write out the original feature geom, not the projected one
new_feature.setGeometry(feature.geometry())
new_feature.setAttributes(feature.attributes())
new_feature[target_field_index] = 1 if affected else 0
features.append(new_feature)
# every once in a while commit the created features
# to the output layer
if len(features) == 1000:
(_, __) = building_provider.addFeatures(features)
features = []
(_, __) = building_provider.addFeatures(features)
building_layer.updateExtents()
# Generate simple impact report
self.buildings = {}
self.affected_buildings = OrderedDict([
(tr('Flooded'), {})
])
buildings_data = building_layer.getFeatures()
building_type_field_index = building_layer.fieldNameIndex(
self.exposure_class_attribute)
for building in buildings_data:
record = building.attributes()
building_type = record[building_type_field_index]
if building_type in [None, 'NULL', 'null', 'Null']:
building_type = 'Unknown type'
if building_type not in self.buildings:
self.buildings[building_type] = 0
for category in self.affected_buildings.keys():
self.affected_buildings[category][
building_type] = OrderedDict([
(tr('Buildings Affected'), 0)])
self.buildings[building_type] += 1
if record[target_field_index] == 1:
self.affected_buildings[tr('Flooded')][building_type][
tr('Buildings Affected')] += 1
# Lump small entries and 'unknown' into 'other' category
# Building threshold #2468
postprocessors = self.parameters['postprocessors']
building_postprocessors = postprocessors['BuildingType'][0]
self.building_report_threshold = building_postprocessors.value[0].value
self._consolidate_to_other()
impact_summary = self.html_report()
# For printing map purpose
map_title = tr('Buildings inundated')
legend_title = tr('Structure 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=self.target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
# Convert QgsVectorLayer to inasafe layer and return it.
if building_layer.featureCount() < 1:
raise ZeroImpactException(tr(
'No buildings were impacted by this flood.'))
extra_keywords = {
'impact_summary': impact_summary,
'map_title': map_title,
'legend_title': legend_title,
'target_field': self.target_field,
'buildings_total': self.total_buildings,
'buildings_affected': self.total_affected_buildings
}
self.set_if_provenance()
impact_layer_keywords = self.generate_impact_keywords(extra_keywords)
building_layer = Vector(
data=building_layer,
name=tr('Flooded buildings'),
keywords=impact_layer_keywords,
style_info=style_info)
self._impact = building_layer
return building_layer
def run(self, layers=None):
"""Experimental impact function for flood polygons on roads.
:param layers: List of layers expected to contain H: Polygon layer of
inundation areas E: Vector layer of roads
"""
self.validate()
self.prepare(layers)
# Set the target field
target_field = 'FLOODED'
# Get the parameters from IF options
road_type_field = self.parameters['road_type_field']
affected_field = self.parameters['affected_field']
affected_value = self.parameters['affected_value']
# Extract data
hazard_layer = self.hazard # Flood
exposure_layer = self.exposure # Roads
hazard_layer = hazard_layer.get_layer()
hazard_provider = hazard_layer.dataProvider()
affected_field_index = hazard_provider.fieldNameIndex(affected_field)
# see #818: should still work if there is no valid attribute
if affected_field_index == -1:
pass
# message = tr('''Parameter "Affected Field"(='%s')
# is not present in the attribute table of the hazard layer.
# ''' % (affected_field, ))
# raise GetDataError(message)
LOGGER.info('Affected field: %s' % affected_field)
LOGGER.info('Affected field index: %s' % affected_field_index)
exposure_layer = exposure_layer.get_layer()
# Filter geometry and data using the extent
requested_extent = QgsRectangle(*self.requested_extent)
# This is a hack - we should be setting the extent CRS
# in the IF base class via safe/engine/core.py:calculate_impact
# for now we assume the extent is in 4326 because it
# is set to that from geo_extent
# See issue #1857
transform = QgsCoordinateTransform(
QgsCoordinateReferenceSystem(
'EPSG:%i' % self._requested_extent_crs),
hazard_layer.crs()
)
projected_extent = transform.transformBoundingBox(requested_extent)
request = QgsFeatureRequest()
request.setFilterRect(projected_extent)
# Split line_layer by hazard and save as result:
# 1) Filter from hazard inundated features
# 2) Mark roads as inundated (1) or not inundated (0)
if affected_field_index != -1:
affected_field_type = hazard_provider.fields()[
affected_field_index].typeName()
if affected_field_type in ['Real', 'Integer']:
affected_value = float(affected_value)
#################################
# REMARK 1
# In qgis 2.2 we can use request to filter inundated
# polygons directly (it allows QgsExpression). Then
# we can delete the lines and call
#
# request = ....
# hazard_poly = union_geometry(H, request)
#
################################
hazard_features = hazard_layer.getFeatures(request)
hazard_poly = None
for feature in hazard_features:
attributes = feature.attributes()
if affected_field_index != -1:
if attributes[affected_field_index] != affected_value:
continue
if hazard_poly is None:
hazard_poly = QgsGeometry(feature.geometry())
else:
# Make geometry union of inundated polygons
# But some feature.geometry() could be invalid, skip them
tmp_geometry = hazard_poly.combine(feature.geometry())
try:
if tmp_geometry.isGeosValid():
hazard_poly = tmp_geometry
except AttributeError:
pass
###############################################
# END REMARK 1
###############################################
if hazard_poly is None:
message = tr(
'There are no objects in the hazard layer with %s (Affected '
'Field) = %s (Affected Value). Please check the value or use '
'a different extent.' % (affected_field, affected_value))
raise GetDataError(message)
# Clip exposure by the extent
extent_as_polygon = QgsGeometry().fromRect(requested_extent)
line_layer = clip_by_polygon(exposure_layer, extent_as_polygon)
# Find inundated roads, mark them
line_layer = split_by_polygon(
line_layer, hazard_poly, request, mark_value=(target_field, 1))
# Generate simple impact report
epsg = get_utm_epsg(self.requested_extent[0], self.requested_extent[1])
destination_crs = QgsCoordinateReferenceSystem(epsg)
transform = QgsCoordinateTransform(
exposure_layer.crs(), destination_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)
target_field_index = line_layer.fieldNameIndex(target_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.
Input
layers: List of layers expected to contain
H: Polygon layer of inundation areas
E: Vector layer of buildings
"""
self.validate()
self.prepare(layers)
# Set the target field in impact layer
target_field = 'INUNDATED'
# Get the IF parameters
building_type_field = self.parameters['building_type_field']
affected_field = self.parameters['affected_field']
affected_value = self.parameters['affected_value']
# Extract data
hazard_layer = self.hazard # Flood
exposure_layer = self.exposure # Roads
# Prepare Hazard Layer
hazard_layer = hazard_layer.get_layer()
hazard_provider = hazard_layer.dataProvider()
# Check affected field exists in the hazard layer
affected_field_index = hazard_provider.fieldNameIndex(affected_field)
if affected_field_index == -1:
message = tr('Field "%s" is not present in the attribute table of '
'the hazard layer. Please change the Affected Field '
'parameter in the IF Option.') % affected_field
raise GetDataError(message)
# Prepare Exposure Layer
exposure_layer = exposure_layer.get_layer()
srs = exposure_layer.crs().toWkt()
exposure_provider = exposure_layer.dataProvider()
exposure_fields = exposure_provider.fields()
# Check building_type_field exists in exposure layer
building_type_field_index = exposure_provider.fieldNameIndex(
building_type_field)
if building_type_field_index == -1:
message = tr(
'Field "%s" is not present in the attribute table of '
'the exposure layer. Please change the Building Type '
'Field parameter in the IF Option.') % building_type_field
raise GetDataError(message)
# If target_field does not exist, add it:
if exposure_fields.indexFromName(target_field) == -1:
exposure_provider.addAttributes(
[QgsField(target_field, QVariant.Int)])
target_field_index = exposure_provider.fieldNameIndex(target_field)
exposure_fields = exposure_provider.fields()
# Create layer to store the lines from E and extent
building_layer = QgsVectorLayer('Polygon?crs=' + srs,
'impact_buildings', 'memory')
building_provider = building_layer.dataProvider()
# Set attributes
building_provider.addAttributes(exposure_fields.toList())
building_layer.startEditing()
building_layer.commitChanges()
# Filter geometry and data using the requested extent
requested_extent = QgsRectangle(*self.requested_extent)
# This is a hack - we should be setting the extent CRS
# in the IF base class via safe/engine/core.py:calculate_impact
# for now we assume the extent is in 4326 because it
# is set to that from geo_extent
# See issue #1857
transform = QgsCoordinateTransform(
QgsCoordinateReferenceSystem('EPSG:%i' %
self._requested_extent_crs),
hazard_layer.crs())
projected_extent = transform.transformBoundingBox(requested_extent)
request = QgsFeatureRequest()
request.setFilterRect(projected_extent)
# Split building_layer by H and save as result:
# 1) Filter from H inundated features
# 2) Mark buildings as inundated (1) or not inundated (0)
affected_field_type = hazard_provider.fields(
)[affected_field_index].typeName()
if affected_field_type in ['Real', 'Integer']:
affected_value = float(affected_value)
hazard_data = hazard_layer.getFeatures(request)
hazard_poly = None
for feature in hazard_data:
record = feature.attributes()
if record[affected_field_index] != affected_value:
continue
if hazard_poly is None:
hazard_poly = QgsGeometry(feature.geometry())
else:
# Make geometry union of inundated polygons
# But some polygon.geometry() could be invalid, skip them
tmp_geometry = hazard_poly.combine(feature.geometry())
try:
if tmp_geometry.isGeosValid():
hazard_poly = tmp_geometry
except AttributeError:
pass
if hazard_poly is None:
message = tr('There are no objects in the hazard layer with %s '
'value=%s. Please check your data or use another '
'attribute.') % (affected_field, affected_value)
raise GetDataError(message)
exposure_data = exposure_layer.getFeatures(request)
for feature in exposure_data:
building_geom = feature.geometry()
record = feature.attributes()
l_feat = QgsFeature()
l_feat.setGeometry(building_geom)
l_feat.setAttributes(record)
if hazard_poly.intersects(building_geom):
l_feat.setAttribute(target_field_index, 1)
else:
l_feat.setAttribute(target_field_index, 0)
(_, __) = building_layer.dataProvider().addFeatures([l_feat])
building_layer.updateExtents()
# Generate simple impact report
self.buildings = {}
self.affected_buildings = OrderedDict([(tr('Flooded'), {})])
buildings_data = building_layer.getFeatures()
building_type_field_index = building_layer.fieldNameIndex(
building_type_field)
for building in buildings_data:
record = building.attributes()
building_type = record[building_type_field_index]
if building_type in [None, 'NULL', 'null', 'Null']:
building_type = 'Unknown type'
if building_type not in self.buildings:
self.buildings[building_type] = 0
for category in self.affected_buildings.keys():
self.affected_buildings[category][
building_type] = OrderedDict([
(tr('Buildings Affected'), 0)
])
self.buildings[building_type] += 1
if record[target_field_index] == 1:
self.affected_buildings[tr('Flooded')][building_type][tr(
'Buildings Affected')] += 1
# Lump small entries and 'unknown' into 'other' category
self._consolidate_to_other()
impact_summary = self.generate_html_report()
map_title = tr('Buildings 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.
building_layer = Vector(data=building_layer,
name=tr('Flooded buildings'),
keywords={
'impact_summary':
impact_summary,
'map_title':
map_title,
'target_field':
target_field,
'buildings_total':
self.total_buildings,
'buildings_affected':
self.total_affected_buildings
},
style_info=style_info)
self._impact = building_layer
return building_layer
