def test_run(self): function = ClassifiedRasterHazardBuildingFunction.instance() hazard_path = standard_data_path( 'hazard', 'classified_hazard.tif') exposure_path = standard_data_path('exposure', 'small_building.shp') hazard_layer = read_layer(hazard_path) exposure_layer = read_layer(exposure_path) function.hazard = SafeLayer(hazard_layer) function.exposure = SafeLayer(exposure_layer) function.run_analysis() impact_layer = function.impact impact_data = impact_layer.get_data() # Count expected_impact = { 'Not affected': 5, 'Low hazard zone': 2, 'Medium hazard zone': 9, 'High hazard zone': 5 } result_impact = {} for impact_feature in impact_data: hazard_class = impact_feature[function.target_field] if hazard_class in result_impact: result_impact[hazard_class] += 1 else: result_impact[hazard_class] = 1 self.assertDictEqual(expected_impact, result_impact)
def test_run(self): """TestVolcanoPolygonBuildingFunction: Test running the IF.""" volcano_path = standard_data_path('hazard', 'volcano_krb.shp') building_path = standard_data_path('exposure', 'buildings.shp') hazard_layer = read_layer(volcano_path) exposure_layer = read_layer(building_path) impact_function = VolcanoPolygonBuildingFunction.instance() impact_function.hazard = SafeLayer(hazard_layer) impact_function.exposure = SafeLayer(exposure_layer) impact_function.run() impact_layer = impact_function.impact # Check the question expected_question = ( 'In the event of volcano krb how many buildings might be ' 'affected?') self.assertEqual(expected_question, impact_function.question) # The buildings should all be categorised into 5000 zone zone_sum = impact_layer.get_data( attribute=impact_function.target_field) krb3_zone_count = zone_sum.count('High Hazard Zone') krb2_zone_count = zone_sum.count('Medium Hazard Zone') # The result (counted by hand) expected_krb3_count = 11 expected_krb2_count = 161 message = 'Expecting %s for KRB III zone, but it returns %s' % ( krb3_zone_count, expected_krb3_count) self.assertEqual(krb3_zone_count, expected_krb3_count, message) message = 'Expecting %s for KRB II zone, but it returns %s' % ( krb2_zone_count, expected_krb2_count) self.assertEqual(krb2_zone_count, expected_krb2_count, message)
def test_run(self): """TestClassifiedPolygonPopulationFunction: Test running the IF.""" generic_polygon_path = standard_data_path( 'hazard', 'classified_generic_polygon.shp') population_path = standard_data_path( 'exposure', 'pop_binary_raster_20_20.asc') generic_polygon_layer = read_layer(generic_polygon_path) population_layer = read_layer(population_path) impact_function = ClassifiedPolygonHazardPopulationFunction.instance() impact_function.hazard = SafeLayer(generic_polygon_layer) impact_function.exposure = SafeLayer(population_layer) impact_function.run() impact_layer = impact_function.impact # Check the question expected_question = ('In each of the hazard zones how many people ' 'might be impacted.') message = 'The question should be %s, but it returns %s' % ( expected_question, impact_function.question) self.assertEqual(expected_question, impact_function.question, message) # Count by hand expected_affected_population = 181 result = numpy.nansum(impact_layer.get_data()) self.assertEqual(expected_affected_population, result, message)
def test_run(self): function = AshRasterPopulationFunction.instance() hazard_path = standard_data_path('hazard', 'ash_raster_wgs84.tif') exposure_path = standard_data_path( 'exposure', 'pop_binary_raster_20_20.asc') # We need clipping for both layers to be in the same dimension clipped_hazard, clipped_exposure = clip_layers( hazard_path, exposure_path) hazard_layer = read_layer(clipped_hazard.source()) exposure_layer = read_layer(clipped_exposure.source()) # Let's set the extent to the hazard extent function.hazard = SafeLayer(hazard_layer) function.exposure = SafeLayer(exposure_layer) function.run() impact = function.impact expected = [ [u'Population in very low hazard zone', 0], [u'Population in medium hazard zone', 1374], [u'Population in high hazard zone', 20], [u'Population in very high hazard zone', 0], [u'Population in low hazard zone', 8443], [u'Total affected population', 9837], [u'Unaffected population', 0], [u'Total population', 9837], [u'Population needing evacuation <sup>1</sup>', 9837] ] self.assertListEqual( expected, impact.impact_data['impact summary']['fields'])
def test_run(self): """TestVolcanoPointPopulationFunction: Test running the IF.""" merapi_point_path = standard_data_path('hazard', 'volcano_point.shp') population_path = standard_data_path('exposure', 'pop_binary_raster_20_20.asc') merapi_point_layer = read_layer(merapi_point_path) population_layer = read_layer(population_path) impact_function = VolcanoPointPopulationFunction.instance() # Run merapi point impact_function.hazard = SafeLayer(merapi_point_layer) impact_function.exposure = SafeLayer(population_layer) impact_function._prepare() impact_function.run() impact_layer = impact_function.impact # Check the question expected_question = ( 'In the event of a volcano point how many people might be ' 'impacted?') self.assertEqual(expected_question, impact_function.question) # Count by hand expected_affected_population = 200 result = numpy.nansum(impact_layer.get_data()) self.assertEqual(expected_affected_population, result)
def test_run(self): function = FloodRasterRoadsFunction.instance() hazard_path = standard_data_path('hazard', 'continuous_flood_20_20.asc') exposure_path = standard_data_path('exposure', 'roads.shp') # noinspection PyCallingNonCallable hazard_layer = QgsRasterLayer(hazard_path, 'Flood') # noinspection PyCallingNonCallable exposure_layer = QgsVectorLayer(exposure_path, 'Roads', 'ogr') # Let's set the extent to the hazard extent extent = hazard_layer.extent() rect_extent = [ extent.xMinimum(), extent.yMaximum(), extent.xMaximum(), extent.yMinimum() ] function.hazard = SafeLayer(hazard_layer) function.exposure = SafeLayer(exposure_layer) function.requested_extent = rect_extent function.run() impact = function.impact keywords = impact.get_keywords() self.assertEquals(function.target_field, keywords['target_field']) expected_inundated_feature = 182 count = sum(impact.get_data(attribute=function.target_field)) self.assertEquals(count, expected_inundated_feature)
def test_run(self): """TestVolcanoPolygonPopulationFunction: Test running the IF.""" merapi_krb_path = standard_data_path('hazard', 'volcano_krb.shp') population_path = standard_data_path( 'exposure', 'pop_binary_raster_20_20.asc') merapi_krb_layer = read_layer(merapi_krb_path) population_layer = read_layer(population_path) impact_function = VolcanoPolygonPopulationFunction.instance() # 2. Run merapi krb impact_function.hazard = SafeLayer(merapi_krb_layer) impact_function.exposure = SafeLayer(population_layer) impact_function.run() impact_layer = impact_function.impact # Check the question expected_question = ( 'In the event of volcano krb how many population might need ' 'evacuation?') self.assertEqual(expected_question, impact_function.question) # Count by hand expected_affected_population = 181 result = numpy.nansum(impact_layer.get_data()) self.assertEqual(expected_affected_population, result)
def test_run(self): """TestVolcanoPointPopulationFunction: Test running the IF.""" merapi_point_path = standard_data_path('hazard', 'volcano_point.shp') population_path = standard_data_path( 'exposure', 'pop_binary_raster_20_20.asc') merapi_point_layer = read_layer(merapi_point_path) population_layer = read_layer(population_path) impact_function = VolcanoPointPopulationFunction.instance() # Run merapi point impact_function.hazard = SafeLayer(merapi_point_layer) impact_function.exposure = SafeLayer(population_layer) impact_function._prepare() impact_function.run() impact_layer = impact_function.impact # Check the question expected_question = ( 'In the event of a volcano point how many people might be ' 'impacted?') self.assertEqual(expected_question, impact_function.question) # Count by hand expected_affected_population = 200 result = numpy.nansum(impact_layer.get_data()) self.assertEqual(expected_affected_population, result)
def test_run(self): impact_function = FloodRasterBuildingFunction.instance() hazard_path = standard_data_path("hazard", "continuous_flood_20_20.asc") exposure_path = standard_data_path("exposure", "buildings.shp") hazard_layer = read_layer(hazard_path) exposure_layer = read_layer(exposure_path) impact_function.hazard = SafeLayer(hazard_layer) impact_function.exposure = SafeLayer(exposure_layer) impact_function.run() impact_layer = impact_function.impact # Extract calculated result impact_data = impact_layer.get_data() self.assertEqual(len(impact_data), 181) # 1 = inundated, 2 = wet, 3 = dry expected_result = {1: 64, 2: 117, 3: 0} result = {1: 0, 2: 0, 3: 0} for feature in impact_data: inundated_status = feature[impact_function.target_field] result[inundated_status] += 1 message = "Expecting %s, but it returns %s" % (expected_result, result) self.assertEqual(expected_result, result, message)
def test_run(self): function = FloodPolygonRoadsFunction.instance() hazard_path = standard_data_path('hazard', 'flood_multipart_polygons.shp') exposure_path = standard_data_path('exposure', 'roads.shp') # noinspection PyCallingNonCallable hazard_layer = QgsVectorLayer(hazard_path, 'Flood', 'ogr') # noinspection PyCallingNonCallable exposure_layer = QgsVectorLayer(exposure_path, 'Roads', 'ogr') # Let's set the extent to the hazard extent extent = hazard_layer.extent() rect_extent = [ extent.xMinimum(), extent.yMaximum(), extent.xMaximum(), extent.yMinimum() ] function.hazard = SafeLayer(hazard_layer) function.exposure = SafeLayer(exposure_layer) function.requested_extent = rect_extent function.run() impact = function.impact # Count of flooded objects is calculated "by the hands" # the count = 69 expected_feature_total = 69 count = sum(impact.get_data(attribute=function.target_field)) message = 'Expecting %s, but it returns %s' % (expected_feature_total, count) self.assertEquals(count, expected_feature_total, message)
def test_set_layers(self): """ Test set up aggregator's layers work """ hazard = QgsVectorLayer( standard_data_path('hazard', 'multipart_polygons_osm_4326.shp'), 'hazard', 'ogr') exposure = QgsVectorLayer( standard_data_path('exposure', 'buildings_osm_4326.shp'), 'impact', 'ogr') aggregation_layer = QgsVectorLayer( os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'), 'test aggregation', 'ogr') # Test in # aoi mode (use None) # not aoi mode (use aggregation_layer) for agg_layer in [None, aggregation_layer]: aggregator = Aggregator(self.extent, None) aggregator.set_layers(hazard, exposure) self.assertEquals(aggregator.exposure_layer, exposure) self.assertEquals(aggregator.hazard_layer, hazard) layer = aggregator.layer extent = layer.extent() x_min, y_min, x_max, y_max = \ extent.xMinimum(), extent.yMinimum(), \ extent.xMaximum(), extent.yMaximum() self.assertAlmostEquals(self.extent[0], x_min) self.assertAlmostEquals(self.extent[1], y_min) self.assertAlmostEquals(self.extent[2], x_max) self.assertAlmostEquals(self.extent[3], y_max) self.assertTrue(aggregator.safe_layer.is_vector) _ = agg_layer
def test_run(self): """TestVolcanoPointBuildingFunction: Test running the IF.""" volcano_path = standard_data_path('hazard', 'volcano_point.shp') building_path = standard_data_path('exposure', 'buildings.shp') hazard_layer = read_layer(volcano_path) exposure_layer = read_layer(building_path) impact_function = VolcanoPointBuildingFunction.instance() impact_function.hazard = SafeLayer(hazard_layer) impact_function.exposure = SafeLayer(exposure_layer) impact_function._prepare() impact_function.run() impact_layer = impact_function.impact # Check the question expected_question = ( 'In the event of volcano point how many buildings might be ' 'affected') message = 'The question should be %s, but it returns %s' % ( expected_question, impact_function.question) self.assertEqual(expected_question, impact_function.question, message) # The buildings should all be categorised into 3000 zone zone_sum = sum(impact_layer.get_data( attribute=impact_function.target_field)) expected_sum = 3 * 181 message = 'Expecting %s, but it returns %s' % (expected_sum, zone_sum) self.assertEqual(zone_sum, expected_sum, message)
def test_run(self): function = FloodRasterRoadsFunction.instance() hazard_path = standard_data_path( 'hazard', 'continuous_flood_20_20.asc') exposure_path = standard_data_path('exposure', 'roads.shp') # noinspection PyCallingNonCallable hazard_layer = QgsRasterLayer(hazard_path, 'Flood') # noinspection PyCallingNonCallable exposure_layer = QgsVectorLayer(exposure_path, 'Roads', 'ogr') # Let's set the extent to the hazard extent extent = hazard_layer.extent() rect_extent = [ extent.xMinimum(), extent.yMaximum(), extent.xMaximum(), extent.yMinimum()] function.hazard = SafeLayer(hazard_layer) function.exposure = SafeLayer(exposure_layer) function.requested_extent = rect_extent function.run() impact = function.impact keywords = impact.get_keywords() self.assertEquals(function.target_field, keywords['target_field']) expected_inundated_feature = 182 count = sum(impact.get_data(attribute=function.target_field)) self.assertEquals(count, expected_inundated_feature)
def test_run(self): function = ContinuousHazardPopulationFunction.instance() hazard_path = standard_data_path( 'hazard', 'continuous_flood_20_20.asc') exposure_path = standard_data_path( 'exposure', 'pop_binary_raster_20_20.asc') hazard_layer = read_layer(hazard_path) exposure_layer = read_layer(exposure_path) function.hazard = SafeLayer(hazard_layer) function.exposure = SafeLayer(exposure_layer) function.run() impact = function.impact # print "keywords", keywords keywords = impact.get_keywords() total_needs_full = keywords['total_needs'] total_needs_weekly = OrderedDict([ [x['table name'], x['amount']] for x in total_needs_full['weekly'] ]) total_needs_single = OrderedDict([ [x['table name'], x['amount']] for x in total_needs_full['single'] ]) self.assertEqual(total_needs_weekly['Rice [kg]'], 336) self.assertEqual(total_needs_weekly['Drinking Water [l]'], 2100) self.assertEqual(total_needs_weekly['Clean Water [l]'], 8040) self.assertEqual(total_needs_weekly['Family Kits'], 24) self.assertEqual(total_needs_single['Toilets'], 6)
def test_is_polygonal_layer(self): """Test we can get the correct attributes back""" # Polygon layer layer = clone_shp_layer( name='district_osm_jakarta', include_keywords=True, source_directory=standard_data_path('boundaries')) message = 'isPolygonLayer, %s layer should be polygonal' % layer self.assertTrue(is_polygon_layer(layer), message) # Point layer layer = clone_shp_layer( name='volcano_point', include_keywords=True, source_directory=standard_data_path('hazard')) message = '%s layer should be polygonal' % layer self.assertFalse(is_polygon_layer(layer), message) layer = clone_raster_layer( name='padang_tsunami_mw8', extension='.tif', include_keywords=True, source_directory=standard_data_path('hazard') ) message = ('%s raster layer should not be polygonal' % layer) self.assertFalse(is_polygon_layer(layer), message)
def test_run(self): impact_function = FloodRasterBuildingFunction.instance() hazard_path = standard_data_path('hazard', 'continuous_flood_20_20.asc') exposure_path = standard_data_path('exposure', 'buildings.shp') hazard_layer = read_layer(hazard_path) exposure_layer = read_layer(exposure_path) impact_function.hazard = SafeLayer(hazard_layer) impact_function.exposure = SafeLayer(exposure_layer) impact_function.run() impact_layer = impact_function.impact # Extract calculated result impact_data = impact_layer.get_data() self.assertEqual(len(impact_data), 181) # 1 = inundated, 2 = wet, 3 = dry expected_result = {1: 64, 2: 117, 3: 0} result = {1: 0, 2: 0, 3: 0} for feature in impact_data: inundated_status = feature[impact_function.target_field] result[inundated_status] += 1 message = 'Expecting %s, but it returns %s' % (expected_result, result) self.assertEqual(expected_result, result, message)
def test_run(self): """TestVolcanoPolygonPopulationFunction: Test running the IF.""" merapi_krb_path = standard_data_path('hazard', 'volcano_krb.shp') population_path = standard_data_path('exposure', 'pop_binary_raster_20_20.asc') merapi_krb_layer = read_layer(merapi_krb_path) population_layer = read_layer(population_path) impact_function = VolcanoPolygonPopulationFunction.instance() # 2. Run merapi krb impact_function.hazard = SafeLayer(merapi_krb_layer) impact_function.exposure = SafeLayer(population_layer) impact_function.run() impact_layer = impact_function.impact # Check the question expected_question = ( 'In the event of volcano krb how many population might need ' 'evacuation?') self.assertEqual(expected_question, impact_function.question) # Count by hand expected_affected_population = 181 result = numpy.nansum(impact_layer.get_data()) self.assertEqual(expected_affected_population, result)
def test_run(self): """TestVolcanoPointBuildingFunction: Test running the IF.""" volcano_path = standard_data_path('hazard', 'volcano_point.shp') building_path = standard_data_path('exposure', 'buildings.shp') hazard_layer = read_layer(volcano_path) exposure_layer = read_layer(building_path) impact_function = VolcanoPointBuildingFunction.instance() impact_function.hazard = SafeLayer(hazard_layer) impact_function.exposure = SafeLayer(exposure_layer) impact_function._prepare() impact_function.run() impact_layer = impact_function.impact # Check the question expected_question = ( 'In the event of volcano point how many buildings might be ' 'affected?') self.assertEqual(expected_question, impact_function.question) # The buildings should all be categorised into 3000 zone zone_sum = sum( impact_layer.get_data(attribute=impact_function.target_field)) expected_sum = 3 * 181 message = 'Expecting %s, but it returns %s' % (expected_sum, zone_sum) self.assertEqual(zone_sum, expected_sum, message)
def test_run_without_population_field(self): impact_function = AshRasterPlacesFunction.instance() hazard_path = standard_data_path("hazard", "ash_raster_wgs84.tif") exposure_path = standard_data_path("exposure", "places.shp") hazard_layer = QgsRasterLayer(hazard_path, "Ash") exposure_layer = QgsVectorLayer(exposure_path, "Places", "ogr") impact_function.hazard = hazard_layer impact_function.exposure = exposure_layer # Let's set the extent to the hazard extent extent = hazard_layer.extent() rect_extent = [extent.xMinimum(), extent.yMaximum(), extent.xMaximum(), extent.yMinimum()] impact_function.requested_extent = rect_extent impact_function.run() impact_layer = impact_function.impact # Extract calculated result impact_data = impact_layer.get_data() # 1 = inundated, 2 = wet, 3 = dry expected_result = {0: 0, 1: 135, 2: 62, 3: 1, 4: 0} result = {0: 0, 1: 0, 2: 0, 3: 0, 4: 0} for feature in impact_data: inundated_status = feature[impact_function.target_field] result[inundated_status] += 1 self.assertDictEqual(expected_result, result)
def test_issue71(self): """Test issue #71 in github - cbo changes should update ok button.""" # See https://github.com/AIFDR/inasafe/issues/71 settings = QtCore.QSettings() settings.setValue('inasafe/analysis_extents_mode', 'HazardExposure') self.tearDown() button = self.dock.pbnRunStop # First part of scenario should have enabled run file_list = [ standard_data_path('hazard', 'continuous_flood_20_20.asc'), standard_data_path('exposure', 'pop_binary_raster_20_20.asc') ] hazard_layer_count, exposure_layer_count = load_layers(file_list) message = ('Incorrect number of Hazard layers: expected 1 got %s' % hazard_layer_count) self.assertTrue(hazard_layer_count == 1, message) message = ('Incorrect number of Exposure layers: expected 1 got %s' % exposure_layer_count) self.assertTrue(exposure_layer_count == 1, message) message = 'Run button was not enabled' self.assertTrue(button.isEnabled(), message) # Second part of scenario - run disabled when adding invalid layer # and select it - run should be disabled path = os.path.join(TESTDATA, 'issue71.tif') file_list = [path] # This layer has incorrect keywords clear_flag = False _, _ = load_layers(file_list, clear_flag) # set exposure to : Population Count (5kmx5km) # by moving one down self.dock.cboExposure.setCurrentIndex( self.dock.cboExposure.currentIndex() + 1) actual_dict = get_ui_state(self.dock) expected_dict = { 'Run Button Enabled': False, 'Impact Function Id': '', 'Impact Function Title': '', 'Hazard': 'Continuous Flood', 'Exposure': 'Population Count (5kmx5km)' } message = (('Run button was not disabled when exposure set to \n%s' '\nUI State: \n%s\nExpected State:\n%s\n%s') % (self.dock.cboExposure.currentText(), actual_dict, expected_dict, combos_to_string(self.dock))) self.assertTrue(expected_dict == actual_dict, message) # Now select again a valid layer and the run button # should be enabled self.dock.cboExposure.setCurrentIndex( self.dock.cboExposure.currentIndex() - 1) message = ('Run button was not enabled when exposure set to \n%s' % self.dock.cboExposure.currentText()) self.assertTrue(button.isEnabled(), message)
def test_run_point_exposure(self): """Run the IF for point exposure. See https://github.com/AIFDR/inasafe/issues/2156. """ generic_polygon_path = standard_data_path( 'hazard', 'classified_generic_polygon.shp') building_path = standard_data_path('exposure', 'building-points.shp') hazard_layer = QgsVectorLayer(generic_polygon_path, 'Hazard', 'ogr') exposure_layer = QgsVectorLayer(building_path, 'Buildings', 'ogr') # Let's set the extent to the hazard extent extent = hazard_layer.extent() rect_extent = [ extent.xMinimum(), extent.yMaximum(), extent.xMaximum(), extent.yMinimum() ] impact_function = ClassifiedPolygonHazardBuildingFunction.instance() impact_function.hazard = SafeLayer(hazard_layer) impact_function.exposure = SafeLayer(exposure_layer) impact_function.requested_extent = rect_extent impact_function.run() impact_layer = impact_function.impact # Check the question expected_question = ( 'In each of the hazard zones how many buildings might be ' 'affected?') self.assertEqual(expected_question, impact_function.question) zone_sum = impact_layer.get_data( attribute=impact_function.target_field) high_zone_count = zone_sum.count('High Hazard Zone') medium_zone_count = zone_sum.count('Medium Hazard Zone') low_zone_count = zone_sum.count('Low Hazard Zone') # The result expected_high_count = 12 expected_medium_count = 172 expected_low_count = 3 message = 'Expecting %s for High Hazard Zone, but it returns %s' % ( high_zone_count, expected_high_count) self.assertEqual(high_zone_count, expected_high_count, message) message = 'Expecting %s for Medium Hazard Zone, but it returns %s' % ( expected_medium_count, medium_zone_count) self.assertEqual(medium_zone_count, expected_medium_count, message) message = 'Expecting %s for Low Hazard Zone, but it returns %s' % ( expected_low_count, low_zone_count) self.assertEqual(expected_low_count, low_zone_count, message)
def test_load_layer_from_uri(self): """Test we can load a layer with different parameters.""" # Without provider path = standard_data_path( 'gisv4', 'aggregation', 'small_grid.geojson') layer, purpose = load_layer(path) self.assertTrue(layer.isValid()) self.assertEqual(layer.name(), 'small_grid') self.assertEqual(purpose, 'aggregation') layer, purpose = load_layer(path, 'foo') self.assertEqual(layer.name(), 'foo') # With internal URI internal_uri = full_layer_uri(layer) self.assertTrue( internal_uri.endswith('small_grid.geojson|qgis_provider=ogr'), internal_uri ) layer, purpose = load_layer(full_layer_uri(layer)) self.assertTrue(layer.isValid()) self.assertEqual(layer.name(), 'small_grid') self.assertEqual(purpose, 'aggregation') # path plus extra layer parameter path = standard_data_path( 'gisv4', 'aggregation', 'small_grid.geojson') path += '|layerid=0' layer, purpose = load_layer(path) self.assertTrue(layer.isValid()) self.assertEqual(layer.name(), 'small_grid') self.assertEqual(purpose, 'aggregation') # CSV path = standard_data_path( 'gisv4', 'impacts', 'exposure_summary_table.csv') layer, purpose = load_layer(path) self.assertTrue(layer.isValid()) self.assertEqual(layer.name(), 'exposure_summary_table') self.assertEqual(purpose, 'undefined') self.assertEqual(len(layer.fields()), 4) # QLR # This QLR contains a file based reference layer to # small_grid.geojson, and it should work the same way # as if we load small_grid.geojson # In practice we could put the non file-based layer (PostGIS/WFS) # and load it from QLR path = standard_data_path( 'gisv4', 'aggregation', 'small_grid.qlr') layer, purpose = load_layer(path) self.assertTrue(layer.isValid()) self.assertEqual(layer.name(), 'small_grid') self.assertEqual(purpose, 'aggregation')
def test_run_point_exposure(self): """Run the IF for point exposure. See https://github.com/AIFDR/inasafe/issues/2156. """ generic_polygon_path = standard_data_path( 'hazard', 'classified_generic_polygon.shp') building_path = standard_data_path('exposure', 'building-points.shp') hazard_layer = QgsVectorLayer(generic_polygon_path, 'Hazard', 'ogr') exposure_layer = QgsVectorLayer(building_path, 'Buildings', 'ogr') # Let's set the extent to the hazard extent extent = hazard_layer.extent() rect_extent = [ extent.xMinimum(), extent.yMaximum(), extent.xMaximum(), extent.yMinimum()] impact_function = ClassifiedPolygonHazardBuildingFunction.instance() impact_function.hazard = SafeLayer(hazard_layer) impact_function.exposure = SafeLayer(exposure_layer) impact_function.requested_extent = rect_extent impact_function.run() impact_layer = impact_function.impact # Check the question expected_question = ('In each of the hazard zones how many buildings ' 'might be affected.') message = 'The question should be %s, but it returns %s' % ( expected_question, impact_function.question) self.assertEqual(expected_question, impact_function.question, message) zone_sum = impact_layer.get_data( attribute=impact_function.target_field) high_zone_count = zone_sum.count('High Hazard Zone') medium_zone_count = zone_sum.count('Medium Hazard Zone') low_zone_count = zone_sum.count('Low Hazard Zone') # The result expected_high_count = 12 expected_medium_count = 172 expected_low_count = 3 message = 'Expecting %s for High Hazard Zone, but it returns %s' % ( high_zone_count, expected_high_count) self.assertEqual(high_zone_count, expected_high_count, message) message = 'Expecting %s for Medium Hazard Zone, but it returns %s' % ( expected_medium_count, medium_zone_count) self.assertEqual(medium_zone_count, expected_medium_count, message) message = 'Expecting %s for Low Hazard Zone, but it returns %s' % ( expected_low_count, low_zone_count) self.assertEqual(expected_low_count, low_zone_count, message)
def test_raster_to_vector_and_line_intersection(self): """Test the core part of the analysis. 1. Test creation of spatial index of flood cells 2. Test intersection of flood cells with roads layer """ raster_name = standard_data_path( 'hazard', 'tsunami_wgs84.tif') exposure_name = standard_data_path( 'exposure', 'roads_osm_4326.shp') raster = QgsRasterLayer(raster_name, 'Flood') exposure = QgsVectorLayer(exposure_name, 'Exposure', 'ogr') ranges = OrderedDict() ranges[0] = [0, 1] ranges[1] = [1, 2] ranges[2] = [2, 100] index, flood_cells_map = _raster_to_vector_cells( raster, ranges, exposure.crs()) self.assertEqual(len(flood_cells_map), 4198) rect_with_all_cells = raster.extent() rect_with_4_cells = QgsRectangle(106.824, -6.177, 106.825, -6.179) rect_with_0_cells = QgsRectangle(106.818, -6.168, 106.828, -6.175) self.assertEqual(len(index.intersects(rect_with_all_cells)), 4198) self.assertEqual(len(index.intersects(rect_with_4_cells)), 43) self.assertEqual(len(index.intersects(rect_with_0_cells)), 504) layer = create_layer(exposure) new_field = QgsField('flooded', QVariant.Int) layer.dataProvider().addAttributes([new_field]) request = QgsFeatureRequest() _intersect_lines_with_vector_cells( exposure, request, index, flood_cells_map, layer, 'flooded') feature_count = layer.featureCount() self.assertEqual(feature_count, 388) flooded = 0 iterator = layer.getFeatures() for feature in iterator: attributes = feature.attributes() if attributes[3] == 1: flooded += 1 self.assertEqual(flooded, 40)
def test_write_read_iso_19115_metadata(self): """Test for write_read_iso_19115_metadata.""" keywords = { # 'date': '26-03-2015 14:03', 'exposure': 'structure', 'keyword_version': inasafe_keyword_version, 'layer_geometry': 'polygon', 'layer_mode': 'classified', 'layer_purpose': 'exposure', 'license': 'Open Data Commons Open Database License (ODbL)', 'source': 'OpenStreetMap - www.openstreetmap.org', 'title': 'Buildings', 'inasafe_fields': { 'youth_count_field': [ 'POP_F_0-4', 'POP_F_5-6', 'POP_F_7-12', ] } } layer = clone_shp_layer( name='buildings', include_keywords=False, source_directory=standard_data_path('exposure')) write_iso19115_metadata(layer.source(), keywords) read_metadata = read_iso19115_metadata(layer.source()) self.assertDictEqual(keywords, read_metadata) # Version 3.5 keywords = { # 'date': '26-03-2015 14:03', 'exposure': 'structure', 'keyword_version': '3.2', 'layer_geometry': 'polygon', 'layer_mode': 'classified', 'layer_purpose': 'exposure', 'license': 'Open Data Commons Open Database License (ODbL)', 'source': 'OpenStreetMap - www.openstreetmap.org', 'structure_class_field': 'TYPE', 'title': 'Buildings' } layer = clone_shp_layer( name='buildings', include_keywords=False, source_directory=standard_data_path('exposure')) write_iso19115_metadata(layer.source(), keywords, version_35=True) read_metadata = read_iso19115_metadata(layer.source(), version_35=True) self.assertDictEqual(keywords, read_metadata)
def setUp(self): self.keyword_io = KeywordIO() # SQLite Layer uri = QgsDataSourceURI() sqlite_building_path = standard_data_path( 'exposure', 'exposure.sqlite') uri.setDatabase(sqlite_building_path) uri.setDataSource('', 'buildings_osm_4326', 'Geometry') self.sqlite_layer = QgsVectorLayer( uri.uri(), 'OSM Buildings', 'spatialite') self.expected_sqlite_keywords = { 'datatype': 'OSM' } # Raster Layer keywords hazard_path = standard_data_path('hazard', 'tsunami_wgs84.tif') self.raster_layer, _ = load_layer(hazard_path) self.expected_raster_keywords = { 'hazard_category': 'single_event', 'title': 'Generic Continuous Flood', 'hazard': 'flood', 'continuous_hazard_unit': 'generic', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': '3.5' } # Vector Layer keywords vector_path = standard_data_path('exposure', 'buildings_osm_4326.shp') self.vector_layer, _ = load_layer(vector_path) self.expected_vector_keywords = { 'keyword_version': '3.5', 'structure_class_field': 'FLOODED', 'value_mapping': {}, 'title': 'buildings_osm_4326', 'layer_geometry': 'polygon', 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'exposure': 'structure', } # Keyword less layer keywordless_path = standard_data_path('other', 'keywordless_layer.shp') self.keywordless_layer, _ = load_layer(keywordless_path) # Keyword file self.keyword_path = standard_data_path( 'exposure', 'buildings_osm_4326.xml')
def setUp(self): self.keyword_io = KeywordIO() # SQLite Layer uri = QgsDataSourceUri() sqlite_building_path = standard_data_path( 'exposure', 'exposure.sqlite') uri.setDatabase(sqlite_building_path) uri.setDataSource('', 'buildings_osm_4326', 'Geometry') self.sqlite_layer = QgsVectorLayer( uri.uri(), 'OSM Buildings', 'spatialite') self.expected_sqlite_keywords = { 'datatype': 'OSM' } # Raster Layer keywords hazard_path = standard_data_path('hazard', 'tsunami_wgs84.tif') self.raster_layer, _ = load_layer(hazard_path, provider='gdal') self.expected_raster_keywords = { 'hazard_category': 'single_event', 'title': 'Generic Continuous Flood', 'hazard': 'flood', 'continuous_hazard_unit': 'generic', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': '3.5' } # Vector Layer keywords vector_path = standard_data_path('exposure', 'buildings_osm_4326.shp') self.vector_layer, _ = load_layer(vector_path, provider='ogr') self.expected_vector_keywords = { 'keyword_version': '3.5', 'value_map': {}, 'title': 'buildings_osm_4326', 'layer_geometry': 'polygon', 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'exposure': 'structure', } # Keyword less layer keywordless_path = standard_data_path('other', 'keywordless_layer.shp') self.keywordless_layer, _ = load_layer( keywordless_path, provider='ogr') # Keyword file self.keyword_path = standard_data_path( 'exposure', 'buildings_osm_4326.xml')
def test_converting(self): """Test converting grif file to tiff.""" dialog = ShakemapConverterDialog(PARENT, IFACE) dialog.use_output_default.setEnabled(False) grid_path = standard_data_path( 'hazard', 'shake_data', '20131105060809', 'output', 'grid.xml') output_raster = unique_filename( prefix='result_grid', suffix='.tif', dir=temp_dir('test')) dialog.load_result.setEnabled(True) dialog.load_result.setChecked(False) dialog.input_path.setText(grid_path) dialog.nearest_mode.setChecked(True) dialog.output_path.setText(output_raster) button = dialog.button_box.button(QDialogButtonBox.Ok) button.click() msg = 'Raster is not created' output_path = '%s-nearest.tif' % output_raster[:-4] self.assertTrue(os.path.exists(output_path), msg)
def test_print_impact_table(self): """Test print impact table to pdf.""" impact_layer_path = standard_data_path( 'impact', 'population_affected_entire_area.shp') layer, _ = load_layer(impact_layer_path) # noinspection PyUnresolvedReferences,PyArgumentList QgsMapLayerRegistry.instance().addMapLayer(layer) # noinspection PyCallingNonCallable rect = QgsRectangle(106.8194, -6.2108, 106.8201, -6.1964) CANVAS.setExtent(rect) CANVAS.refresh() template = resources_path( 'qgis-composer-templates', 'a4-portrait-blue.qpt') report = ImpactReport(IFACE, template, layer) report.template = template # just to cover set template out_path = unique_filename( prefix='test_print_impact_table', suffix='.pdf', dir=temp_dir('test')) report.print_impact_table(out_path) # Check the file exists message = 'Rendered output does not exist: %s' % out_path self.assertTrue(os.path.exists(out_path), message) # Check the file is not corrupt message = 'The output file %s is corrupt' % out_path out_size = os.stat(out_path).st_size self.assertTrue(out_size > 0, message)
def test_transparency_of_minimum_value(self): """Test that transparency of minimum value works when set to 100% """ # This dataset has all cells with value 1.3 data_path = standard_data_path('other', 'issue126.tif') layer, _ = load_layer(data_path) # Note the float quantity values below style_info = { 'style_classes': [ {'colour': '#FFFFFF', 'transparency': 100, 'quantity': 0.0}, {'colour': '#38A800', 'quantity': 0.038362596547925065, 'transparency': 0, 'label': u'Rendah [0 orang/sel]'}, {'colour': '#79C900', 'transparency': 0, 'quantity': 0.07672519309585013}, {'colour': '#CEED00', 'transparency': 0, 'quantity': 0.1150877896437752}, {'colour': '#FFCC00', 'quantity': 0.15345038619170026, 'transparency': 0, 'label': u'Sedang [0 orang/sel]'}, {'colour': '#FF6600', 'transparency': 0, 'quantity': 0.19181298273962533}, {'colour': '#FF0000', 'transparency': 0, 'quantity': 0.23017557928755039}, {'colour': '#7A0000', 'quantity': 0.26853817583547546, 'transparency': 0, 'label': u'Tinggi [0 orang/sel]'}]} try: setRasterStyle(layer, style_info) except Exception, e: message = '\nCould not create raster style' e.args = (e.args[0] + message,) raise
def test_update_keywords(self): """Test append file keywords with update_keywords method.""" self.maxDiff = None layer = clone_raster_layer( name='tsunami_wgs84', extension='.tif', include_keywords=True, source_directory=standard_data_path('hazard')) new_keywords = {'hazard_category': 'multiple_event'} self.keyword_io.update_keywords(layer, new_keywords) keywords = self.keyword_io.read_keywords(layer) expected_keywords = { 'hazard_category': 'multiple_event', 'title': 'Tsunami', 'hazard': 'tsunami', 'continuous_hazard_unit': 'metres', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': inasafe_keyword_version } expected_keywords = { k: get_unicode(v) for k, v in expected_keywords.iteritems() } self.assertDictEqual(keywords, expected_keywords)
def test_preprocessing(self): """Preprocessing results are correct.""" # TODO - this needs to be fixed post dock refactor. layer_path = standard_data_path('hazard', 'flood_polygon_crosskabupaten.shp') # See qgis project in test data: vector_preprocessing_test.qgs # add additional layers file_list = [layer_path] load_layers(file_list, clear_flag=False) result, message = setup_scenario( self.DOCK, hazard='Flood Polygon Cross Kabupaten', exposure='Population', function_id='FloodEvacuationVectorHazardFunction', aggregation_layer=u"Dístríct's of Jakarta", aggregation_enabled_flag=True) assert result, message # Enable on-the-fly reprojection set_canvas_crs(GEOCRS, True) set_jakarta_extent(dock=self.DOCK) # Press RUN self.DOCK.accept() expected_feature_count = 5 aggregator = self.DOCK.impact_function.aggregator message = ( 'The preprocessing should have generated %s features, ' 'found %s' % (expected_feature_count, aggregator.preprocessed_feature_count)) self.assertEqual(expected_feature_count, aggregator.preprocessed_feature_count, message)
def test_relative_path(self): """Test we calculate the relative paths correctly when saving scenario. """ result, message = setup_scenario(self.DOCK, hazard='Classified Flood', exposure='Population') self.assertTrue(result, message) fake_dir = standard_data_path() scenario_file = unique_filename(prefix='scenarioTest', suffix='.txt', dir=fake_dir) exposure_layer = self.DOCK.get_exposure_layer().publicSource() hazard_layer = self.DOCK.get_hazard_layer().publicSource() relative_exposure = self.save_scenario_dialog.relative_path( scenario_file, exposure_layer) relative_hazard = self.save_scenario_dialog.relative_path( scenario_file, hazard_layer) if 'win32' in sys.platform: # windows self.assertEqual('exposure\\pop_binary_raster_20_20.asc', relative_exposure) self.assertEqual('hazard\\classified_flood_20_20.asc', relative_hazard) else: self.assertEqual('exposure/pop_binary_raster_20_20.asc', relative_exposure) self.assertEqual('hazard/classified_flood_20_20.asc', relative_hazard)
def test_retrieve_exposure_classes_lists(self): """Test retrieve_exposure_classes_lists method. .. versionadded:: 4.0 """ layer_paths = self.layer_paths_list expected_classes_lists = [ None, None, None, None, generic_structure_classes['classes'], generic_structure_classes['classes'], None, generic_road_classes['classes'] ] for layer_path, expected_classes in zip(layer_paths, expected_classes_lists): path = standard_data_path(*layer_path) layer, _ = load_layer(path) actual_classes = retrieve_exposure_classes_lists(layer) try: self.assertEqual(expected_classes, actual_classes) except Exception as e: LOGGER.error('Layer path: {path}'.format(path=path)) LOGGER.error( 'Expected {classes}'.format(classes=expected_classes)) LOGGER.error('Actual {classes}'.format(classes=actual_classes)) raise e
def test_retrieve_exposure_classes_lists(self): """Test retrieve_exposure_classes_lists method. .. versionadded:: 4.0 """ layer_paths = self.layer_paths_list expected_classes_lists = [ None, None, None, None, generic_structure_classes['classes'], generic_structure_classes['classes'], None, generic_road_classes['classes'] ] for layer_path, expected_classes in zip( layer_paths, expected_classes_lists): path = standard_data_path(*layer_path) layer, _ = load_layer(path) actual_classes = retrieve_exposure_classes_lists(layer) try: self.assertEqual( expected_classes, actual_classes) except Exception as e: LOGGER.error('Layer path: {path}'.format( path=path)) LOGGER.error('Expected {classes}'.format( classes=expected_classes)) LOGGER.error('Actual {classes}'.format( classes=actual_classes)) raise e
def test_error_message(self): """Test we can send error messages to the message viewer.""" text = self.fake_error() control_file_path = standard_data_path('control', 'files', 'test-error-message.txt') expected_result = open(control_file_path).read().replace('\n', '') self.assertEqual(text, expected_result)
def test_update_keywords(self): """Test append file keywords with update_keywords method.""" self.maxDiff = None layer = clone_raster_layer( name='tsunami_wgs84', extension='.tif', include_keywords=True, source_directory=standard_data_path('hazard')) new_keywords = { 'hazard_category': 'multiple_event' } self.keyword_io.update_keywords(layer, new_keywords) keywords = self.keyword_io.read_keywords(layer) expected_keywords = { 'hazard_category': 'multiple_event', 'title': 'Tsunami', 'hazard': 'tsunami', 'continuous_hazard_unit': 'metres', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': inasafe_keyword_version } expected_keywords = { k: get_unicode(v) for k, v in expected_keywords.iteritems() } self.assertDictEqual(keywords, expected_keywords)
def test_is_polygonal_layer(self): """Test we can get the correct attributes back""" # Polygon layer layer = load_test_vector_layer( 'aggregation', 'district_osm_jakarta.geojson', clone=True ) message = 'isPolygonLayer, %s layer should be polygonal' % layer self.assertTrue(is_polygon_layer(layer), message) # Point layer layer = load_test_vector_layer('hazard', 'volcano_point.geojson') message = '%s layer should be polygonal' % layer self.assertFalse(is_polygon_layer(layer), message) # Raster layer layer = clone_raster_layer( name='earthquake', extension='.tif', include_keywords=True, source_directory=standard_data_path('hazard') ) message = ('%s raster layer should not be polygonal' % layer) self.assertFalse(is_polygon_layer(layer), message)
def test_stacktrace_html(self): """Stack traces can be caught and rendered as html """ # This is about general exception handling, so ok to use catch-all # pylint: disable=W0703 try: bbox_intersection('aoeu', 'oaeu', []) except Exception, e: # Display message and traceback message = get_error_message(e) # print message message = message.to_text() self.assertIn(str(e), message) self.assertIn('line', message) self.assertIn('file', message) message = get_error_message(e) message = message.to_html() assert str(e) in message message = message.decode('string_escape') control_file_path = standard_data_path( 'control', 'files', 'test-stacktrace-html.txt') expected_results = open(control_file_path).read().replace('\n', '') self.assertIn(expected_results, message)
def test_read_existing_geopackage(self): """Test we can read an existing geopackage.""" path = standard_data_path('other', 'jakarta.gpkg') import os path = os.path.normpath(os.path.normcase(os.path.abspath(path))) geopackage = QFileInfo(path) data_store = GeoPackage(geopackage) # We should have 3 layers in this geopackage. self.assertEqual(len(data_store.layers()), 3) # Test we can load a vector layer. roads = QgsVectorLayer( data_store.layer_uri('roads'), 'Test', 'ogr' ) self.assertTrue(roads.isValid()) # Test we can load a raster layers. # This currently fails on windows... # So we have decorated it with expected fail on windows # Should pass on other platforms. path = data_store.layer_uri('flood') flood = QgsRasterLayer(path, 'flood') self.assertTrue(flood.isValid())
def test_layer_hazard_classification(self): """Test layer_hazard_classification method. .. versionadded:: 4.0 """ layer_paths = self.layer_paths_list expected_classifications = [ generic_hazard_classes, earthquake_mmi_scale, tsunami_hazard_classes, cyclone_au_bom_hazard_classes, None, None, None, None, ] for layer_path, expected_classification in zip( layer_paths, expected_classifications): path = standard_data_path(*layer_path) layer, _ = load_layer(path) # inject classification keyword if expected_classification: layer.keywords['classification'] = ( expected_classification['key']) actual_classification = layer_hazard_classification(layer) try: self.assertEqual(expected_classification, actual_classification) except Exception as e: LOGGER.error('Layer path: {path}'.format(path=path)) LOGGER.error( 'Expected {name}'.format(**expected_classification)) LOGGER.error('Actual {name}'.format(**actual_classification)) raise e
def test_read_iso19115_metadata(self): """Test for read_iso19115_metadata method.""" exposure_layer = clone_shp_layer( name='buildings', include_keywords=False, source_directory=standard_data_path('exposure')) keywords = { # 'date': '26-03-2015 14:03', 'exposure': 'structure', 'keyword_version': inasafe_keyword_version, 'layer_geometry': 'polygon', 'layer_mode': 'classified', 'layer_purpose': 'exposure', 'license': 'Open Data Commons Open Database License (ODbL)', 'source': 'OpenStreetMap - www.openstreetmap.org', 'title': 'Buildings' } write_iso19115_metadata(exposure_layer.source(), keywords) read_metadata = read_iso19115_metadata(exposure_layer.source()) for key in set(keywords.keys()) & set(read_metadata.keys()): self.assertEqual(read_metadata[key], keywords[key]) for key in set(keywords.keys()) - set(read_metadata.keys()): message = 'key %s is not found in ISO metadata' % key self.assertEqual(read_metadata[key], keywords[key], message) for key in set(read_metadata.keys()) - set(keywords.keys()): message = 'key %s is not found in old keywords' % key self.assertEqual(read_metadata[key], keywords[key], message)
def test_polygonize_thresholds(self): """Test polygonize raster using gdal with some thresholds.""" raster_path = standard_data_path('hazard', 'jakarta_flood_design.tif') inside_file_name, inside_layer_name, outside_file_name, \ outside_layer_name = polygonize_thresholds( raster_path, 0.5) # Syntactic sugar to ignore unused vars. _ = inside_layer_name _ = outside_layer_name driver = ogr.GetDriverByName('ESRI Shapefile') data_source = driver.Open(inside_file_name, 0) layer = data_source.GetLayer() feature_count = layer.GetFeatureCount() # print 'inside %s' % (inside_file_name) self.assertEquals(feature_count, 3) data_source2 = driver.Open(outside_file_name, 0) layer2 = data_source2.GetLayer() feature_count2 = layer2.GetFeatureCount() # print 'outside %s' % (outside_file_name) self.assertEquals(feature_count2, 1)
def setUp(self): """Setup before each test.""" # Download files (which are local files) to realtime-test temp folder local_path = os.path.join(temp_dir('realtime-test')) shake_data = standard_data_path('hazard', 'shake_data', SHAKE_ID) shutil.copytree( shake_data, os.path.join(local_path, 'shakemaps', SHAKE_ID))
def test_layer_definition_type(self): """Test layer_definition_type method. .. versionadded:: 4.0 """ layer_paths = self.layer_paths_list expected_definitions = [ hazard_generic, hazard_earthquake, hazard_tsunami, hazard_cyclone, exposure_structure, exposure_structure, exposure_population, exposure_road, ] for layer_path, expected_definition in zip(layer_paths, expected_definitions): path = standard_data_path(*layer_path) layer, _ = load_layer(path) actual_definition = layer_definition_type(layer) try: self.assertEqual(expected_definition, actual_definition) except Exception as e: LOGGER.error('Layer path: {path}'.format(path=path)) LOGGER.error('Expected {name}'.format(**expected_definition)) LOGGER.error('Actual {name}'.format(**actual_definition)) raise e
def test_relative_path(self): """Test we calculate the relative paths correctly when saving scenario. """ result, message = setup_scenario( self.DOCK, hazard='Classified Flood', exposure='Population') self.assertTrue(result, message) fake_dir = standard_data_path() scenario_file = unique_filename( prefix='scenarioTest', suffix='.txt', dir=fake_dir) exposure_layer = self.DOCK.get_exposure_layer().publicSource() hazard_layer = self.DOCK.get_hazard_layer().publicSource() relative_exposure = self.save_scenario_dialog.relative_path( scenario_file, exposure_layer) relative_hazard = self.save_scenario_dialog.relative_path( scenario_file, hazard_layer) if 'win32' in sys.platform: # windows self.assertEqual( 'exposure\\pop_binary_raster_20_20.asc', relative_exposure) self.assertEqual( 'hazard\\classified_flood_20_20.asc', relative_hazard) else: self.assertEqual( 'exposure/pop_binary_raster_20_20.asc', relative_exposure) self.assertEqual( 'hazard/classified_flood_20_20.asc', relative_hazard)
def test_write_read_iso_19115_metadata(self): """Test for write_read_iso_19115_metadata.""" keywords = { # 'date': '26-03-2015 14:03', 'exposure': 'structure', 'keyword_version': inasafe_keyword_version, 'layer_geometry': 'polygon', 'layer_mode': 'classified', 'layer_purpose': 'exposure', 'license': 'Open Data Commons Open Database License (ODbL)', 'source': 'OpenStreetMap - www.openstreetmap.org', 'title': 'Buildings', 'inasafe_fields': { 'youth_count_field': [ 'POP_F_0-4', 'POP_F_5-6', 'POP_F_7-12', ] } } layer = clone_shp_layer( name='buildings', include_keywords=False, source_directory=standard_data_path('exposure')) write_iso19115_metadata(layer.source(), keywords) read_metadata = read_iso19115_metadata(layer.source()) self.assertDictEqual(keywords, read_metadata)
def test_polygonize(self): """Test if we can polygonize a raster using GDAL.""" raster_path = standard_data_path( 'hazard', 'classified_flood_20_20.asc') driver = ogr.GetDriverByName('ESRI Shapefile') expected_field_name = 'my_field' shapefile = polygonize(raster_path, 1, expected_field_name) data_source = driver.Open(shapefile, 0) layer = data_source.GetLayer() layer_definition = layer.GetLayerDefn() field_name = layer_definition.GetFieldDefn(0).GetName() self.assertEqual(field_name, expected_field_name) self.assertEquals(layer.GetFeatureCount(), 400) layer.SetAttributeFilter('%s = 1' % expected_field_name) self.assertEquals(layer.GetFeatureCount(), 133) layer.SetAttributeFilter('%s = 2' % expected_field_name) self.assertEquals(layer.GetFeatureCount(), 134) layer.SetAttributeFilter('%s = 3' % expected_field_name) self.assertEquals(layer.GetFeatureCount(), 133)
def test_layer_definition_type(self): """Test layer_definition_type method. .. versionadded:: 4.0 """ layer_paths = self.layer_paths_list expected_definitions = [ hazard_generic, hazard_earthquake, hazard_tsunami, hazard_cyclone, exposure_structure, exposure_structure, exposure_population, exposure_road, ] for layer_path, expected_definition in zip( layer_paths, expected_definitions): path = standard_data_path(*layer_path) layer, _ = load_layer(path) actual_definition = layer_definition_type(layer) try: self.assertEqual(expected_definition, actual_definition) except Exception as e: LOGGER.error('Layer path: {path}'.format( path=path)) LOGGER.error('Expected {name}'.format( **expected_definition)) LOGGER.error('Actual {name}'.format( **actual_definition)) raise e