def test_getOptimalExtent(self):
"""Optimal extent is calculated correctly
"""
exposure_path = os.path.join(TESTDATA, 'Population_2010.asc')
hazard_path = os.path.join(HAZDATA,
'Lembang_Earthquake_Scenario.asc')
# Expected data
haz_metadata = {'bounding_box': (105.3000035,
-8.3749994999999995,
110.2914705,
-5.5667784999999999),
'resolution': (0.0083330000000000001,
0.0083330000000000001)}
exp_metadata = {'bounding_box': (94.972335000000001,
-11.009721000000001,
141.0140016666665,
6.0736123333332639),
'resolution': (0.0083333333333333003,
0.0083333333333333003)}
# Verify relevant metada is ok
H = readSafeLayer(hazard_path)
E = readSafeLayer(exposure_path)
hazard_bbox = H.get_bounding_box()
assert numpy.allclose(hazard_bbox, haz_metadata['bounding_box'],
rtol=1.0e-12, atol=1.0e-12)
exposure_bbox = E.get_bounding_box()
assert numpy.allclose(exposure_bbox, exp_metadata['bounding_box'],
rtol=1.0e-12, atol=1.0e-12)
hazard_res = H.get_resolution()
assert numpy.allclose(hazard_res, haz_metadata['resolution'],
rtol=1.0e-12, atol=1.0e-12)
exposure_res = E.get_resolution()
assert numpy.allclose(exposure_res, exp_metadata['resolution'],
rtol=1.0e-12, atol=1.0e-12)
# First, do some examples that produce valid results
ref_box = [105.3000035, -8.3749995, 110.2914705, -5.5667785]
view_port = [94.972335, -11.009721, 141.014002, 6.073612]
bbox = getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
assert numpy.allclose(bbox, ref_box, rtol=1.0e-12, atol=1.0e-12)
#testing with viewport clipping disabled
bbox = getOptimalExtent(hazard_bbox, exposure_bbox, None)
assert numpy.allclose(bbox, ref_box, rtol=1.0e-12, atol=1.0e-12)
view_port = [105.3000035,
-8.3749994999999995,
110.2914705,
-5.5667784999999999]
bbox = getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
assert numpy.allclose(bbox, ref_box,
rtol=1.0e-12, atol=1.0e-12)
# Very small viewport fully inside other layers
view_port = [106.0, -6.0, 108.0, -5.8]
bbox = getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
assert numpy.allclose(bbox, view_port,
rtol=1.0e-12, atol=1.0e-12)
# viewport that intersects hazard layer
view_port = [107.0, -6.0, 112.0, -3.0]
ref_box = [107, -6, 110.2914705, -5.5667785]
bbox = getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
assert numpy.allclose(bbox, ref_box,
rtol=1.0e-12, atol=1.0e-12)
# Then one where boxes don't overlap
view_port = [105.3, -4.3, 110.29, -2.5]
try:
getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
except InsufficientOverlapError, e:
myMessage = 'Did not find expected error message in %s' % str(e)
assert 'did not overlap' in str(e), myMessage
def test_clipBoth(self):
"""Raster and Vector layers can be clipped
"""
# Create a vector layer
myName = 'padang'
myVectorLayer = QgsVectorLayer(VECTOR_PATH, myName, 'ogr')
myMessage = 'Did not find layer "%s" in path "%s"' % \
(myName, VECTOR_PATH)
assert myVectorLayer.isValid(), myMessage
# Create a raster layer
myName = 'shake'
myRasterLayer = QgsRasterLayer(RASTERPATH, myName)
myMessage = 'Did not find layer "%s" in path "%s"' % \
(myName, RASTERPATH)
assert myRasterLayer.isValid(), myMessage
# Create a bounding box
myViewportGeoExtent = [99.53, -1.22, 101.20, -0.36]
# Get the Hazard extents as an array in EPSG:4326
myHazardGeoExtent = [myRasterLayer.extent().xMinimum(),
myRasterLayer.extent().yMinimum(),
myRasterLayer.extent().xMaximum(),
myRasterLayer.extent().yMaximum()]
# Get the Exposure extents as an array in EPSG:4326
myExposureGeoExtent = [myVectorLayer.extent().xMinimum(),
myVectorLayer.extent().yMinimum(),
myVectorLayer.extent().xMaximum(),
myVectorLayer.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]
myGeoExtent = getOptimalExtent(myHazardGeoExtent,
myExposureGeoExtent,
myViewportGeoExtent)
# Clip the vector to the bbox
myResult = clip_layer(myVectorLayer, myGeoExtent)
# Check the output is valid
assert os.path.exists(myResult.source())
readSafeLayer(myResult.source())
# Clip the raster to the bbox
myResult = clip_layer(myRasterLayer, myGeoExtent)
# Check the output is valid
assert os.path.exists(myResult.source())
readSafeLayer(myResult.source())
# -------------------------------
# Check the extra keywords option
# -------------------------------
# Clip the vector to the bbox
myResult = clip_layer(myVectorLayer, myGeoExtent,
extra_keywords={'kermit': 'piggy'})
# Check the output is valid
assert os.path.exists(myResult.source())
L = readSafeLayer(myResult.source())
kwds = L.get_keywords()
# myMessage = 'Extra keyword wasn\'t found in %s: %s' % (myResult,
# kwds)
assert kwds['kermit'] == 'piggy'
# Clip the raster to the bbox
myResult = clip_layer(myRasterLayer, myGeoExtent,
extra_keywords={'zoot': 'animal'})
# Check the output is valid
assert os.path.exists(myResult.source())
L = readSafeLayer(myResult.source())
kwds = L.get_keywords()
myMessage = 'Extra keyword was not found in %s: %s' % (
myResult.source(), kwds)
assert kwds['zoot'] == 'animal', myMessage
# Then one where boxes don't overlap
view_port = [105.3, -4.3, 110.29, -2.5]
try:
getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
except InsufficientOverlapError, e:
myMessage = 'Did not find expected error message in %s' % str(e)
assert 'did not overlap' in str(e), myMessage
else:
myMessage = ('Non ovelapping bounding boxes should have raised '
'an exception')
raise Exception(myMessage)
# Try with wrong input data
try:
getOptimalExtent(haz_metadata, exp_metadata, view_port)
except BoundingBoxError:
#good this was expected
pass
except InsufficientOverlapError, e:
myMessage = 'Did not find expected error message in %s' % str(e)
assert 'Invalid' in str(e), myMessage
else:
myMessage = 'Wrong input data should have raised an exception'
raise Exception(myMessage)
try:
getOptimalExtent(None, None, view_port)
except BoundingBoxError, e:
myMessage = 'Did not find expected error message in %s' % str(e)
assert 'cannot be None' in str(e), myMessage
def test_clipBoth(self):
"""Raster and Vector layers can be clipped
"""
# Create a vector layer
myName = 'padang'
myVectorLayer = QgsVectorLayer(VECTOR_PATH, myName, 'ogr')
myMessage = 'Did not find layer "%s" in path "%s"' % \
(myName, VECTOR_PATH)
assert myVectorLayer.isValid(), myMessage
# Create a raster layer
myName = 'shake'
myRasterLayer = QgsRasterLayer(RASTERPATH, myName)
myMessage = 'Did not find layer "%s" in path "%s"' % \
(myName, RASTERPATH)
assert myRasterLayer.isValid(), myMessage
# Create a bounding box
myViewportGeoExtent = [99.53, -1.22, 101.20, -0.36]
# Get the Hazard extents as an array in EPSG:4326
myHazardGeoExtent = [
myRasterLayer.extent().xMinimum(),
myRasterLayer.extent().yMinimum(),
myRasterLayer.extent().xMaximum(),
myRasterLayer.extent().yMaximum()
]
# Get the Exposure extents as an array in EPSG:4326
myExposureGeoExtent = [
myVectorLayer.extent().xMinimum(),
myVectorLayer.extent().yMinimum(),
myVectorLayer.extent().xMaximum(),
myVectorLayer.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]
myGeoExtent = getOptimalExtent(myHazardGeoExtent, myExposureGeoExtent,
myViewportGeoExtent)
# Clip the vector to the bbox
myResult = clipLayer(myVectorLayer, myGeoExtent)
# Check the output is valid
assert os.path.exists(myResult)
readSafeLayer(myResult)
# Clip the raster to the bbox
myResult = clipLayer(myRasterLayer, myGeoExtent)
# Check the output is valid
assert os.path.exists(myResult)
readSafeLayer(myResult)
# -------------------------------
# Check the extra keywords option
# -------------------------------
# Clip the vector to the bbox
myResult = clipLayer(myVectorLayer,
myGeoExtent,
theExtraKeywords={'kermit': 'piggy'})
# Check the output is valid
assert os.path.exists(myResult)
L = readSafeLayer(myResult)
kwds = L.get_keywords()
myMessage = 'Extra keyword was not found in %s: %s' % (myResult, kwds)
assert kwds['kermit'] == 'piggy'
# Clip the raster to the bbox
myResult = clipLayer(myRasterLayer,
myGeoExtent,
theExtraKeywords={'zoot': 'animal'})
# Check the output is valid
assert os.path.exists(myResult)
L = readSafeLayer(myResult)
kwds = L.get_keywords()
myMessage = 'Extra keyword was not found in %s: %s' % (myResult, kwds)
assert kwds['zoot'] == 'animal', myMessage
assert numpy.allclose(bbox, ref_box, rtol=1.0e-12, atol=1.0e-12)
# Then one where boxes don't overlap
view_port = [105.3, -4.3, 110.29, -2.5]
try:
getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
except InsufficientOverlapError, e:
message = "Did not find expected error message in %s" % str(e)
assert "did not overlap" in str(e), message
else:
message = "Non ovelapping bounding boxes should have raised " "an exception"
raise Exception(message)
# Try with wrong input data
try:
getOptimalExtent(haz_metadata, exp_metadata, view_port)
except BoundingBoxError:
# good this was expected
pass
except InsufficientOverlapError, e:
message = "Did not find expected error message in %s" % str(e)
assert "Invalid" in str(e), message
else:
message = "Wrong input data should have raised an exception"
raise Exception(message)
try:
getOptimalExtent(None, None, view_port)
except BoundingBoxError, e:
message = "Did not find expected error message in %s" % str(e)
assert "cannot be None" in str(e), message
def test_getOptimalExtent(self):
"""Optimal extent is calculated correctly
"""
exposure_path = os.path.join(TESTDATA, 'Population_2010.asc')
hazard_path = os.path.join(HAZDATA, 'Lembang_Earthquake_Scenario.asc')
# Expected data
haz_metadata = {
'bounding_box': (105.3000035, -8.3749994999999995, 110.2914705,
-5.5667784999999999),
'resolution': (0.0083330000000000001, 0.0083330000000000001)
}
exp_metadata = {
'bounding_box': (94.972335000000001, -11.009721000000001,
141.0140016666665, 6.0736123333332639),
'resolution': (0.0083333333333333003, 0.0083333333333333003)
}
# Verify relevant metada is ok
H = readSafeLayer(hazard_path)
E = readSafeLayer(exposure_path)
hazard_bbox = H.get_bounding_box()
assert numpy.allclose(hazard_bbox,
haz_metadata['bounding_box'],
rtol=1.0e-12,
atol=1.0e-12)
exposure_bbox = E.get_bounding_box()
assert numpy.allclose(exposure_bbox,
exp_metadata['bounding_box'],
rtol=1.0e-12,
atol=1.0e-12)
hazard_res = H.get_resolution()
assert numpy.allclose(hazard_res,
haz_metadata['resolution'],
rtol=1.0e-12,
atol=1.0e-12)
exposure_res = E.get_resolution()
assert numpy.allclose(exposure_res,
exp_metadata['resolution'],
rtol=1.0e-12,
atol=1.0e-12)
# First, do some examples that produce valid results
ref_box = [105.3000035, -8.3749995, 110.2914705, -5.5667785]
view_port = [94.972335, -11.009721, 141.014002, 6.073612]
bbox = getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
assert numpy.allclose(bbox, ref_box, rtol=1.0e-12, atol=1.0e-12)
#testing with viewport clipping disabled
bbox = getOptimalExtent(hazard_bbox, exposure_bbox, None)
assert numpy.allclose(bbox, ref_box, rtol=1.0e-12, atol=1.0e-12)
view_port = [
105.3000035, -8.3749994999999995, 110.2914705, -5.5667784999999999
]
bbox = getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
assert numpy.allclose(bbox, ref_box, rtol=1.0e-12, atol=1.0e-12)
# Very small viewport fully inside other layers
view_port = [106.0, -6.0, 108.0, -5.8]
bbox = getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
assert numpy.allclose(bbox, view_port, rtol=1.0e-12, atol=1.0e-12)
# viewport that intersects hazard layer
view_port = [107.0, -6.0, 112.0, -3.0]
ref_box = [107, -6, 110.2914705, -5.5667785]
bbox = getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
assert numpy.allclose(bbox, ref_box, rtol=1.0e-12, atol=1.0e-12)
# Then one where boxes don't overlap
view_port = [105.3, -4.3, 110.29, -2.5]
try:
getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
except InsufficientOverlapError, e:
myMessage = 'Did not find expected error message in %s' % str(e)
assert 'did not overlap' in str(e), myMessage
# Then one where boxes don't overlap
view_port = [105.3, -4.3, 110.29, -2.5]
try:
getOptimalExtent(hazard_bbox, exposure_bbox, view_port)
except InsufficientOverlapError, e:
myMessage = 'Did not find expected error message in %s' % str(e)
assert 'did not overlap' in str(e), myMessage
else:
myMessage = ('Non ovelapping bounding boxes should have raised '
'an exception')
raise Exception(myMessage)
# Try with wrong input data
try:
getOptimalExtent(haz_metadata, exp_metadata, view_port)
except BoundingBoxError:
#good this was expected
pass
except InsufficientOverlapError, e:
myMessage = 'Did not find expected error message in %s' % str(e)
assert 'Invalid' in str(e), myMessage
else:
myMessage = 'Wrong input data should have raised an exception'
raise Exception(myMessage)
try:
getOptimalExtent(None, None, view_port)
except BoundingBoxError, e:
myMessage = 'Did not find expected error message in %s' % str(e)
assert 'cannot be None' in str(e), myMessage
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 = getOptimalExtent(
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())
readSafeLayer(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())
readSafeLayer(result.source())
# -------------------------------
# Check the extra keywords option
# -------------------------------
# Clip the vector to the bbox
result = clip_layer(
vector_layer, geo_extent, extra_keywords={'kermit': 'piggy'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = readSafeLayer(result.source())
keywords = safe_layer.get_keywords()
# message = 'Extra keyword was not found in %s: %s' % (myResult,
# keywords)
assert keywords['kermit'] == 'piggy'
# Clip the raster to the bbox
result = clip_layer(
raster_layer, geo_extent, extra_keywords={'zoot': 'animal'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = readSafeLayer(result.source())
keywords = safe_layer.get_keywords()
message = ('Extra keyword was not found in %s: %s' %
(result.source(), keywords))
assert keywords['zoot'] == 'animal', message