def setUp(self):
"""Create shared resources that all tests can use"""
self.calculator = ImpactCalculator()
self.vector_path = os.path.join(TESTDATA, 'Padang_WGS84.shp')
self.vector_layer = read_safe_layer(self.vector_path)
self.raster_shake_path = os.path.join(HAZDATA,
'Shakemap_Padang_2009.asc')
self.raster_shake = read_safe_layer(self.raster_shake_path)
# UTM projected layer
fn = 'tsunami_max_inundation_depth_BB_utm.asc'
self.raster_tsunami_path = os.path.join(TESTDATA, fn)
self.raster_exposure_path = os.path.join(
TESTDATA, 'tsunami_building_exposure.shp')
self.raster_population_path = os.path.join(EXPDATA, 'glp10ag.asc')
self.calculator.set_hazard_layer(self.raster_shake)
self.calculator.set_exposure_layer(self.vector_layer)
self.calculator.set_function('Earthquake Building Impact Function')
def setUp(self):
"""Create shared resources that all tests can use"""
register_impact_functions()
self.calculator = ImpactCalculator()
self.vector_path = os.path.join(TESTDATA, 'Padang_WGS84.shp')
self.vector_layer = read_safe_layer(self.vector_path)
self.raster_shake_path = os.path.join(
HAZDATA, 'Shakemap_Padang_2009.asc')
self.raster_shake = read_safe_layer(self.raster_shake_path)
# UTM projected layer
fn = 'tsunami_max_inundation_depth_BB_utm.asc'
self.raster_tsunami_path = os.path.join(TESTDATA, fn)
self.raster_exposure_path = os.path.join(
TESTDATA, 'tsunami_building_exposure.shp')
self.raster_population_path = os.path.join(EXPDATA, 'glp10ag.asc')
self.calculator.set_hazard_layer(self.raster_shake)
self.calculator.set_exposure_layer(self.vector_layer)
self.calculator.set_function('EarthquakeBuildingFunction')
self.impact_function_manager = ImpactFunctionManager()
def test_issue100(self):
"""Test for issue 100: unhashable type dict"""
exposure_path = os.path.join(TESTDATA,
'OSM_building_polygons_20110905.shp')
hazard_path = os.path.join(
HAZDATA, 'Flood_Current_Depth_Jakarta_geographic.asc')
# Verify relevant metada is ok
h = read_safe_layer(hazard_path)
e = read_safe_layer(exposure_path)
self.calculator.set_hazard_layer(h)
self.calculator.set_exposure_layer(e)
self.calculator.set_function('Flood Raster Building Impact Function')
try:
function_runner = self.calculator.get_runner()
# Run non threaded
function_runner.run()
message = function_runner.result()
impact_layer = function_runner.impact_layer()
file_name = impact_layer.get_filename()
assert (file_name and not file_name == '')
assert (message and not message == '')
except Exception, e: # pylint: disable=W0703
message = 'Calculator run failed. %s' % str(e)
assert (), message
def test_issue100(self):
"""Test for issue 100: unhashable type dict"""
exposure_path = os.path.join(
TESTDATA, 'OSM_building_polygons_20110905.shp')
hazard_path = os.path.join(
HAZDATA, 'Flood_Current_Depth_Jakarta_geographic.asc')
# Verify relevant metada is ok
h = read_safe_layer(hazard_path)
e = read_safe_layer(exposure_path)
self.calculator.set_hazard_layer(h)
self.calculator.set_exposure_layer(e)
self.calculator.set_function('FloodRasterBuildingFunction')
try:
function_runner = self.calculator.get_runner()
# Run non threaded
function_runner.run()
message = function_runner.result()
impact_layer = function_runner.impact_layer()
file_name = impact_layer.get_filename()
assert(file_name and not file_name == '')
assert(message and not message == '')
except Exception, e: # pylint: disable=W0703
message = 'Calculator run failed. %s' % str(e)
assert(), message
def test_raster_scaling_projected(self):
"""Attempt to scale projected density raster layers raise exception.
Automatic scaling when resampling density data
does not currently work for projected layers. See issue #123.
For the time being this test checks that an exception is raised
when scaling is attempted on projected layers.
When we resolve issue #123, this test should be rewritten.
"""
test_filename = 'Population_Jakarta_UTM48N.tif'
raster_path = ('%s/%s' % (TESTDATA, test_filename))
# Get reference values
safe_layer = read_safe_layer(raster_path)
min_value, max_value = safe_layer.get_extrema()
native_resolution = safe_layer.get_resolution()
print min_value, max_value
print native_resolution
# Define bounding box in EPSG:4326
bounding_box = [106.61, -6.38, 107.05, -6.07]
resolutions = [0.02, 0.01, 0.005, 0.002, 0.001]
# Test for a range of resolutions
for resolution in resolutions:
# Clip the raster to the bbox
extra_keywords = {'resolution': native_resolution}
raster_layer = QgsRasterLayer(raster_path, 'xxx')
try:
clip_layer(
raster_layer,
bounding_box,
resolution,
extra_keywords=extra_keywords
)
except InvalidProjectionError:
pass
else:
message = 'Should have raised InvalidProjectionError'
raise Exception(message)
def test_raster_scaling(self):
"""Raster layers can be scaled when resampled.
This is a test for ticket #52
Native test .asc data has
Population_Jakarta_geographic.asc
ncols 638
nrows 649
cellsize 0.00045228819716044
Population_2010.asc
ncols 5525
nrows 2050
cellsize 0.0083333333333333
Scaling is necessary for raster data that represents density
such as population per km^2
"""
filenames = [
'Population_Jakarta_geographic.asc',
'Population_2010.asc'
]
for filename in filenames:
raster_path = ('%s/%s' % (TESTDATA, filename))
# Get reference values
safe_layer = read_safe_layer(raster_path)
min_value, max_value = safe_layer.get_extrema()
del max_value
del min_value
native_resolution = safe_layer.get_resolution()
# Get the Hazard extents as an array in EPSG:4326
bounding_box = safe_layer.get_bounding_box()
resolutions = [
0.02,
0.01,
0.005,
0.002,
0.001,
0.0005, # Coarser
0.0002 # Finer
]
# Test for a range of resolutions
for resolution in resolutions: # Finer
# To save time only do two resolutions for the
# large population set
if filename.startswith('Population_2010'):
if resolution > 0.01 or resolution < 0.005:
break
# Clip the raster to the bbox
extra_keywords = {'resolution': native_resolution}
raster_layer = QgsRasterLayer(raster_path, 'xxx')
result = clip_layer(
raster_layer,
bounding_box,
resolution,
extra_keywords=extra_keywords
)
safe_layer = read_safe_layer(result.source())
native_data = safe_layer.get_data(scaling=False)
scaled_data = safe_layer.get_data(scaling=True)
sigma_value = (safe_layer.get_resolution()[0] /
native_resolution[0]) ** 2
# Compare extrema
expected_scaled_max = sigma_value * numpy.nanmax(native_data)
message = (
'Resampled raster was not rescaled correctly: '
'max(scaled_data) was %f but expected %f' %
(numpy.nanmax(scaled_data), expected_scaled_max))
# FIXME (Ole): The rtol used to be 1.0e-8 -
# now it has to be 1.0e-6, otherwise we get
# max(scaled_data) was 12083021.000000 but
# expected 12083020.414316
# Is something being rounded to the nearest
# integer?
assert numpy.allclose(expected_scaled_max,
numpy.nanmax(scaled_data),
rtol=1.0e-6, atol=1.0e-8), message
expected_scaled_min = sigma_value * numpy.nanmin(native_data)
message = (
'Resampled raster was not rescaled correctly: '
'min(scaled_data) was %f but expected %f' %
(numpy.nanmin(scaled_data), expected_scaled_min))
assert numpy.allclose(expected_scaled_min,
numpy.nanmin(scaled_data),
rtol=1.0e-8, atol=1.0e-12), message
# Compare element-wise
message = 'Resampled raster was not rescaled correctly'
assert nan_allclose(native_data * sigma_value, scaled_data,
rtol=1.0e-8, atol=1.0e-8), message
# Check that it also works with manual scaling
manual_data = safe_layer.get_data(scaling=sigma_value)
message = 'Resampled raster was not rescaled correctly'
assert nan_allclose(manual_data, scaled_data,
rtol=1.0e-8, atol=1.0e-8), message
# Check that an exception is raised for bad arguments
try:
safe_layer.get_data(scaling='bad')
except GetDataError:
pass
else:
message = 'String argument should have raised exception'
raise Exception(message)
try:
safe_layer.get_data(scaling='(1, 3)')
except GetDataError:
pass
else:
message = 'Tuple argument should have raised exception'
raise Exception(message)
# Check None option without keyword datatype == 'density'
safe_layer.keywords['datatype'] = 'undefined'
unscaled_data = safe_layer.get_data(scaling=None)
message = 'Data should not have changed'
assert nan_allclose(native_data, unscaled_data,
rtol=1.0e-12, atol=1.0e-12), message
# Try with None and density keyword
safe_layer.keywords['datatype'] = 'density'
unscaled_data = safe_layer.get_data(scaling=None)
message = 'Resampled raster was not rescaled correctly'
assert nan_allclose(scaled_data, unscaled_data,
rtol=1.0e-12, atol=1.0e-12), message
safe_layer.keywords['datatype'] = 'counts'
unscaled_data = safe_layer.get_data(scaling=None)
message = 'Data should not have changed'
assert nan_allclose(native_data, unscaled_data,
rtol=1.0e-12, atol=1.0e-12), message
def test_clip_both(self):
"""Raster and Vector layers can be clipped."""
# Create a vector layer
layer_name = 'padang'
vector_layer = QgsVectorLayer(VECTOR_PATH, layer_name, 'ogr')
message = (
'Did not find layer "%s" in path "%s"' % (layer_name, VECTOR_PATH))
assert vector_layer.isValid(), message
# Create a raster layer
layer_name = 'shake'
raster_layer = QgsRasterLayer(RASTERPATH, layer_name)
message = (
'Did not find layer "%s" in path "%s"' % (layer_name, RASTERPATH))
assert raster_layer.isValid(), message
# Create a bounding box
view_port_geo_extent = [99.53, -1.22, 101.20, -0.36]
# Get the Hazard extents as an array in EPSG:4326
hazard_geo_extent = [
raster_layer.extent().xMinimum(),
raster_layer.extent().yMinimum(),
raster_layer.extent().xMaximum(),
raster_layer.extent().yMaximum()
]
# Get the Exposure extents as an array in EPSG:4326
exposure_geo_extent = [
vector_layer.extent().xMinimum(),
vector_layer.extent().yMinimum(),
vector_layer.extent().xMaximum(),
vector_layer.extent().yMaximum()
]
# Now work out the optimal extent between the two layers and
# the current view extent. The optimal extent is the intersection
# between the two layers and the viewport.
# Extent is returned as an array [xmin,ymin,xmax,ymax]
geo_extent = get_optimal_extent(
hazard_geo_extent, exposure_geo_extent, view_port_geo_extent)
# Clip the vector to the bbox
result = clip_layer(vector_layer, geo_extent)
# Check the output is valid
assert os.path.exists(result.source())
read_safe_layer(result.source())
# Clip the raster to the bbox
result = clip_layer(raster_layer, geo_extent)
# Check the output is valid
assert os.path.exists(result.source())
read_safe_layer(result.source())
# -------------------------------
# Check the extra keywords option
# -------------------------------
# Clip the vector to the bbox
result = clip_layer(
vector_layer, geo_extent, extra_keywords={'title': 'piggy'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = read_safe_layer(result.source())
keywords = safe_layer.get_keywords()
# message = 'Extra keyword was not found in %s: %s' % (myResult,
# keywords)
assert keywords['title'] == 'piggy'
# Clip the raster to the bbox
result = clip_layer(
raster_layer, geo_extent, extra_keywords={'email': 'animal'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = read_safe_layer(result.source())
keywords = safe_layer.get_keywords()
message = ('Extra keyword was not found in %s: %s' %
(result.source(), keywords))
assert keywords['email'] == 'animal', message
def test_raster_scaling(self):
"""Raster layers can be scaled when resampled.
This is a test for ticket #52
Native test .asc data has
Population_Jakarta_geographic.asc
ncols 638
nrows 649
cellsize 0.00045228819716044
Population_2010.asc
ncols 5525
nrows 2050
cellsize 0.0083333333333333
Scaling is necessary for raster data that represents density
such as population per km^2
"""
filenames = [
'Population_Jakarta_geographic.asc', 'Population_2010.asc'
]
for filename in filenames:
raster_path = ('%s/%s' % (TESTDATA, filename))
# Get reference values
safe_layer = read_safe_layer(raster_path)
min_value, max_value = safe_layer.get_extrema()
del max_value
del min_value
native_resolution = safe_layer.get_resolution()
# Get the Hazard extents as an array in EPSG:4326
bounding_box = safe_layer.get_bounding_box()
resolutions = [
0.02,
0.01,
0.005,
0.002,
0.001,
0.0005, # Coarser
0.0002 # Finer
]
# Test for a range of resolutions
for resolution in resolutions: # Finer
# To save time only do two resolutions for the
# large population set
if filename.startswith('Population_2010'):
if resolution > 0.01 or resolution < 0.005:
break
# Clip the raster to the bbox
extra_keywords = {'resolution': native_resolution}
raster_layer = QgsRasterLayer(raster_path, 'xxx')
result = clip_layer(raster_layer,
bounding_box,
resolution,
extra_keywords=extra_keywords)
safe_layer = read_safe_layer(result.source())
native_data = safe_layer.get_data(scaling=False)
scaled_data = safe_layer.get_data(scaling=True)
sigma_value = (safe_layer.get_resolution()[0] /
native_resolution[0])**2
# Compare extrema
expected_scaled_max = sigma_value * numpy.nanmax(native_data)
message = ('Resampled raster was not rescaled correctly: '
'max(scaled_data) was %f but expected %f' %
(numpy.nanmax(scaled_data), expected_scaled_max))
# FIXME (Ole): The rtol used to be 1.0e-8 -
# now it has to be 1.0e-6, otherwise we get
# max(scaled_data) was 12083021.000000 but
# expected 12083020.414316
# Is something being rounded to the nearest
# integer?
assert numpy.allclose(expected_scaled_max,
numpy.nanmax(scaled_data),
rtol=1.0e-6,
atol=1.0e-8), message
expected_scaled_min = sigma_value * numpy.nanmin(native_data)
message = ('Resampled raster was not rescaled correctly: '
'min(scaled_data) was %f but expected %f' %
(numpy.nanmin(scaled_data), expected_scaled_min))
assert numpy.allclose(expected_scaled_min,
numpy.nanmin(scaled_data),
rtol=1.0e-8,
atol=1.0e-12), message
# Compare element-wise
message = 'Resampled raster was not rescaled correctly'
assert nan_allclose(native_data * sigma_value,
scaled_data,
rtol=1.0e-8,
atol=1.0e-8), message
# Check that it also works with manual scaling
manual_data = safe_layer.get_data(scaling=sigma_value)
message = 'Resampled raster was not rescaled correctly'
assert nan_allclose(manual_data,
scaled_data,
rtol=1.0e-8,
atol=1.0e-8), message
# Check that an exception is raised for bad arguments
try:
safe_layer.get_data(scaling='bad')
except GetDataError:
pass
else:
message = 'String argument should have raised exception'
raise Exception(message)
try:
safe_layer.get_data(scaling='(1, 3)')
except GetDataError:
pass
else:
message = 'Tuple argument should have raised exception'
raise Exception(message)
# Check None option without keyword datatype == 'density'
safe_layer.keywords['datatype'] = 'undefined'
unscaled_data = safe_layer.get_data(scaling=None)
message = 'Data should not have changed'
assert nan_allclose(native_data,
unscaled_data,
rtol=1.0e-12,
atol=1.0e-12), message
# Try with None and density keyword
safe_layer.keywords['datatype'] = 'density'
unscaled_data = safe_layer.get_data(scaling=None)
message = 'Resampled raster was not rescaled correctly'
assert nan_allclose(scaled_data,
unscaled_data,
rtol=1.0e-12,
atol=1.0e-12), message
safe_layer.keywords['datatype'] = 'counts'
unscaled_data = safe_layer.get_data(scaling=None)
message = 'Data should not have changed'
assert nan_allclose(native_data,
unscaled_data,
rtol=1.0e-12,
atol=1.0e-12), message
def test_clip_both(self):
"""Raster and Vector layers can be clipped."""
# Create a vector layer
layer_name = 'padang'
vector_layer = QgsVectorLayer(VECTOR_PATH, layer_name, 'ogr')
message = ('Did not find layer "%s" in path "%s"' %
(layer_name, VECTOR_PATH))
assert vector_layer.isValid(), message
# Create a raster layer
layer_name = 'shake'
raster_layer = QgsRasterLayer(RASTERPATH, layer_name)
message = ('Did not find layer "%s" in path "%s"' %
(layer_name, RASTERPATH))
assert raster_layer.isValid(), message
# Create a bounding box
view_port_geo_extent = [99.53, -1.22, 101.20, -0.36]
# Get the Hazard extents as an array in EPSG:4326
hazard_geo_extent = [
raster_layer.extent().xMinimum(),
raster_layer.extent().yMinimum(),
raster_layer.extent().xMaximum(),
raster_layer.extent().yMaximum()
]
# Get the Exposure extents as an array in EPSG:4326
exposure_geo_extent = [
vector_layer.extent().xMinimum(),
vector_layer.extent().yMinimum(),
vector_layer.extent().xMaximum(),
vector_layer.extent().yMaximum()
]
# Now work out the optimal extent between the two layers and
# the current view extent. The optimal extent is the intersection
# between the two layers and the viewport.
# Extent is returned as an array [xmin,ymin,xmax,ymax]
geo_extent = get_optimal_extent(hazard_geo_extent, exposure_geo_extent,
view_port_geo_extent)
# Clip the vector to the bbox
result = clip_layer(vector_layer, geo_extent)
# Check the output is valid
assert os.path.exists(result.source())
read_safe_layer(result.source())
# Clip the raster to the bbox
result = clip_layer(raster_layer, geo_extent)
# Check the output is valid
assert os.path.exists(result.source())
read_safe_layer(result.source())
# -------------------------------
# Check the extra keywords option
# -------------------------------
# Clip the vector to the bbox
result = clip_layer(vector_layer,
geo_extent,
extra_keywords={'title': 'piggy'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = read_safe_layer(result.source())
keywords = safe_layer.get_keywords()
# message = 'Extra keyword was not found in %s: %s' % (myResult,
# keywords)
assert keywords['title'] == 'piggy'
# Clip the raster to the bbox
result = clip_layer(raster_layer,
geo_extent,
extra_keywords={'email': 'animal'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = read_safe_layer(result.source())
keywords = safe_layer.get_keywords()
message = ('Extra keyword was not found in %s: %s' %
(result.source(), keywords))
assert keywords['email'] == 'animal', message