def test_functions_for_constraint(self): """Test functions_for_constraint.""" ifm = ImpactFunctionManager() impact_functions = ifm.functions_for_constraint( 'earthquake', 'population', 'raster', 'raster', 'continuous', 'continuous', ) expected = [ ITBFatalityFunction.metadata().as_dict(), ITBBayesianFatalityFunction.metadata().as_dict(), PAGFatalityFunction.metadata().as_dict(), ContinuousHazardPopulationFunction.metadata().as_dict()] for key in impact_functions[0].keys(): if key == 'parameters': # We do not check the parameters since they are mutable. continue result = [x[key] for x in impact_functions] hope = [x[key] for x in expected] message = key self.assertItemsEqual(result, hope, message)
def test_exposure_units_for_layer(self): """Test for exposure_units_for_layer""" impact_function_manager = ImpactFunctionManager() exposure_units = impact_function_manager.exposure_units_for_layer( 'population', 'raster', 'continuous') expected = [count_exposure_unit, density_exposure_unit] self.assertItemsEqual(exposure_units, expected)
def test_hazards_for_layer(self): """Test for hazards_for_layer""" impact_function_manager = ImpactFunctionManager() hazards = impact_function_manager.hazards_for_layer( 'polygon', 'single_event') # print [x['key'] for x in hazards] expected = [ hazard_flood, hazard_tsunami, hazard_earthquake, hazard_volcano, hazard_volcanic_ash, hazard_generic ] self.assertItemsEqual(hazards, expected) hazards = impact_function_manager.hazards_for_layer('polygon') expected = [hazard_flood, hazard_tsunami, hazard_earthquake, hazard_volcano, hazard_volcanic_ash, hazard_generic] self.assertItemsEqual(hazards, expected) hazards = impact_function_manager.hazards_for_layer( 'point', 'single_event') expected = [hazard_volcano] self.assertItemsEqual(hazards, expected)
def test_available_hazards(self): """Test available_hazards API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.available_hazards( 'single_event') print [x['key'] for x in result]
def test_get_functions_for_constraint(self): """Test get_functions_for_constraint.""" impact_function_manager = ImpactFunctionManager() hazard = hazard_earthquake exposure = exposure_structure expected_result = [ EarthquakeBuildingImpactFunction.Metadata.get_metadata(), ClassifiedHazardBuildingImpactFunction.Metadata.get_metadata()] result = impact_function_manager.get_functions_for_constraint( hazard, exposure) message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(expected_result, result, message) hazard_constraint = layer_raster_continuous exposure_constraint = None expected_result = [ EarthquakeBuildingImpactFunction.Metadata.get_metadata()] result = impact_function_manager.get_functions_for_constraint( hazard, exposure, hazard_constraint, exposure_constraint) message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(expected_result, result, message) hazard_constraint = layer_vector_polygon exposure_constraint = layer_vector_line expected_result = [] result = impact_function_manager.get_functions_for_constraint( hazard, exposure, hazard_constraint, exposure_constraint) message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(expected_result, result, message)
def test_available_exposure_layer_modes(self): """Test for available_exposure_layer_modes.""" ifm = ImpactFunctionManager() exposure_layer_mode = ifm.available_exposure_layer_modes( 'population', 'raster') expected = [layer_mode_continuous] self.assertItemsEqual(exposure_layer_mode, expected)
def test_available_hazard_layer_modes(self): """Test for available_hazard_layer_modes.""" ifm = ImpactFunctionManager() hazard_layer_mode = ifm.available_hazard_layer_modes( 'earthquake', 'raster', 'single_event') expected = [layer_mode_continuous, layer_mode_classified] self.assertItemsEqual(hazard_layer_mode, expected)
def test_available_exposures(self): """Test available_exposures API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.available_exposures() expected_result = [ exposure_structure, exposure_road, exposure_population] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def analysis_setup(command_line_arguments, hazard, exposure, aggregation=None): """Sets up an analysis object. .. versionadded:: 3.2 :param command_line_arguments: User inputs. :type command_line_arguments: CommandLineArguments :param hazard: Hazard layer :type hazard: QgsLayer :param exposure: Exposure Layer :type exposure: QgsLayer :param aggregation: Aggregation Layer :type aggregation: QgsLayer :raises: Exception """ # IF impact_function_manager = ImpactFunctionManager() impact_function = impact_function_manager.get(command_line_arguments.impact_function) keyword_io = KeywordIO() try: from safe.utilities.analysis import Analysis except ImportError as ie: LOGGER.debug("Import error for Analysis module") print ie.message raise ImportError analysis = Analysis() analysis.impact_function = impact_function analysis.hazard = hazard analysis.exposure = exposure analysis.aggregation = aggregation # analysis.hazard_keyword = keyword_io.read_keywords(hazard) # analysis.exposure_keyword = keyword_io.read_keywords(exposure) analysis.clip_hard = False analysis.show_intermediate_layers = False analysis.run_in_thread_flag = False analysis.map_canvas = CANVAS # QSetting context settings = QSettings() crs = settings.value("inasafe/analysis_extent_crs", "", type=str) analysis.user_extent_crs = QgsCoordinateReferenceSystem(crs) try: analysis.user_extent = QgsRectangle( float(command_line_arguments.extent[0]), float(command_line_arguments.extent[1]), float(command_line_arguments.extent[2]), float(command_line_arguments.extent[3]), ) except AttributeError: print "No extents" pass analysis.setup_analysis() return analysis
def __init__(self): """Constructor for the impact calculator.""" QObject.__init__(self) self.impact_function_manager = ImpactFunctionManager() self._hazard_layer = None self._exposure_layer = None self._impact_function = None self._filename = None self._result = None self._extent = None
def test_available_exposure_constraints(self): """Test for available_exposure_constraints.""" ifm = ImpactFunctionManager() exposure_constraints = ifm.available_exposure_constraints( 'population') expected = [ (layer_mode_continuous, layer_geometry_raster), ] self.assertItemsEqual(exposure_constraints, expected)
def test_exposure_additional_keywords(self): """Test for exposure_additional_keywords.""" ifm = ImpactFunctionManager() additional_keywords = ifm.exposure_additional_keywords( layer_mode_key='classified', layer_geometry_key='polygon', exposure_key='structure') expected = [] self.assertItemsEqual(additional_keywords, expected)
def test_exposures_for_layer(self): """Test for exposures_for_layer""" impact_function_manager = ImpactFunctionManager() exposures = impact_function_manager.exposures_for_layer('polygon') expected = [exposure_structure, exposure_population] self.assertItemsEqual(exposures, expected) exposures = impact_function_manager.exposures_for_layer('line') expected = [exposure_road] self.assertItemsEqual(exposures, expected)
def test_available_exposure_constraints(self): """Test for available_exposure_constraints.""" self.maxDiff = None ifm = ImpactFunctionManager() exposure_constraints = ifm.available_exposure_constraints( 'population') expected = [ (layer_mode_continuous, layer_geometry_raster), (layer_mode_continuous, layer_geometry_polygon) ] self.assertItemsEqual(exposure_constraints, expected)
def test_available_exposures(self): """Test available_exposures API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.available_exposures() expected_result = [ exposure_structure, exposure_road, exposure_population, exposure_place, exposure_land_cover] self.assertItemsEqual(result, expected_result)
def test_exposure_class_fields(self): """Test for exposure_class_fields.""" ifm = ImpactFunctionManager() additional_keywords = ifm.exposure_class_fields( layer_mode_key='classified', layer_geometry_key='polygon', exposure_key='structure' ) expected = [structure_class_field] self.assertItemsEqual(additional_keywords, expected)
def test_hazard_additional_keywords(self): """Test for hazard_additional_keywords.""" ifm = ImpactFunctionManager() additional_keywords = ifm.hazard_additional_keywords( layer_mode_key='classified', layer_geometry_key='polygon', hazard_category_key='single_event', hazard_key='flood') expected = [] self.assertItemsEqual(additional_keywords, expected)
def test_allowed_subcategories(self): """Test allowed_subcategories API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.allowed_subcategories() expected_result = [ exposure_structure, hazard_earthquake, exposure_population, hazard_flood, hazard_tsunami, exposure_road, hazard_volcano, hazard_volcanic_ash, hazard_generic ] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def test_available_exposures(self): """Test available_exposures API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.available_exposures() expected_result = [ exposure_structure, exposure_road, exposure_population, exposure_place, exposure_land_cover] self.assertItemsEqual(result, expected_result)
def test_exposures_for_layer(self): """Test for exposures_for_layer""" impact_function_manager = ImpactFunctionManager() exposures = impact_function_manager.exposures_for_layer( 'polygon') expected = [exposure_structure] self.assertItemsEqual(exposures, expected) exposures = impact_function_manager.exposures_for_layer( 'line') expected = [exposure_road] self.assertItemsEqual(exposures, expected)
def test_available_hazard_constraints(self): """Test for available_hazard_constraints.""" ifm = ImpactFunctionManager() hazard_constraints = ifm.available_hazard_constraints( 'earthquake', 'single_event') expected = [ (layer_mode_continuous, layer_geometry_raster), (layer_mode_classified, layer_geometry_raster), (layer_mode_classified, layer_geometry_polygon), ] print [(x[0]['key'], x[1]['key']) for x in hazard_constraints]
def analysis_execution(): from safe.test.utilities import get_qgis_app # get_qgis_app must be called before importing Analysis QGIS_APP, CANVAS, IFACE, PARENT = get_qgis_app() from safe.utilities.analysis import Analysis from safe.utilities.keyword_io import KeywordIO analysis = Analysis() arg = AnalysisArguments.read_arguments() register_impact_functions() registry = ImpactFunctionManager().registry function = registry.get_instance(arg.impact_function_name) hazard_layer = safe_to_qgis_layer(read_layer(arg.hazard_filename)) exposure_layer = safe_to_qgis_layer(read_layer(arg.exposure_filename)) if arg.aggregation_filename: aggregation_layer = safe_to_qgis_layer(read_layer( arg.aggregation_filename)) keywords_io = KeywordIO() try: analysis.map_canvas = IFACE.mapCanvas() analysis.hazard_layer = hazard_layer analysis.hazard_keyword = keywords_io.read_keywords(hazard_layer) analysis.exposure_layer = exposure_layer analysis.exposure_keyword = keywords_io.read_keywords(exposure_layer) if aggregation_layer: analysis.aggregation_layer = aggregation_layer analysis.aggregation_keyword = keywords_io.read_keywords( aggregation_layer) analysis.impact_function = function analysis.setup_analysis() print 'Setup analysis done' analysis.run_analysis() print 'Analysis done' except Exception as e: print e.message impact = analysis.impact_layer qgis_impact = safe_to_qgis_layer(impact) generate_styles(impact, qgis_impact) copy_impact_layer(impact, arg.impact_filename)
def test_available_hazards(self): """Test available_hazards API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.available_hazards('single_event') # print [x['key'] for x in result] expected_result = [ hazard_flood, hazard_tsunami, hazard_earthquake, hazard_generic, hazard_volcanic_ash, hazard_volcano ] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def analysis_execution(): from safe.test.utilities import get_qgis_app # get_qgis_app must be called before importing Analysis QGIS_APP, CANVAS, IFACE, PARENT = get_qgis_app() from safe.utilities.analysis import Analysis from safe.utilities.keyword_io import KeywordIO analysis = Analysis() arg = AnalysisArguments.read_arguments() register_impact_functions() registry = ImpactFunctionManager().registry function = registry.get_instance(arg.impact_function_name) hazard_layer = safe_to_qgis_layer(read_layer(arg.hazard_filename)) exposure_layer = safe_to_qgis_layer(read_layer(arg.exposure_filename)) if arg.aggregation_filename: aggregation_layer = safe_to_qgis_layer( read_layer(arg.aggregation_filename)) keywords_io = KeywordIO() try: analysis.map_canvas = IFACE.mapCanvas() analysis.hazard_layer = hazard_layer analysis.hazard_keyword = keywords_io.read_keywords(hazard_layer) analysis.exposure_layer = exposure_layer analysis.exposure_keyword = keywords_io.read_keywords(exposure_layer) if aggregation_layer: analysis.aggregation_layer = aggregation_layer analysis.aggregation_keyword = keywords_io.read_keywords( aggregation_layer) analysis.impact_function = function analysis.setup_analysis() print 'Setup analysis done' analysis.run_analysis() print 'Analysis done' except Exception as e: print e.message impact = analysis.impact_layer qgis_impact = safe_to_qgis_layer(impact) generate_styles(impact, qgis_impact) copy_impact_layer(impact, arg.impact_filename)
def test_hazard_additional_keywords(self): """Test for hazard_additional_keywords.""" ifm = ImpactFunctionManager() additional_keywords = ifm.hazard_additional_keywords( layer_mode_key='classified', layer_geometry_key='polygon', hazard_category_key='single_event', hazard_key='flood' ) expected = [] self.assertItemsEqual(additional_keywords, expected)
def test_get_functions_for_exposure_id(self): """Test get_functions_for_exposure_id API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.get_functions_for_exposure_id( exposure_structure['id']) expected_result = [ VolcanoBuildingImpact.Metadata.get_metadata(), EarthquakeBuildingImpactFunction.Metadata.get_metadata(), FloodBuildingImpactFunction.Metadata.get_metadata(), FloodNativePolygonExperimentalFunction.Metadata.get_metadata(), ClassifiedHazardBuildingImpactFunction.Metadata.get_metadata()] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def test_get_functions_for_hazard_id(self): """Test get_functions_for_hazard_id API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.get_functions_for_hazard_id( hazard_volcano['id']) expected_result = [ VolcanoBuildingImpact.Metadata.get_metadata(), VolcanoPolygonHazardPopulation.Metadata.get_metadata(), ContinuousHazardPopulationImpactFunction.Metadata.get_metadata(), ClassifiedHazardBuildingImpactFunction.Metadata.get_metadata(), ClassifiedHazardPopulationImpactFunction.Metadata.get_metadata()] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def test_available_hazard_constraints(self): """Test for available_hazard_constraints.""" ifm = ImpactFunctionManager() hazard_constraints = ifm.available_hazard_constraints( 'earthquake', 'single_event') expected = [ (layer_mode_continuous, layer_geometry_raster), (layer_mode_classified, layer_geometry_raster), (layer_mode_classified, layer_geometry_polygon), ] # print [(x[0]['key'], x[1]['key']) for x in hazard_constraints] self.assertItemsEqual(hazard_constraints, expected)
def test_get_functions_for_hazard_id(self): """Test get_functions_for_hazard_id API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.get_functions_for_hazard_id( hazard_volcano['id']) expected_result = [ VolcanoBuildingImpact.Metadata.get_metadata(), VolcanoPolygonHazardPopulation.Metadata.get_metadata(), ContinuousHazardPopulationImpactFunction.Metadata.get_metadata(), ClassifiedHazardBuildingImpactFunction.Metadata.get_metadata(), ClassifiedHazardPopulationImpactFunction.Metadata.get_metadata()] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def calculate_specified_impact(self, function_id, hazard_layer, exposure_layer, output_basename): LOGGER.info('Calculate %s' % function_id) if_manager = ImpactFunctionManager() impact_function = if_manager.get_instance(function_id) impact_function.hazard = hazard_layer extent = impact_function.hazard.extent() hazard_extent = [ extent.xMinimum(), extent.yMinimum(), extent.xMaximum(), extent.yMaximum() ] # clip exposure if required (if it is too large) if isinstance(exposure_layer, QgsRasterLayer): cell_size, _ = get_wgs84_resolution(exposure_layer) else: cell_size = None clipped_exposure = clip_layer(layer=exposure_layer, extent=hazard_extent, cell_size=cell_size) exposure_layer = clipped_exposure impact_function.exposure = exposure_layer impact_function.requested_extent = hazard_extent impact_function.requested_extent_crs = impact_function.hazard.crs() impact_function.force_memory = True try: impact_function.run_analysis() impact_layer = impact_function.impact if impact_layer: self.set_impact_style(impact_layer) # copy results of impact to report_path directory self.copy_layer(impact_layer, output_basename) except ZeroImpactException as e: # in case zero impact, just return LOGGER.info('No impact detected') LOGGER.info(e.message) return False except Exception as e: LOGGER.info('Calculation error') LOGGER.exception(e) return False LOGGER.info('Calculation completed.') return True
def test_get_functions_for_exposure_id(self): """Test get_functions_for_exposure_id API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.get_functions_for_exposure_id( exposure_structure['id']) expected_result = [ VolcanoBuildingImpact.Metadata.get_metadata(), EarthquakeBuildingImpactFunction.Metadata.get_metadata(), FloodRasterBuildingImpactFunction.Metadata.get_metadata(), FloodVectorBuildingImpactFunction.Metadata.get_metadata(), FloodNativePolygonExperimentalFunction.Metadata.get_metadata(), ClassifiedHazardBuildingImpactFunction.Metadata.get_metadata()] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def test_get_available_hazards(self): """Test get_available_hazards API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.get_available_hazards() expected_result = hazard_all message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) impact_function = EarthquakeBuildingImpactFunction() result = impact_function_manager.get_available_hazards(impact_function) expected_result = [hazard_earthquake] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def test_get_available_hazards(self): """Test get_available_hazards API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.get_available_hazards() expected_result = hazard_all message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) impact_function = EarthquakeBuildingImpactFunction() result = impact_function_manager.get_available_hazards(impact_function) expected_result = [hazard_earthquake] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def show_impact_function_names(impact_functions): """Prints a list of impact functions. .. versionadded:: 3.2 :param impact_functions: A list of impact function ids. :type: list of strings. """ manager = ImpactFunctionManager() print "" print "Available Impact Function:" for impact_function in impact_functions: print manager.get_function_id(impact_function) print ""
def test_allowed_data_types(self): """Test allowed_data_types API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.allowed_data_types('flood') expected_result = ['polygon', 'continuous', 'classified'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types('volcano') expected_result = ['point', 'polygon', 'continuous', 'classified'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types('structure') expected_result = ['polygon', 'point'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types('earthquake') expected_result = ['continuous', 'classified'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types('tsunami') expected_result = ['polygon', 'continuous', 'classified'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types('population') expected_result = ['continuous'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def show_impact_function_names(impact_functions): """Prints a list of impact functions. .. versionadded:: 3.2 :param impact_functions: A list of impact function ids. :type: list of strings. """ manager = ImpactFunctionManager() print "" print "Available Impact Function:" for impact_function in impact_functions: print manager.get_function_id(impact_function) print ""
def test_available_hazards(self): """Test available_hazards API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.available_hazards( 'single_event') # print [x['key'] for x in result] expected_result = [hazard_flood, hazard_tsunami, hazard_earthquake, hazard_generic, hazard_volcanic_ash, hazard_volcano] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def impact_function_setup(command_line_arguments, hazard, exposure, aggregation=None): """Sets up an analysis object. .. versionadded:: 3.2 :param command_line_arguments: User inputs. :type command_line_arguments: CommandLineArguments :param hazard: Hazard layer :type hazard: QgsLayer :param exposure: Exposure Layer :type exposure: QgsLayer :param aggregation: Aggregation Layer :type aggregation: QgsLayer :raises: Exception """ # IF impact_function_manager = ImpactFunctionManager() impact_function = impact_function_manager.get( command_line_arguments.impact_function) impact_function.hazard = hazard impact_function.exposure = exposure impact_function.aggregation = aggregation impact_function.clip_hard = False impact_function.show_intermediate_layers = False impact_function.run_in_thread_flag = False impact_function.map_canvas = CANVAS # QSetting context settings = QSettings() crs = settings.value('inasafe/analysis_extent_crs', '', type=str) impact_function.requested_extent_crs = QgsCoordinateReferenceSystem(crs) try: impact_function.requested_extent = QgsRectangle( float(command_line_arguments.extent[0]), float(command_line_arguments.extent[1]), float(command_line_arguments.extent[2]), float(command_line_arguments.extent[3])) except AttributeError: print "No extents" pass return impact_function
def test_keywords(self): """Test filtering IF from layer keywords""" exposure_keywords = { 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'layer_geometry': 'point', 'exposure': 'place', 'exposure_unit': 'count' } hazard_keywords = { 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'layer_geometry': 'raster', 'hazard': 'volcanic_ash', 'hazard_category': 'single_event', 'continuous_hazard_unit': 'centimetres' } impact_functions = ImpactFunctionManager().filter_by_keywords( hazard_keywords, exposure_keywords) message = 'There should be 1 impact function, but there are: %s' % \ len(impact_functions) self.assertEqual(1, len(impact_functions), message)
def test_keywords(self): exposure_keywords = { 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'layer_geometry': 'polygon', 'exposure': 'land_cover', 'field': 'FCODE', } hazard_keywords = { 'layer_purpose': 'hazard', 'layer_mode': 'classified', 'layer_geometry': 'polygon', 'hazard': 'generic', 'hazard_category': 'multiple_event', 'field': 'level', 'vector_hazard_classification': 'generic_vector_hazard_classes', } impact_functions = ImpactFunctionManager().filter_by_keywords( hazard_keywords, exposure_keywords) message = 'There should be 1 impact function, but there are: %s' % \ len(impact_functions) self.assertEqual(1, len(impact_functions), message)
def test_keywords(self): """TestClassifiedPolygonPeopleFunction: Test keywords IF""" exposure_keywords = { 'layer_purpose': 'exposure', 'layer_mode': 'continuous', 'layer_geometry': 'polygon', 'exposure': 'population', 'structure_class_field': '', 'exposure_unit': 'count' } hazard_keywords = { 'layer_purpose': 'hazard', 'layer_mode': 'classified', 'layer_geometry': 'polygon', 'hazard': 'generic', 'hazard_category': 'multiple_event', 'field': 'h_zone', 'vector_hazard_classification': 'generic_vector_hazard_classes', } impact_functions = ImpactFunctionManager().filter_by_keywords( hazard_keywords, exposure_keywords) message = 'There should be 1 impact function, but there are: %s' % \ len(impact_functions) self.assertEqual(1, len(impact_functions), message)
def __init__(self, parent): """Constructor for the class. :param parent: Parent widget i.e. the wizard dialog. :type parent: QWidget """ QtCore.QObject.__init__(self) self.parent = parent # Do not delete this self.iface = parent.iface self.keyword_io = KeywordIO() self.impact_function_manager = ImpactFunctionManager() self.extent = Extent(self.iface) self.analysis = None # Values for settings these get set in read_settings. self.run_in_thread_flag = None self.zoom_to_impact_flag = None self.hide_exposure_flag = None self.clip_hard = None self.show_intermediate_layers = None self.show_rubber_bands = False self.last_analysis_rubberband = None # This is a rubber band to show what the AOI of the # next analysis will be. Also added in 2.1.0 self.next_analysis_rubberband = None self.read_settings()
def test_hazard_categories_for_layer(self): """Test for hazard_categories_for_layer""" impact_function_manager = ImpactFunctionManager() hazard_categories = impact_function_manager.\ hazard_categories_for_layer('polygon') expected = [ hazard_category_single_event, hazard_category_multiple_event ] self.assertItemsEqual(hazard_categories, expected) hazard_categories = impact_function_manager.\ hazard_categories_for_layer('line') expected = [] self.assertItemsEqual(hazard_categories, expected) hazard_categories = impact_function_manager.\ hazard_categories_for_layer('point') expected = [ hazard_category_multiple_event, hazard_category_single_event ] self.assertItemsEqual(hazard_categories, expected) hazard_categories = impact_function_manager.\ hazard_categories_for_layer('raster') expected = [ hazard_category_single_event, hazard_category_multiple_event ] self.assertItemsEqual(hazard_categories, expected) hazard_categories = impact_function_manager. \ hazard_categories_for_layer('raster', 'earthquake') expected = [ hazard_category_single_event, hazard_category_multiple_event ] self.assertItemsEqual(hazard_categories, expected)
def __init__(self): super(TsunamiEvacuationFunction, self).__init__() self.impact_function_manager = ImpactFunctionManager() # AG: Use the proper minimum needs, update the parameters self.parameters = add_needs_parameters(self.parameters) self.no_data_warning = False
def impact_function_setup( command_line_arguments, hazard, exposure, aggregation=None): """Sets up an analysis object. .. versionadded:: 3.2 :param command_line_arguments: User inputs. :type command_line_arguments: CommandLineArguments :param hazard: Hazard layer :type hazard: QgsLayer :param exposure: Exposure Layer :type exposure: QgsLayer :param aggregation: Aggregation Layer :type aggregation: QgsLayer :raises: Exception """ # IF impact_function_manager = ImpactFunctionManager() impact_function = impact_function_manager.get( command_line_arguments.impact_function) impact_function.hazard = hazard impact_function.exposure = exposure impact_function.aggregation = aggregation impact_function.clip_hard = False impact_function.show_intermediate_layers = False impact_function.run_in_thread_flag = False impact_function.map_canvas = CANVAS # QSetting context settings = QSettings() crs = settings.value('inasafe/analysis_extent_crs', '', type=str) impact_function.requested_extent_crs = QgsCoordinateReferenceSystem(crs) try: impact_function.requested_extent = QgsRectangle( float(command_line_arguments.extent[0]), float(command_line_arguments.extent[1]), float(command_line_arguments.extent[2]), float(command_line_arguments.extent[3]) ) except AttributeError: print "No extents" pass return impact_function
def __init__(self): super(ContinuousHazardPopulationFunction, self).__init__() PopulationExposureReportMixin.__init__(self) self.impact_function_manager = ImpactFunctionManager() # AG: Use the proper minimum needs, update the parameters self.parameters = add_needs_parameters(self.parameters) self.no_data_warning = False
def test_get_function_title(self): """TestImpactFunctionManager: Test getting function title.""" impact_function_title = ImpactFunctionManager().get_function_title( FloodPolygonBuildingFunction) expected_title = 'Be flooded' message = 'Expecting %s but got %s' % (impact_function_title, expected_title) self.assertEqual(impact_function_title, expected_title, message)
def test_allowed_subcategories(self): """Test allowed_subcategories API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.allowed_subcategories() expected_result = [ exposure_structure, hazard_earthquake, exposure_population, hazard_flood, hazard_tsunami, exposure_road, hazard_volcano, hazard_tephra, hazard_generic] message = ( 'I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def test_get_available_exposures(self): """Test get_available_exposures API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.get_available_exposures() expected_result = [ exposure_population, exposure_road, exposure_structure ] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) impact_function = EarthquakeBuildingImpactFunction() result = impact_function_manager.get_available_exposures( impact_function) expected_result = [exposure_structure] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def __init__(self): """Constructor.""" super(FloodEvacuationRasterHazardFunction, self).__init__() self.target_field = 'population' self.impact_function_manager = ImpactFunctionManager() # AG: Use the proper minimum needs, update the parameters self.parameters = add_needs_parameters(self.parameters)
def test_allowed_data_types(self): """TestImpactFunctionManager: Test allowed_data_types API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.allowed_data_types("flood") expected_result = ["polygon", "continuous", "classified"] message = "I expect %s but I got %s." % (expected_result, result) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types("volcano") expected_result = ["point", "polygon", "continuous", "classified"] message = "I expect %s but I got %s." % (expected_result, result) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types("structure") expected_result = ["polygon", "point"] message = "I expect %s but I got %s." % (expected_result, result) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types("earthquake") expected_result = ["continuous", "classified", "polygon"] message = "I expect %s but I got %s." % (expected_result, result) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types("tsunami") expected_result = ["polygon", "continuous", "classified"] message = "I expect %s but I got %s." % (expected_result, result) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types("population") expected_result = ["continuous"] message = "I expect %s but I got %s." % (expected_result, result) self.assertItemsEqual(result, expected_result, message)
def test_allowed_data_types(self): """Test allowed_data_types API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.allowed_data_types('flood') expected_result = ['polygon', 'numeric'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types('volcano') expected_result = ['point', 'polygon', 'numeric'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types('structure') expected_result = ['polygon', 'point'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types('earthquake') expected_result = ['polygon', 'numeric'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types('tsunami') expected_result = ['polygon', 'numeric'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) result = impact_function_manager.allowed_data_types('population') expected_result = ['numeric'] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def test_init(self): """Test initialize ImpactFunctionManager.""" impact_function_manager = ImpactFunctionManager() expected_result = 15 result = len(impact_function_manager.impact_functions) message = ( 'I expect %s but I got %s, please check the number of current ' 'enabled impact functions' % (expected_result, result)) self.assertEqual(result, expected_result, message)
def direct_execution(): arg = AnalysisArguments.read_arguments() register_impact_functions() registry = ImpactFunctionManager().registry function = registry.get_instance(arg.impact_function_name) function.hazard = SafeLayer(read_layer(arg.hazard_filename)) function.exposure = SafeLayer(read_layer(arg.exposure_filename)) impact = calculate_impact(function) qgis_impact = safe_to_qgis_layer(impact) generate_styles(impact, qgis_impact) copy_impact_layer(impact, arg.impact_filename)
def test_continuous_hazards_units_for_layer(self): """Test for continuous_hazards_units_for_layer""" impact_function_manager = ImpactFunctionManager() continuous_hazards_units = impact_function_manager.\ continuous_hazards_units_for_layer( 'tsunami', 'raster', 'continuous', 'single_event') # print [x['key'] for x in continuous_hazards_units] expected = [unit_metres, unit_feet, unit_generic] self.assertItemsEqual(continuous_hazards_units, expected)
def test_purposes_for_layer(self): """Test for purposes_for_layer""" impact_function_manager = ImpactFunctionManager() layer_purposes = impact_function_manager.purposes_for_layer('polygon') expected = [layer_purpose_hazard, layer_purpose_exposure] self.assertItemsEqual(layer_purposes, expected) layer_purposes = impact_function_manager.purposes_for_layer('line') expected = [layer_purpose_exposure] self.assertItemsEqual(layer_purposes, expected) layer_purposes = impact_function_manager.purposes_for_layer('point') expected = [layer_purpose_hazard, layer_purpose_exposure] self.assertItemsEqual(layer_purposes, expected) layer_purposes = impact_function_manager.purposes_for_layer('raster') expected = [layer_purpose_hazard, layer_purpose_exposure] self.assertItemsEqual(layer_purposes, expected)
def direct_execution(): arg = AnalysisArguments.read_arguments() register_impact_functions() registry = ImpactFunctionManager().registry function = registry.get_instance(arg.impact_function_name) function.hazard = SafeLayer(read_layer(arg.hazard_filename)) function.exposure = SafeLayer(read_layer(arg.exposure_filename)) impact = calculate_impact(function) qgis_impact = safe_to_qgis_layer(impact) generate_styles(impact, qgis_impact) copy_impact_layer(impact, arg.impact_filename)
def test_get_available_exposures(self): """Test get_available_exposures API.""" impact_function_manager = ImpactFunctionManager() result = impact_function_manager.get_available_exposures() expected_result = [ exposure_population, exposure_road, exposure_structure] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message) impact_function = EarthquakeBuildingImpactFunction() result = impact_function_manager.get_available_exposures( impact_function) expected_result = [exposure_structure] message = ('I expect %s but I got %s.' % (expected_result, result)) self.assertItemsEqual(result, expected_result, message)
def __init__(self): """Constructor.""" super(FloodEvacuationRasterHazardFunction, self).__init__() self.impact_function_manager = ImpactFunctionManager() # AG: Use the proper minimum needs, update the parameters self.parameters = add_needs_parameters(self.parameters) # Initialize instance attributes for readability (pylint) self.no_data_warning = False
def __init__(self, parent=None): """Constructor :param parent: parent - widget to use as parent. :type parent: QWidget """ QWidget.__init__(self, parent) self.parent = parent self.setupUi(self) self.keyword_io = KeywordIO() self.impact_function_manager = ImpactFunctionManager()