def test_set_layers(self):
"""
Test set up aggregator's layers work
"""
hazard = QgsVectorLayer(
os.path.join(UNITDATA, 'hazard',
'multipart_polygons_osm_4326.shp'), 'hazard', 'ogr')
exposure = QgsVectorLayer(
os.path.join(UNITDATA, '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_setup_target_field(self):
"""Test setup up target field is correct
"""
layer = QgsVectorLayer(
os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'),
'test aggregation', 'ogr')
aggregator = Aggregator(self.extent, None)
self.assertFalse(aggregator._setup_target_field(layer))
impact_layer_name = os.path.join(TESTDATA,
'aggregation_test_impact_vector.shp')
impact_layer = QgsVectorLayer(impact_layer_name, 'test', 'ogr')
self.assertTrue(aggregator._setup_target_field(impact_layer))
def test_setup_target_field(self):
"""Test setup up target field is correct
"""
layer = QgsVectorLayer(
os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'),
'test aggregation',
'ogr')
aggregator = Aggregator(self.extent, None)
self.assertFalse(aggregator._setup_target_field(layer))
impact_layer_name = os.path.join(TESTDATA,
'aggregation_test_impact_vector.shp')
impact_layer = QgsVectorLayer(impact_layer_name,
'test', 'ogr')
self.assertTrue(aggregator._setup_target_field(impact_layer))
def test_set_layers(self):
"""
Test set up aggregator's layers work
"""
hazard = QgsVectorLayer(
os.path.join(
UNITDATA,
'hazard',
'multipart_polygons_osm_4326.shp'),
'hazard',
'ogr'
)
exposure = QgsVectorLayer(
os.path.join(
UNITDATA,
'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 _create_aggregator(self, use_aoi_mode, use_native_zonal_stats):
"""Helper to create aggregator"""
aggregation_layer = QgsVectorLayer(
os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'),
'test aggregation', 'ogr')
# Dummy layers. Them are used in aggregator._prepare_layer
# The extent of the layers must be equal to aggregator.extent
hazard_layer = exposure_layer = aggregation_layer
# setting up
if not use_aoi_mode:
aggregator = Aggregator(self.extent, aggregation_layer)
else:
aggregator = Aggregator(self.extent, None)
aggregator.set_layers(hazard_layer, exposure_layer)
aggregator.validate_keywords()
aggregator.use_native_zonal_stats = use_native_zonal_stats
return aggregator
def _aggregate(self, myImpactLayer, myExpectedResults):
myAggregationLayer = QgsVectorLayer(
os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'),
'test aggregation',
'ogr')
# create a copy of aggregation layer
myGeoExtent = extent_to_geo_array(
myAggregationLayer.extent(),
myAggregationLayer.crs())
myAggrAttribute = self.keywordIO.read_keywords(
myAggregationLayer, self.defaults['AGGR_ATTR_KEY'])
# noinspection PyArgumentEqualDefault
myAggregationLayer = clip_layer(
layer=myAggregationLayer,
extent=myGeoExtent,
explode_flag=True,
explode_attribute=myAggrAttribute)
myAggregator = Aggregator(None, myAggregationLayer)
# setting up
myAggregator.isValid = True
myAggregator.layer = myAggregationLayer
myAggregator.safeLayer = safe_read_layer(
str(myAggregator.layer.source()))
myAggregator.aoiMode = False
myAggregator.aggregate(myImpactLayer)
myProvider = myAggregator.layer.dataProvider()
myProvider.select(myProvider.attributeIndexes())
myFeature = QgsFeature()
myResults = []
while myProvider.nextFeature(myFeature):
myFeatureResults = {}
myAtMap = myFeature.attributeMap()
for (k, attr) in myAtMap.iteritems():
myFeatureResults[k] = str(attr.toString())
myResults.append(myFeatureResults)
self.assertEqual(myExpectedResults, myResults)
def _create_aggregator(self,
use_aoi_mode,
use_native_zonal_stats):
"""Helper to create aggregator"""
aggregation_layer = QgsVectorLayer(
os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'),
'test aggregation',
'ogr')
# Dummy layers. Them are used in aggregator._prepare_layer
# The extent of the layers must be equal to aggregator.extent
hazard_layer = exposure_layer = aggregation_layer
# setting up
if not use_aoi_mode:
aggregator = Aggregator(self.extent, aggregation_layer)
else:
aggregator = Aggregator(self.extent, None)
aggregator.set_layers(hazard_layer, exposure_layer)
aggregator.validate_keywords()
aggregator.use_native_zonal_stats = use_native_zonal_stats
return aggregator
def _aggregate(self,
myImpactLayer,
myExpectedResults,
useNativeZonalStats=False):
"""Helper to calculate aggregation.
Expected results is split into two lists - one list contains numeric
attributes, the other strings. This is done so that we can use numpy
.testing.assert_allclose which doesn't work on strings
"""
myExpectedStringResults = []
myExpectedNumericResults = []
for item in myExpectedResults:
myItemNumResults = []
myItemStrResults = []
for field in item:
try:
value = float(field)
myItemNumResults.append(value)
except ValueError:
myItemStrResults.append(str(field))
myExpectedNumericResults.append(myItemNumResults)
myExpectedStringResults.append(myItemStrResults)
myAggregationLayer = QgsVectorLayer(
os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'),
'test aggregation',
'ogr')
# create a copy of aggregation layer
myGeoExtent = extent_to_geo_array(
myAggregationLayer.extent(),
myAggregationLayer.crs())
myAggrAttribute = self.keywordIO.read_keywords(
myAggregationLayer, self.defaults['AGGR_ATTR_KEY'])
# noinspection PyArgumentEqualDefault
myAggregationLayer = clip_layer(
layer=myAggregationLayer,
extent=myGeoExtent,
explode_flag=True,
explode_attribute=myAggrAttribute)
myAggregator = Aggregator(None, myAggregationLayer)
# setting up
myAggregator.isValid = True
myAggregator.layer = myAggregationLayer
myAggregator.safeLayer = safe_read_layer(
str(myAggregator.layer.source()))
myAggregator.aoiMode = False
myAggregator.useNativeZonalStats = useNativeZonalStats
myAggregator.aggregate(myImpactLayer)
myProvider = myAggregator.layer.dataProvider()
myNumericResults = []
myStringResults = []
for myFeature in myProvider.getFeatures():
myFeatureNumResults = []
myFeatureStrResults = []
myAttrs = myFeature.attributes()
for attr in myAttrs:
if isinstance(attr, (int, float)):
myFeatureNumResults.append(attr)
else:
myFeatureStrResults.append(attr)
myNumericResults.append(myFeatureNumResults)
myStringResults.append(myFeatureStrResults)
# check string attributes
self.assertEqual(myExpectedStringResults, myStringResults)
# check numeric attributes with a 0.01% tolerance compared to the
# native QGIS stats
numpy.testing.assert_allclose(myExpectedNumericResults,
myNumericResults,
rtol=0.01)
def _aggregate(self,
impact_layer,
expected_results,
use_native_zonal_stats=False):
"""Helper to calculate aggregation.
Expected results is split into two lists - one list contains numeric
attributes, the other strings. This is done so that we can use numpy
.testing.assert_allclose which doesn't work on strings
"""
expected_string_results = []
expected_numeric_results = []
for item in expected_results:
string_results = []
numeric_results = []
for field in item:
try:
value = float(field)
numeric_results.append(value)
except ValueError:
string_results.append(str(field))
expected_numeric_results.append(numeric_results)
expected_string_results.append(string_results)
aggregation_layer = QgsVectorLayer(
os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'),
'test aggregation', 'ogr')
# create a copy of aggregation layer
geo_extent = extent_to_geo_array(aggregation_layer.extent(),
aggregation_layer.crs())
aggregation_attribute = self.keywordIO.read_keywords(
aggregation_layer, self.defaults['AGGR_ATTR_KEY'])
# noinspection PyArgumentEqualDefault
aggregation_layer = clip_layer(layer=aggregation_layer,
extent=geo_extent,
explode_flag=True,
explode_attribute=aggregation_attribute)
aggregator = Aggregator(None, aggregation_layer)
# setting up
aggregator.is_valid = True
aggregator.layer = aggregation_layer
aggregator.safe_layer = safe_read_layer(str(aggregator.layer.source()))
aggregator.aoi_mode = False
aggregator.use_native_zonal_stats = use_native_zonal_stats
aggregator.aggregate(impact_layer)
provider = aggregator.layer.dataProvider()
string_results = []
numeric_results = []
for feature in provider.getFeatures():
feature_string_results = []
feature_numeric_results = []
attributes = feature.attributes()
for attr in attributes:
if isinstance(attr, (int, float)):
feature_numeric_results.append(attr)
else:
feature_string_results.append(attr)
numeric_results.append(feature_numeric_results)
string_results.append(feature_string_results)
# check string attributes
self.assertEqual(expected_string_results, string_results)
# check numeric attributes with a 0.01% tolerance compared to the
# native QGIS stats
numpy.testing.assert_allclose(expected_numeric_results,
numeric_results,
rtol=0.01)
def _aggregate(
self,
impact_layer,
expected_results,
use_native_zonal_stats=False):
"""Helper to calculate aggregation.
Expected results is split into two lists - one list contains numeric
attributes, the other strings. This is done so that we can use numpy
.testing.assert_allclose which doesn't work on strings
"""
expected_string_results = []
expected_numeric_results = []
for item in expected_results:
string_results = []
numeric_results = []
for field in item:
try:
value = float(field)
numeric_results.append(value)
except ValueError:
string_results.append(str(field))
expected_numeric_results.append(numeric_results)
expected_string_results.append(string_results)
aggregation_layer = QgsVectorLayer(
os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'),
'test aggregation',
'ogr')
# create a copy of aggregation layer
geo_extent = extent_to_geo_array(
aggregation_layer.extent(),
aggregation_layer.crs())
aggregation_attribute = self._keywordIO.read_keywords(
aggregation_layer, self._defaults['AGGR_ATTR_KEY'])
# noinspection PyArgumentEqualDefault
aggregation_layer = clip_layer(
layer=aggregation_layer,
extent=geo_extent,
explode_flag=True,
explode_attribute=aggregation_attribute)
aggregator = Aggregator(None, aggregation_layer)
# setting up
aggregator.is_valid = True
aggregator.layer = aggregation_layer
aggregator.safe_layer = safe_read_layer(
str(aggregator.layer.source()))
aggregator.aoi_mode = False
aggregator.use_native_zonal_stats = use_native_zonal_stats
aggregator.aggregate(impact_layer)
provider = aggregator.layer.dataProvider()
string_results = []
numeric_results = []
for feature in provider.getFeatures():
feature_string_results = []
feature_numeric_results = []
attributes = feature.attributes()
for attr in attributes:
if isinstance(attr, (int, float)):
feature_numeric_results.append(attr)
else:
feature_string_results.append(attr)
numeric_results.append(feature_numeric_results)
string_results.append(feature_string_results)
# check string attributes
self.assertEqual(expected_string_results, string_results)
# check numeric attributes with a 0.01% tolerance compared to the
# native QGIS stats
numpy.testing.assert_allclose(expected_numeric_results,
numeric_results,
rtol=0.01)
def _aggregate(
self,
impact_layer,
expected_results,
use_native_zonal_stats=False,
use_aoi_mode=False):
"""Helper to calculate aggregation.
Expected results is split into two lists - one list contains numeric
attributes, the other strings. This is done so that we can use numpy
.testing.assert_allclose which doesn't work on strings
"""
expected_string_results = []
expected_numeric_results = []
for item in expected_results:
string_results = []
numeric_results = []
for field in item:
try:
value = float(field)
numeric_results.append(value)
except ValueError:
string_results.append(str(field))
expected_numeric_results.append(numeric_results)
expected_string_results.append(string_results)
aggregation_layer = QgsVectorLayer(
os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'),
'test aggregation',
'ogr')
# Dummy layers. Them are used in aggregator._prepare_layer
# The extent of the layers must be equal to aggregator.extent
hazard_layer = exposure_layer = aggregation_layer
# setting up
if not use_aoi_mode:
aggregator = Aggregator(self.extent, aggregation_layer)
else:
aggregator = Aggregator(self.extent, None)
aggregator.set_layers(hazard_layer, exposure_layer)
aggregator.validate_keywords()
aggregator.use_native_zonal_stats = use_native_zonal_stats
aggregator.aggregate(impact_layer)
provider = aggregator.layer.dataProvider()
string_results = []
numeric_results = []
for feature in provider.getFeatures():
feature_string_results = []
feature_numeric_results = []
attributes = feature.attributes()
for attr in attributes:
try:
value = float(attr)
feature_numeric_results.append(value)
except ValueError:
feature_string_results.append(str(attr))
numeric_results.append(feature_numeric_results)
string_results.append(feature_string_results)
# check string attributes
self.assertEqual(expected_string_results, string_results)
# check numeric attributes with a 0.01% tolerance compared to the
# native QGIS stats
numpy.testing.assert_allclose(expected_numeric_results,
numeric_results,
rtol=0.01)
