def _check_value_mapping(layer, exposure_key=None):
"""Loop over the exposure type field and check if the value map is correct.
:param layer: The layer
:type layer: QgsVectorLayer
:param exposure_key: The exposure key.
:type exposure_key: str
"""
index = layer.fields().lookupField(exposure_type_field['field_name'])
unique_exposure = layer.uniqueValues(index)
if layer.keywords['layer_purpose'] == layer_purpose_hazard['key']:
if not exposure_key:
message = tr('Hazard value mapping missing exposure key.')
raise InvalidKeywordsForProcessingAlgorithm(message)
value_map = active_thresholds_value_maps(layer.keywords, exposure_key)
else:
value_map = layer.keywords.get('value_map')
if not value_map:
# The exposure do not have a value_map, we can skip the layer.
return layer
if layer.keywords['layer_purpose'] == layer_purpose_hazard['key']:
if not exposure_key:
message = tr('Hazard classification is missing exposure key.')
raise InvalidKeywordsForProcessingAlgorithm(message)
classification = active_classification(layer.keywords, exposure_key)
else:
classification = layer.keywords['classification']
exposure_classification = definition(classification)
other = None
if exposure_classification['key'] != data_driven_classes['key']:
other = exposure_classification['classes'][-1]['key']
exposure_mapped = []
for group in list(value_map.values()):
exposure_mapped.extend(group)
diff = list(unique_exposure - set(exposure_mapped))
if other in list(value_map.keys()):
value_map[other].extend(diff)
else:
value_map[other] = diff
layer.keywords['value_map'] = value_map
layer.keywords['classification'] = classification
return layer
def _check_value_mapping(layer, exposure_key=None):
"""Loop over the exposure type field and check if the value map is correct.
:param layer: The layer
:type layer: QgsVectorLayer
:param exposure_key: The exposure key.
:type exposure_key: str
"""
index = layer.fieldNameIndex(exposure_type_field['field_name'])
unique_exposure = layer.uniqueValues(index)
if layer.keywords['layer_purpose'] == layer_purpose_hazard['key']:
if not exposure_key:
message = tr('Hazard value mapping missing exposure key.')
raise InvalidKeywordsForProcessingAlgorithm(message)
value_map = active_thresholds_value_maps(layer.keywords, exposure_key)
else:
value_map = layer.keywords.get('value_map')
if not value_map:
# The exposure do not have a value_map, we can skip the layer.
return layer
if layer.keywords['layer_purpose'] == layer_purpose_hazard['key']:
if not exposure_key:
message = tr('Hazard classification is missing exposure key.')
raise InvalidKeywordsForProcessingAlgorithm(message)
classification = active_classification(layer.keywords, exposure_key)
else:
classification = layer.keywords['classification']
exposure_classification = definition(classification)
other = None
if exposure_classification['key'] != 'data_driven_classes':
other = exposure_classification['classes'][-1]['key']
exposure_mapped = []
for group in value_map.itervalues():
exposure_mapped.extend(group)
diff = list(set(unique_exposure) - set(exposure_mapped))
if other in value_map.keys():
value_map[other].extend(diff)
else:
value_map[other] = diff
layer.keywords['value_map'] = value_map
layer.keywords['classification'] = classification
return layer
def update_value_map(layer, exposure_key=None):
"""Assign inasafe values according to definitions for a vector layer.
:param layer: The vector layer.
:type layer: QgsVectorLayer
:param exposure_key: The exposure key.
:type exposure_key: str
:return: The classified vector layer.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = assign_inasafe_values_steps['output_layer_name']
output_layer_name = output_layer_name % layer.keywords['layer_purpose']
keywords = layer.keywords
inasafe_fields = keywords['inasafe_fields']
classification = None
if keywords['layer_purpose'] == layer_purpose_hazard['key']:
if not inasafe_fields.get(hazard_value_field['key']):
raise InvalidKeywordsForProcessingAlgorithm
old_field = hazard_value_field
new_field = hazard_class_field
classification = active_classification(layer.keywords, exposure_key)
elif keywords['layer_purpose'] == layer_purpose_exposure['key']:
if not inasafe_fields.get(exposure_type_field['key']):
raise InvalidKeywordsForProcessingAlgorithm
old_field = exposure_type_field
new_field = exposure_class_field
else:
raise InvalidKeywordsForProcessingAlgorithm
# It's a hazard layer
if exposure_key:
if not active_thresholds_value_maps(keywords, exposure_key):
raise InvalidKeywordsForProcessingAlgorithm
value_map = active_thresholds_value_maps(keywords, exposure_key)
# It's exposure layer
else:
if not keywords.get('value_map'):
raise InvalidKeywordsForProcessingAlgorithm
value_map = keywords.get('value_map')
unclassified_column = inasafe_fields[old_field['key']]
unclassified_index = layer.fields().lookupField(unclassified_column)
reversed_value_map = {}
for inasafe_class, values in list(value_map.items()):
for val in values:
reversed_value_map[val] = inasafe_class
classified_field = QgsField()
classified_field.setType(new_field['type'])
classified_field.setName(new_field['field_name'])
classified_field.setLength(new_field['length'])
classified_field.setPrecision(new_field['precision'])
layer.startEditing()
layer.addAttribute(classified_field)
classified_field_index = layer.fields(). \
lookupField(classified_field.name())
for feature in layer.getFeatures():
attributes = feature.attributes()
source_value = attributes[unclassified_index]
classified_value = reversed_value_map.get(source_value)
if not classified_value:
classified_value = ''
layer.changeAttributeValue(feature.id(), classified_field_index,
classified_value)
layer.commitChanges()
remove_fields(layer, [unclassified_column])
# We transfer keywords to the output.
# We add new class field
inasafe_fields[new_field['key']] = new_field['field_name']
# and we remove hazard value field
inasafe_fields.pop(old_field['key'])
layer.keywords = keywords
layer.keywords['inasafe_fields'] = inasafe_fields
if exposure_key:
value_map_key = 'value_maps'
else:
value_map_key = 'value_map'
if value_map_key in list(layer.keywords.keys()):
layer.keywords.pop(value_map_key)
layer.keywords['title'] = output_layer_name
if classification:
layer.keywords['classification'] = classification
check_layer(layer)
return layer
def reclassify(layer, exposure_key=None, overwrite_input=False, callback=None):
"""Reclassify a continuous raster layer.
Issue https://github.com/inasafe/inasafe/issues/3182
This function is a wrapper for the code from
https://github.com/chiatt/gdal_reclassify
For instance if you want to reclassify like this table :
Original Value | Class
- ∞ < val <= 0 | 1
0 < val <= 0.5 | 2
0.5 < val <= 5 | 3
5 < val < + ∞ | 6
You need a dictionary :
ranges = OrderedDict()
ranges[1] = [None, 0]
ranges[2] = [0.0, 0.5]
ranges[3] = [0.5, 5]
ranges[6] = [5, None]
:param layer: The raster layer.
:type layer: QgsRasterLayer
:param overwrite_input: Option for the output layer. True will overwrite
the input layer. False will create a temporary layer.
:type overwrite_input: bool
:param exposure_key: The exposure key.
:type exposure_key: str
:param callback: A function to all to indicate progress. The function
should accept params 'current' (int), 'maximum' (int) and 'step' (str).
Defaults to None.
:type callback: function
:return: The classified raster layer.
:rtype: QgsRasterLayer
.. versionadded:: 4.0
"""
output_layer_name = reclassify_raster_steps['output_layer_name']
processing_step = reclassify_raster_steps['step_name']
output_layer_name = output_layer_name % layer.keywords['layer_purpose']
if exposure_key:
classification_key = active_classification(layer.keywords,
exposure_key)
thresholds = active_thresholds_value_maps(layer.keywords, exposure_key)
layer.keywords['thresholds'] = thresholds
layer.keywords['classification'] = classification_key
else:
classification_key = layer.keywords.get('classification')
thresholds = layer.keywords.get('thresholds')
if not thresholds:
raise InvalidKeywordsForProcessingAlgorithm(
'thresholds are missing from the layer %s' %
layer.keywords['layer_purpose'])
if not classification_key:
raise InvalidKeywordsForProcessingAlgorithm(
'classification is missing from the layer %s' %
layer.keywords['layer_purpose'])
ranges = {}
value_map = {}
hazard_classes = definition(classification_key)['classes']
for hazard_class in hazard_classes:
ranges[hazard_class['value']] = thresholds[hazard_class['key']]
value_map[hazard_class['key']] = [hazard_class['value']]
if overwrite_input:
output_raster = layer.source()
else:
output_raster = unique_filename(suffix='.tiff', dir=temp_dir())
driver = gdal.GetDriverByName('GTiff')
raster_file = gdal.Open(layer.source())
band = raster_file.GetRasterBand(1)
no_data = band.GetNoDataValue()
source = band.ReadAsArray()
destination = source.copy()
for value, interval in ranges.iteritems():
v_min = interval[0]
v_max = interval[1]
if v_min is None:
destination[np.where(source <= v_max)] = value
if v_max is None:
destination[np.where(source > v_min)] = value
if v_min < v_max:
destination[np.where((v_min < source) & (source <= v_max))] = value
# Tag no data cells
destination[np.where(source == no_data)] = no_data_value
# Create the new file.
output_file = driver.Create(output_raster, raster_file.RasterXSize,
raster_file.RasterYSize, 1)
output_file.GetRasterBand(1).WriteArray(destination)
output_file.GetRasterBand(1).SetNoDataValue(no_data_value)
# CRS
output_file.SetProjection(raster_file.GetProjection())
output_file.SetGeoTransform(raster_file.GetGeoTransform())
output_file.FlushCache()
del output_file
if not isfile(output_raster):
raise FileNotFoundError
reclassified = QgsRasterLayer(output_raster, output_layer_name)
# We transfer keywords to the output.
reclassified.keywords = layer.keywords.copy()
reclassified.keywords['layer_mode'] = 'classified'
value_map = {}
hazard_classes = definition(classification_key)['classes']
for hazard_class in reversed(hazard_classes):
value_map[hazard_class['key']] = [hazard_class['value']]
reclassified.keywords['value_map'] = value_map
reclassified.keywords['title'] = output_layer_name
check_layer(reclassified)
return reclassified
def test_active_classification_thresholds_value_maps(self):
"""Test for active_classification and thresholds value maps method."""
keywords = {
'layer_mode': 'continuous',
'thresholds': {
'structure': {
'ina_structure_flood_hazard_classification': {
'classes': {
'low': [1, 2],
'medium': [3, 4],
'high': [5, 6]
},
'active': False
},
'ina_structure_flood_hazard_4_class_classification': {
'classes': {
'low': [1, 2],
'medium': [3, 4],
'high': [5, 6],
'very_high': [7, 8]
},
'active': False
}
},
'population': {
'ina_population_flood_hazard_classification': {
'classes': {
'low': [1, 2.5],
'medium': [2.5, 4.5],
'high': [4.5, 6]
},
'active': False
},
'ina_population_flood_hazard_4_class_classification': {
'classes': {
'low': [1, 2.5],
'medium': [2.5, 4],
'high': [4, 6],
'very_high': [6, 8]
},
'active': True
}
}
}
}
classification = active_classification(keywords, 'population')
self.assertEqual(classification,
'ina_population_flood_hazard_4_class_classification')
classification = active_classification(keywords, 'road')
self.assertIsNone(classification)
classification = active_classification(keywords, 'structure')
self.assertIsNone(classification)
thresholds = active_thresholds_value_maps(keywords, 'population')
expected_thresholds = {
'low': [1, 2.5],
'medium': [2.5, 4],
'high': [4, 6],
'very_high': [6, 8]
}
self.assertDictEqual(thresholds, expected_thresholds)
classification = active_thresholds_value_maps(keywords, 'road')
self.assertIsNone(classification)
classification = active_thresholds_value_maps(keywords, 'structure')
self.assertIsNone(classification)
def reclassify(layer, exposure_key=None):
"""Reclassify a continuous vector layer.
This function will modify the input.
For instance if you want to reclassify like this table :
Original Value | Class
- ∞ < val <= 0 | 1
0 < val <= 0.5 | 2
0.5 < val <= 5 | 3
5 < val < + ∞ | 6
You need a dictionary :
ranges = OrderedDict()
ranges[1] = [None, 0]
ranges[2] = [0.0, 0.5]
ranges[3] = [0.5, 5]
ranges[6] = [5, None]
:param layer: The raster layer.
:type layer: QgsRasterLayer
:param exposure_key: The exposure key.
:type exposure_key: str
:return: The classified vector layer.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = reclassify_vector_steps['output_layer_name']
output_layer_name = output_layer_name % layer.keywords['title']
# This layer should have this keyword, or it's a mistake from the dev.
inasafe_fields = layer.keywords['inasafe_fields']
continuous_column = inasafe_fields[hazard_value_field['key']]
if exposure_key:
classification_key = active_classification(
layer.keywords, exposure_key)
thresholds = active_thresholds_value_maps(layer.keywords, exposure_key)
layer.keywords['thresholds'] = thresholds
layer.keywords['classification'] = classification_key
else:
classification_key = layer.keywords.get('classification')
thresholds = layer.keywords.get('thresholds')
if not thresholds:
raise InvalidKeywordsForProcessingAlgorithm(
'thresholds are missing from the layer %s'
% layer.keywords['layer_purpose'])
continuous_index = layer.fields().lookupField(continuous_column)
classified_field = QgsField()
classified_field.setType(hazard_class_field['type'])
classified_field.setName(hazard_class_field['field_name'])
classified_field.setLength(hazard_class_field['length'])
classified_field.setPrecision(hazard_class_field['precision'])
layer.startEditing()
layer.addAttribute(classified_field)
classified_field_index = layer.fields(). \
lookupField(classified_field.name())
for feature in layer.getFeatures():
attributes = feature.attributes()
source_value = attributes[continuous_index]
classified_value = reclassify_value(source_value, thresholds)
if (classified_value is None
or (hasattr(classified_value, 'isNull')
and classified_value.isNull())):
layer.deleteFeature(feature.id())
else:
layer.changeAttributeValue(
feature.id(), classified_field_index, classified_value)
layer.commitChanges()
layer.updateFields()
# We transfer keywords to the output.
inasafe_fields[hazard_class_field['key']] = (
hazard_class_field['field_name'])
value_map = {}
hazard_classes = definition(classification_key)['classes']
for hazard_class in reversed(hazard_classes):
value_map[hazard_class['key']] = [hazard_class['value']]
layer.keywords['value_map'] = value_map
layer.keywords['title'] = output_layer_name
check_layer(layer)
return layer
def reclassify(layer, exposure_key=None, callback=None):
"""Reclassify a continuous vector layer.
This function will modify the input.
For instance if you want to reclassify like this table :
Original Value | Class
- ∞ < val <= 0 | 1
0 < val <= 0.5 | 2
0.5 < val <= 5 | 3
5 < val < + ∞ | 6
You need a dictionary :
ranges = OrderedDict()
ranges[1] = [None, 0]
ranges[2] = [0.0, 0.5]
ranges[3] = [0.5, 5]
ranges[6] = [5, None]
:param layer: The raster layer.
:type layer: QgsRasterLayer
:param exposure_key: The exposure key.
:type exposure_key: str
:param callback: A function to all to indicate progress. The function
should accept params 'current' (int), 'maximum' (int) and 'step' (str).
Defaults to None.
:type callback: function
:return: The classified vector layer.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = reclassify_vector_steps['output_layer_name']
output_layer_name = output_layer_name % layer.keywords['title']
processing_step = reclassify_vector_steps['step_name']
# This layer should have this keyword, or it's a mistake from the dev.
inasafe_fields = layer.keywords['inasafe_fields']
continuous_column = inasafe_fields[hazard_value_field['key']]
if exposure_key:
classification_key = active_classification(layer.keywords,
exposure_key)
thresholds = active_thresholds_value_maps(layer.keywords, exposure_key)
layer.keywords['thresholds'] = thresholds
layer.keywords['classification'] = classification_key
else:
classification_key = layer.keywords.get('classification')
thresholds = layer.keywords.get('thresholds')
if not thresholds:
raise InvalidKeywordsForProcessingAlgorithm(
'thresholds are missing from the layer %s' %
layer.keywords['layer_purpose'])
continuous_index = layer.fieldNameIndex(continuous_column)
classified_field = QgsField()
classified_field.setType(hazard_class_field['type'])
classified_field.setName(hazard_class_field['field_name'])
classified_field.setLength(hazard_class_field['length'])
classified_field.setPrecision(hazard_class_field['precision'])
layer.startEditing()
layer.addAttribute(classified_field)
classified_field_index = layer.fieldNameIndex(classified_field.name())
for feature in layer.getFeatures():
attributes = feature.attributes()
source_value = attributes[continuous_index]
classified_value = _classified_value(source_value, thresholds)
if not classified_value:
layer.deleteFeature(feature.id())
else:
layer.changeAttributeValue(feature.id(), classified_field_index,
classified_value)
layer.commitChanges()
layer.updateFields()
# We transfer keywords to the output.
inasafe_fields[hazard_class_field['key']] = (
hazard_class_field['field_name'])
value_map = {}
hazard_classes = definition(classification_key)['classes']
for hazard_class in reversed(hazard_classes):
value_map[hazard_class['key']] = [hazard_class['value']]
layer.keywords['value_map'] = value_map
layer.keywords['title'] = output_layer_name
check_layer(layer)
return layer
def reclassify(layer, exposure_key=None, overwrite_input=False, callback=None):
"""Reclassify a continuous raster layer.
Issue https://github.com/inasafe/inasafe/issues/3182
This function is a wrapper for the code from
https://github.com/chiatt/gdal_reclassify
For instance if you want to reclassify like this table :
Original Value | Class
- ∞ < val <= 0 | 1
0 < val <= 0.5 | 2
0.5 < val <= 5 | 3
5 < val < + ∞ | 6
You need a dictionary :
ranges = OrderedDict()
ranges[1] = [None, 0]
ranges[2] = [0.0, 0.5]
ranges[3] = [0.5, 5]
ranges[6] = [5, None]
:param layer: The raster layer.
:type layer: QgsRasterLayer
:param overwrite_input: Option for the output layer. True will overwrite
the input layer. False will create a temporary layer.
:type overwrite_input: bool
:param exposure_key: The exposure key.
:type exposure_key: str
:param callback: A function to all to indicate progress. The function
should accept params 'current' (int), 'maximum' (int) and 'step' (str).
Defaults to None.
:type callback: function
:return: The classified raster layer.
:rtype: QgsRasterLayer
.. versionadded:: 4.0
"""
output_layer_name = reclassify_raster_steps['output_layer_name']
processing_step = reclassify_raster_steps['step_name']
output_layer_name = output_layer_name % layer.keywords['layer_purpose']
if exposure_key:
classification_key = active_classification(
layer.keywords, exposure_key)
thresholds = active_thresholds_value_maps(layer.keywords, exposure_key)
layer.keywords['thresholds'] = thresholds
layer.keywords['classification'] = classification_key
else:
classification_key = layer.keywords.get('classification')
thresholds = layer.keywords.get('thresholds')
if not thresholds:
raise InvalidKeywordsForProcessingAlgorithm(
'thresholds are missing from the layer %s'
% layer.keywords['layer_purpose'])
if not classification_key:
raise InvalidKeywordsForProcessingAlgorithm(
'classification is missing from the layer %s'
% layer.keywords['layer_purpose'])
ranges = {}
value_map = {}
hazard_classes = definition(classification_key)['classes']
for hazard_class in hazard_classes:
ranges[hazard_class['value']] = thresholds[hazard_class['key']]
value_map[hazard_class['key']] = [hazard_class['value']]
if overwrite_input:
output_raster = layer.source()
else:
output_raster = unique_filename(suffix='.tiff', dir=temp_dir())
driver = gdal.GetDriverByName('GTiff')
raster_file = gdal.Open(layer.source())
band = raster_file.GetRasterBand(1)
no_data = band.GetNoDataValue()
source = band.ReadAsArray()
destination = source.copy()
for value, interval in ranges.iteritems():
v_min = interval[0]
v_max = interval[1]
if v_min is None:
destination[np.where(source <= v_max)] = value
if v_max is None:
destination[np.where(source > v_min)] = value
if v_min < v_max:
destination[np.where((v_min < source) & (source <= v_max))] = value
# Tag no data cells
destination[np.where(source == no_data)] = no_data_value
# Create the new file.
output_file = driver.Create(
output_raster, raster_file.RasterXSize, raster_file.RasterYSize, 1)
output_file.GetRasterBand(1).WriteArray(destination)
output_file.GetRasterBand(1).SetNoDataValue(no_data_value)
# CRS
output_file.SetProjection(raster_file.GetProjection())
output_file.SetGeoTransform(raster_file.GetGeoTransform())
output_file.FlushCache()
del output_file
if not isfile(output_raster):
raise FileNotFoundError
reclassified = QgsRasterLayer(output_raster, output_layer_name)
# We transfer keywords to the output.
reclassified.keywords = layer.keywords.copy()
reclassified.keywords['layer_mode'] = 'classified'
value_map = {}
hazard_classes = definition(classification_key)['classes']
for hazard_class in reversed(hazard_classes):
value_map[hazard_class['key']] = [hazard_class['value']]
reclassified.keywords['value_map'] = value_map
reclassified.keywords['title'] = output_layer_name
check_layer(reclassified)
return reclassified
def test_active_classification_thresholds_value_maps(self):
"""Test for active_classification and thresholds value maps method."""
keywords = {
'layer_mode': 'continuous',
'thresholds': {
'structure': {
'ina_structure_flood_hazard_classification': {
'classes': {
'low': [1, 2],
'medium': [3, 4],
'high': [5, 6]
},
'active': False
},
'ina_structure_flood_hazard_4_class_classification': {
'classes': {
'low': [1, 2],
'medium': [3, 4],
'high': [5, 6],
'very_high': [7, 8]
},
'active': False
}
},
'population': {
'ina_population_flood_hazard_classification': {
'classes': {
'low': [1, 2.5],
'medium': [2.5, 4.5],
'high': [4.5, 6]
},
'active': False
},
'ina_population_flood_hazard_4_class_classification': {
'classes': {
'low': [1, 2.5],
'medium': [2.5, 4],
'high': [4, 6],
'very_high': [6, 8]
},
'active': True
}
}
}
}
classification = active_classification(keywords, 'population')
self.assertEqual(
classification,
'ina_population_flood_hazard_4_class_classification')
classification = active_classification(keywords, 'road')
self.assertIsNone(classification)
classification = active_classification(keywords, 'structure')
self.assertIsNone(classification)
thresholds = active_thresholds_value_maps(keywords, 'population')
expected_thresholds = {
'low': [1, 2.5],
'medium': [2.5, 4],
'high': [4, 6],
'very_high': [6, 8]}
self.assertDictEqual(thresholds, expected_thresholds)
classification = active_thresholds_value_maps(keywords, 'road')
self.assertIsNone(classification)
classification = active_thresholds_value_maps(keywords, 'structure')
self.assertIsNone(classification)
def update_value_map(layer, exposure_key=None, callback=None):
"""Assign inasafe values according to definitions for a vector layer.
:param layer: The vector layer.
:type layer: QgsVectorLayer
:param exposure_key: The exposure key.
:type exposure_key: str
:param callback: A function to all to indicate progress. The function
should accept params 'current' (int), 'maximum' (int) and 'step' (str).
Defaults to None.
:type callback: function
:return: The classified vector layer.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = assign_inasafe_values_steps['output_layer_name']
processing_step = assign_inasafe_values_steps['step_name']
output_layer_name = output_layer_name % layer.keywords['layer_purpose']
keywords = layer.keywords
inasafe_fields = keywords['inasafe_fields']
classification = None
if keywords['layer_purpose'] == layer_purpose_hazard['key']:
if not inasafe_fields.get(hazard_value_field['key']):
raise InvalidKeywordsForProcessingAlgorithm
old_field = hazard_value_field
new_field = hazard_class_field
classification = active_classification(layer.keywords, exposure_key)
elif keywords['layer_purpose'] == layer_purpose_exposure['key']:
if not inasafe_fields.get(exposure_type_field['key']):
raise InvalidKeywordsForProcessingAlgorithm
old_field = exposure_type_field
new_field = exposure_class_field
else:
raise InvalidKeywordsForProcessingAlgorithm
# It's a hazard layer
if exposure_key:
if not active_thresholds_value_maps(keywords, exposure_key):
raise InvalidKeywordsForProcessingAlgorithm
value_map = active_thresholds_value_maps(keywords, exposure_key)
# It's exposure layer
else:
if not keywords.get('value_map'):
raise InvalidKeywordsForProcessingAlgorithm
value_map = keywords.get('value_map')
unclassified_column = inasafe_fields[old_field['key']]
unclassified_index = layer.fieldNameIndex(unclassified_column)
reversed_value_map = {}
for inasafe_class, values in value_map.iteritems():
for val in values:
reversed_value_map[val] = inasafe_class
classified_field = QgsField()
classified_field.setType(new_field['type'])
classified_field.setName(new_field['field_name'])
classified_field.setLength(new_field['length'])
classified_field.setPrecision(new_field['precision'])
layer.startEditing()
layer.addAttribute(classified_field)
classified_field_index = layer.fieldNameIndex(classified_field.name())
for feature in layer.getFeatures():
attributes = feature.attributes()
source_value = attributes[unclassified_index]
classified_value = reversed_value_map.get(source_value)
if not classified_value:
classified_value = ''
layer.changeAttributeValue(
feature.id(), classified_field_index, classified_value)
layer.commitChanges()
remove_fields(layer, [unclassified_column])
# We transfer keywords to the output.
# We add new class field
inasafe_fields[new_field['key']] = new_field['field_name']
# and we remove hazard value field
inasafe_fields.pop(old_field['key'])
layer.keywords = keywords
layer.keywords['inasafe_fields'] = inasafe_fields
if exposure_key:
value_map_key = 'value_maps'
else:
value_map_key = 'value_map'
if value_map_key in layer.keywords.keys():
layer.keywords.pop(value_map_key)
layer.keywords['title'] = output_layer_name
if classification:
layer.keywords['classification'] = classification
check_layer(layer)
return layer
