def test_write_read_raster_h5(self):
"""Write and read hdf5 format"""
file_name = str(DATA_DIR.joinpath('test_centr.h5'))
centr = Centroids()
xf_lat, xo_lon, d_lat, d_lon, n_lat, n_lon = 10, 5, -0.5, 0.2, 20, 25
centr.set_raster_from_pix_bounds(xf_lat, xo_lon, d_lat, d_lon, n_lat,
n_lon)
centr.write_hdf5(file_name)
centr_read = Centroids()
centr_read.read_hdf5(file_name)
self.assertTrue(centr_read.meta)
self.assertFalse(centr_read.lat.size)
self.assertFalse(centr_read.lon.size)
self.assertEqual(centr_read.meta['width'], centr.meta['width'])
self.assertEqual(centr_read.meta['height'], centr.meta['height'])
self.assertAlmostEqual(centr_read.meta['transform'].a,
centr.meta['transform'].a)
self.assertAlmostEqual(centr_read.meta['transform'].b,
centr.meta['transform'].b)
self.assertAlmostEqual(centr_read.meta['transform'].c,
centr.meta['transform'].c)
self.assertAlmostEqual(centr_read.meta['transform'].d,
centr.meta['transform'].d)
self.assertAlmostEqual(centr_read.meta['transform'].e,
centr.meta['transform'].e)
self.assertAlmostEqual(centr_read.meta['transform'].f,
centr.meta['transform'].f)
self.assertTrue(
u_coord.equal_crs(centr_read.meta['crs'], centr.meta['crs']))
def test_union(self):
cent1 = Centroids()
cent1.lat, cent1.lon = np.array([0, 1]), np.array([0, -1])
cent1.on_land = np.array([True, True])
cent2 = Centroids()
cent2.lat, cent2.lon = np.array([2, 3]), np.array([-2, 3])
cent2.on_land = np.array([False, False])
cent3 = Centroids()
cent3.lat, cent3.lon = np.array([-1, -2]), np.array([1, 2])
cent = cent1.union(cent2)
np.testing.assert_array_equal(cent.lat, [0, 1, 2, 3])
np.testing.assert_array_equal(cent.lon, [0, -1, -2, 3])
np.testing.assert_array_equal(cent.on_land, [True, True, False, False])
cent = cent1.union(cent1, cent2)
np.testing.assert_array_equal(cent.lat, [0, 1, 2, 3])
np.testing.assert_array_equal(cent.lon, [0, -1, -2, 3])
np.testing.assert_array_equal(cent.on_land, [True, True, False, False])
cent = Centroids().union(cent1)
np.testing.assert_array_equal(cent.lat, [0, 1])
np.testing.assert_array_equal(cent.lon, [0, -1])
np.testing.assert_array_equal(cent.on_land, [True, True])
cent = cent1.union(cent1)
np.testing.assert_array_equal(cent.lat, [0, 1])
np.testing.assert_array_equal(cent.lon, [0, -1])
np.testing.assert_array_equal(cent.on_land, [True, True])
cent = Centroids().union(cent1, cent2, cent3)
np.testing.assert_array_equal(cent.lat, [0, 1, 2, 3, -1, -2])
np.testing.assert_array_equal(cent.lon, [0, -1, -2, 3, 1, 2])
def _centroids_from_nc(file_name):
""" Construct Centroids from the grid described by 'latitude' and
'longitude' variables in a netCDF file.
"""
LOGGER.info('Constructing centroids from %s', file_name)
cent = Centroids()
ncdf = xr.open_dataset(file_name)
if hasattr(ncdf, 'latitude'):
lats = ncdf.latitude.data
lons = ncdf.longitude.data
elif hasattr(ncdf, 'lat'):
lats = ncdf.lat.data
lons = ncdf.lon.data
elif hasattr(ncdf, 'lat_1'):
lats = ncdf.lat_1.data
lons = ncdf.lon_1.data
else:
raise AttributeError('netcdf file has no field named latitude or '
'other know abrivation for coordinates.')
ncdf.close()
lats, lons = np.array(
[np.repeat(lats, len(lons)),
np.tile(lons, len(lats))])
cent = Centroids()
cent.set_lat_lon(lats, lons)
cent.set_area_pixel()
cent.set_on_land()
return cent
def test_append_all_pass(self):
"""Test _append_all function."""
haz_1 = Hazard('TC')
haz_1.tag.file_name = 'file1.mat'
haz_1.tag.description = 'Description 1'
haz_1.centroids = Centroids()
haz_1.centroids.set_lat_lon(np.array([1, 3, 5]), np.array([2, 4, 6]))
haz_1.event_id = np.array([1])
haz_1.event_name = ['ev1']
haz_1.date = np.array([1])
haz_1.orig = np.array([True])
haz_1.frequency = np.array([1.0])
haz_1.fraction = sparse.csr_matrix([[0.02, 0.03, 0.04]])
haz_1.intensity = sparse.csr_matrix([[0.2, 0.3, 0.4]])
haz_1.units = 'm/s'
haz_2 = Hazard('TC')
haz_2.tag.file_name = 'file2.mat'
haz_2.tag.description = 'Description 2'
haz_2.centroids = Centroids()
haz_2.centroids.set_lat_lon(np.array([1, 3, 5]), np.array([2, 4, 6]))
haz_2.event_id = np.array([1])
haz_2.event_name = ['ev2']
haz_2.date = np.array([2])
haz_2.orig = np.array([False])
haz_2.frequency = np.array([1.0])
haz_2.fraction = sparse.csr_matrix([[1.02, 1.03, 1.04]])
haz_2.intensity = sparse.csr_matrix([[1.2, 1.3, 1.4]])
haz_2.units = 'm/s'
haz = Hazard('TC')
haz._append_all([haz_1, haz_2])
hres_frac = sparse.csr_matrix([[0.02, 0.03, 0.04], \
[1.02, 1.03, 1.04]])
hres_inten = sparse.csr_matrix([[0.2, 0.3, 0.4], \
[1.2, 1.3, 1.4]])
self.assertTrue(sparse.isspmatrix_csr(haz.intensity))
self.assertTrue(
np.array_equal(haz.intensity.todense(), hres_inten.todense()))
self.assertTrue(sparse.isspmatrix_csr(haz.fraction))
self.assertTrue(
np.array_equal(haz.fraction.todense(), hres_frac.todense()))
self.assertEqual(haz.units, haz_2.units)
self.assertTrue(np.array_equal(haz.frequency, np.array([1.0, 1.0])))
self.assertTrue(np.array_equal(haz.orig, np.array([True, False])))
self.assertTrue(np.array_equal(haz.date, np.array([1, 2])))
self.assertTrue(np.array_equal(haz.event_id, np.array([1, 2])))
self.assertTrue(haz.event_name, ['ev1', 'ev2'])
self.assertTrue(
np.array_equal(haz.centroids.coord, haz_1.centroids.coord))
self.assertTrue(
np.array_equal(haz.centroids.coord, haz_2.centroids.coord))
self.assertTrue(haz.tag, 'file_1.mat + file_2.mat')
self.assertTrue(haz.tag, 'Description 1 + Description 2')
def test_equal_pass(self):
"""Test equal"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr_bis = Centroids()
centr_bis.set_lat_lon(np.array([1, 2, 3]), np.array([4, 5, 6]))
self.assertFalse(centr.equal(centr_bis))
self.assertFalse(centr_bis.equal(centr))
self.assertTrue(centr_bis.equal(centr_bis))
self.assertTrue(centr.equal(centr))
def test_equal_pass(self):
"""Test equal"""
centr_ras = Centroids()
centr_ras.set_raster_file(HAZ_DEMO_FL, window=Window(0, 0, 50, 60))
centr_bis = Centroids()
centr_bis.set_raster_file(HAZ_DEMO_FL, window=Window(51, 61, 10, 10))
self.assertFalse(centr_ras.equal(centr_bis))
self.assertFalse(centr_bis.equal(centr_ras))
self.assertTrue(centr_ras.equal(centr_ras))
self.assertTrue(centr_bis.equal(centr_bis))
def __init__(self, haz_type):
"""Initialize values.
Parameters:
haz_type (str, optional): acronym of the hazard type (e.g. 'TC').
Examples:
Fill hazard values by hand:
>>> haz = Hazard('TC')
>>> haz.intensity = sparse.csr_matrix(np.zeros((2, 2)))
>>> ...
Take hazard values from file:
>>> haz = Hazard('TC', HAZ_DEMO_MAT)
>>> haz.read_mat(HAZ_DEMO_MAT, 'demo')
"""
self.tag = TagHazard()
self.tag.haz_type = haz_type
self.units = ''
self.centroids = Centroids()
# following values are defined for each event
self.event_id = np.array([], int)
self.frequency = np.array([], float)
self.event_name = list()
self.date = np.array([], int)
self.orig = np.array([], bool)
# following values are defined for each event and centroid
self.intensity = sparse.csr_matrix(np.empty(
(0, 0))) # events x centroids
self.fraction = sparse.csr_matrix(np.empty(
(0, 0))) # events x centroids
def test_mat_global_pass(self):
"""Test read GLB_CENTROIDS_MAT"""
centroids = Centroids()
centroids.read_mat(GLB_CENTROIDS_MAT)
self.assertEqual(centroids.region_id[1062443], 35)
self.assertEqual(centroids.region_id[170825], 28)
def test_centroids_att_two_pass(self):
""" Test set all attributes centroids """
centr_bang = Centroids()
centr_bang.set_raster_from_pnt_bounds((89, 21.5, 90, 23), 0.01)
_set_centroids_att(centr_bang,
dist_coast_decay=True,
dem_product='SRTM3',
as_pixel=True)
self.assertEqual(centr_bang.dist_coast.size, centr_bang.size)
self.assertEqual(centr_bang.elevation.size, centr_bang.size)
self.assertAlmostEqual(centr_bang.elevation.max(), 22.743055555555557)
centr_bang.elevation = np.array([])
centr_bang.dist_coast = np.array([])
_set_centroids_att(centr_bang,
dist_coast_decay=True,
dem_product='SRTM3',
as_pixel=False)
self.assertEqual(centr_bang.dist_coast.size, centr_bang.size)
self.assertEqual(centr_bang.elevation.size, centr_bang.size)
self.assertAlmostEqual(centr_bang.elevation.max(), 28.0)
centr_bang.set_meta_to_lat_lon()
centr_bang.meta = dict()
centr_bang.elevation = np.array([])
centr_bang.dist_coast = np.array([])
_set_centroids_att(centr_bang,
dist_coast_decay=True,
dem_product='SRTM3')
self.assertEqual(centr_bang.dist_coast.size, centr_bang.size)
self.assertEqual(centr_bang.elevation.size, centr_bang.size)
self.assertAlmostEqual(centr_bang.elevation.max(), 28.0)
def test_write_read_points_h5(self):
file_name = str(DATA_DIR.joinpath('test_centr.h5'))
centr = Centroids()
centr = Centroids()
centr.set_lat_lon(VEC_LAT, VEC_LON)
centr.write_hdf5(file_name)
centr_read = Centroids()
centr_read.read_hdf5(file_name)
self.assertFalse(centr_read.meta)
self.assertTrue(centr_read.lat.size)
self.assertTrue(centr_read.lon.size)
self.assertTrue(np.allclose(centr_read.lat, centr.lat))
self.assertTrue(np.allclose(centr_read.lon, centr.lon))
self.assertTrue(u_coord.equal_crs(centr_read.crs, centr.crs))
def test_area_approx(self):
"""Test set_area_approx"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr.geometry.crs = {'init': 'epsg:4326'}
with self.assertRaises(ValueError):
centr.set_area_approx()
def test_centroids_att_one_pass(self):
""" Test set one attribute centroids """
centr_bang = Centroids()
centr_bang.set_raster_from_pnt_bounds((89, 21.5, 90, 23), 0.01)
_set_centroids_att(centr_bang, dist_coast_decay=False, dem_product='SRTM3')
self.assertEqual(centr_bang.dist_coast.size, 0)
self.assertEqual(centr_bang.elevation.size, centr_bang.size)
def test_set_vector_file_wrong_fail(self):
"""Test set_vector_file with wrong centroids"""
shp_file = shapereader.natural_earth(resolution='110m',
category='cultural',
name='populated_places_simple')
centr = Centroids()
inten = centr.set_vector_file(shp_file, ['pop_min', 'pop_max'])
self.assertEqual(CRS.from_user_input(centr.geometry.crs),
CRS.from_epsg(u_coord.NE_EPSG))
self.assertEqual(centr.geometry.size, centr.lat.size)
self.assertEqual(CRS.from_user_input(centr.geometry.crs),
CRS.from_epsg(u_coord.NE_EPSG))
self.assertAlmostEqual(centr.lon[0], 12.453386544971766)
self.assertAlmostEqual(centr.lon[-1], 114.18306345846304)
self.assertAlmostEqual(centr.lat[0], 41.903282179960115)
self.assertAlmostEqual(centr.lat[-1], 22.30692675357551)
self.assertEqual(inten.shape, (2, 243))
# population min
self.assertEqual(inten[0, 0], 832)
self.assertEqual(inten[0, -1], 4551579)
# population max
self.assertEqual(inten[1, 0], 832)
self.assertEqual(inten[1, -1], 7206000)
shp_file = shapereader.natural_earth(resolution='10m',
category='cultural',
name='populated_places_simple')
with self.assertRaises(ValueError):
centr.set_vector_file(shp_file, ['pop_min', 'pop_max'])
def test_append_diff_pass(self):
""" Append raster """
centr_ras = Centroids()
centr_ras.set_raster_file(HAZ_DEMO_FL, window= Window(0, 0, 50, 60))
centr_bis = Centroids()
centr_bis.set_raster_file(HAZ_DEMO_FL, window= Window(51, 61, 10, 10))
centr_bis.append(centr_ras)
self.assertAlmostEqual(centr_bis.meta['crs'], DEF_CRS)
self.assertAlmostEqual(centr_bis.meta['transform'].c, -69.33714959699981)
self.assertAlmostEqual(centr_bis.meta['transform'].a, 0.009000000000000341)
self.assertAlmostEqual(centr_bis.meta['transform'].b, 0.0)
self.assertAlmostEqual(centr_bis.meta['transform'].f, 10.42822096697894)
self.assertAlmostEqual(centr_bis.meta['transform'].d, 0.0)
self.assertAlmostEqual(centr_bis.meta['transform'].e, -0.009000000000000341)
self.assertEqual(centr_bis.meta['height'], 71)
self.assertEqual(centr_bis.meta['width'], 61)
def test_on_land(self):
""" Test set_on_land """
centr_ras = Centroids()
centr_ras.set_raster_file(HAZ_DEMO_FL, window= Window(0, 0, 50, 60))
centr_ras.set_on_land()
centr_ras.check()
self.assertTrue(np.array_equal(centr_ras.on_land, np.ones(60 * 50, bool)))
def test_region_id_pass(self):
""" Test set_dist_coast """
centr_ras = Centroids()
centr_ras.set_raster_file(HAZ_DEMO_FL, window= Window(0, 0, 50, 60))
centr_ras.set_region_id()
self.assertEqual(centr_ras.region_id.size, centr_ras.size)
self.assertTrue(np.array_equal(np.unique(centr_ras.region_id), np.array([862])))
def test_region_id_pass(self):
"""Test set_region_id"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr.geometry.crs = {'init': 'epsg:4326'}
centr.set_region_id()
self.assertEqual(np.count_nonzero(centr.region_id), 6)
self.assertEqual(centr.region_id[0], 52) # 052 for barbados
def test_dist_coast_pass(self):
"""Test set_dist_coast"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr.geometry.crs = {'init': 'epsg:4326'}
centr.set_dist_coast()
self.assertAlmostEqual(2594.2070842031694, centr.dist_coast[1])
self.assertAlmostEqual(166295.87602398323, centr.dist_coast[-2])
def _centroids_from_nc(file_name):
"""Construct Centroids from the grid described by 'latitude' and
'longitude' variables in a netCDF file.
"""
LOGGER.info('Constructing centroids from %s', file_name)
cent = Centroids()
ncdf = xr.open_dataset(file_name)
create_meshgrid = True
if hasattr(ncdf, 'latitude'):
lats = ncdf.latitude.data
lons = ncdf.longitude.data
elif hasattr(ncdf, 'lat'):
lats = ncdf.lat.data
lons = ncdf.lon.data
elif hasattr(ncdf, 'lat_1'):
if len(ncdf.lon_1.shape)>1 & \
(ncdf.lon_1.shape == ncdf.lat_1.shape) \
:
lats = ncdf.lat_1.data.flatten()
lons = ncdf.lon_1.data.flatten()
create_meshgrid = False
else:
lats = ncdf.lat_1.data
lons = ncdf.lon_1.data
elif hasattr(ncdf, 'clat'):
lats = ncdf.clat.data
lons = ncdf.clon.data
if ncdf.clat.attrs['units'] == 'radian':
lats = np.rad2deg(lats)
lons = np.rad2deg(lons)
create_meshgrid = False
else:
raise AttributeError('netcdf file has no field named latitude or '
'other know abrivation for coordinates.')
ncdf.close()
if create_meshgrid:
lats, lons = np.array(
[np.repeat(lats, len(lons)),
np.tile(lons, len(lats))])
cent = Centroids()
cent.set_lat_lon(lats, lons)
cent.set_area_pixel()
cent.set_on_land()
return cent
def test_dist_coast_pass(self):
""" Test set_dist_coast """
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr.geometry.crs = {'init':'epsg:4326'}
centr.set_dist_coast()
self.assertAlmostEqual(5.798819757520 * 1000, centr.dist_coast[1])
self.assertAlmostEqual(166.3650542203 * 1000, centr.dist_coast[-2])
def test_union_meta(self):
cent1 = Centroids()
cent1.set_raster_from_pnt_bounds((-1, -1, 0, 0), res=1)
cent2 = Centroids()
cent2.set_raster_from_pnt_bounds((0, 0, 1, 1), res=1)
cent3 = Centroids()
cent3.lat, cent3.lon = np.array([1]), np.array([1])
cent = cent1.union(cent2)
np.testing.assert_array_equal(cent.lat, [0, 0, -1, -1, 1, 1, 0])
np.testing.assert_array_equal(cent.lon, [-1, 0, -1, 0, 0, 1, 1])
cent = cent3.union(cent1)
np.testing.assert_array_equal(cent.lat, [1, 0, 0, -1, -1])
np.testing.assert_array_equal(cent.lon, [1, -1, 0, -1, 0])
def test_dist_coast_pass(self):
"""Test set_region_id"""
centr_ras = Centroids()
centr_ras.set_raster_file(HAZ_DEMO_FL, window=Window(0, 0, 50, 60))
centr_ras.set_dist_coast()
centr_ras.check()
self.assertTrue(abs(centr_ras.dist_coast[0] - 117000) < 1000)
self.assertTrue(abs(centr_ras.dist_coast[-1] - 104000) < 1000)
def test_same_events_append(self):
"""Append hazard with same events (and diff centroids).
Events are appended with all new centroids columns. """
haz1 = dummy_hazard()
haz2 = Hazard('TC')
haz2.tag.file_name = 'file2.mat'
haz2.tag.description = 'Description 2'
haz2.centroids = Centroids()
haz2.centroids.set_lat_lon(np.array([7, 9, 11]), np.array([8, 10, 12]))
haz2.event_id = haz1.event_id
haz2.event_name = haz1.event_name.copy()
haz2.frequency = haz1.frequency
haz2.date = haz1.date
haz2.fraction = sparse.csr_matrix([[0.22, 0.32, 0.44], \
[0.11, 0.11, 0.11], \
[0.32, 0.11, 0.99], \
[0.32, 0.22, 0.88]])
haz2.intensity = sparse.csr_matrix([[0.22, 3.33, 6.44], \
[1.11, 0.11, 1.11], \
[8.33, 4.11, 4.4], \
[9.33, 9.22, 1.77]])
haz2.units = 'm/s'
haz1.append(haz2)
# expected values
haz1_ori = dummy_hazard()
res_inten = sparse.lil_matrix(np.zeros((8, 6)))
res_inten[0:4, 0:3] = haz1_ori.intensity
res_inten[4:, 3:] = haz2.intensity
res_frac = sparse.lil_matrix(np.zeros((8, 6)))
res_frac[0:4, 0:3] = haz1_ori.fraction
res_frac[4:, 3:] = haz2.fraction
self.assertTrue(np.array_equal(res_inten.todense(),
haz1.intensity.todense()))
self.assertTrue(sparse.isspmatrix_csr(haz1.intensity))
self.assertTrue(np.array_equal(res_frac.todense(), \
haz1.fraction.todense()))
self.assertTrue(sparse.isspmatrix_csr(haz1.fraction))
self.assertEqual(haz1.event_name,
haz1_ori.event_name + haz2.event_name)
self.assertTrue(np.array_equal(haz1.date,
np.append(haz1_ori.date, haz2.date)))
self.assertTrue(np.array_equal(haz1.orig,
np.append(haz1_ori.orig, haz2.orig)))
self.assertTrue(np.array_equal(haz1.event_id, np.arange(1,9)))
self.assertTrue(np.array_equal(haz1.frequency,
np.append(haz1_ori.frequency, haz2.frequency)))
self.assertEqual(haz1_ori.units, haz1.units)
self.assertEqual(haz1.tag.file_name, \
[haz1_ori.tag.file_name, haz2.tag.file_name])
self.assertEqual(haz1.tag.haz_type, haz1_ori.tag.haz_type)
self.assertEqual(haz1.tag.description, \
[haz1_ori.tag.description, haz2.tag.description])
def test_mat_global_pass(self):
""" Test read GLB_CENTROIDS_MAT """
centroids = Centroids()
centroids.read_mat(GLB_CENTROIDS_MAT)
self.assertEqual(centroids.region_id[1062443], 35)
self.assertEqual(centroids.region_id[170825], 28)
self.assertAlmostEqual(centroids.dist_coast[9], 21.366461094662913)
self.assertAlmostEqual(centroids.dist_coast[1568370], 36.76908653021)
def test_ne_crs_xy_pass(self):
""" Test _ne_crs_xy """
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
lon, lat = centr._ne_crs_xy()
self.assertAlmostEqual(4.51072194, lon[0])
self.assertAlmostEqual(0.00011838, lat[0])
self.assertAlmostEqual(4.5107354, lon[-1])
self.assertAlmostEqual(0.0001297, lat[-1])
def test_area_pass(self):
""" Test set_area """
centr_ras = Centroids()
centr_ras.set_raster_file(HAZ_DEMO_FL, window= Window(0, 0, 50, 60))
centr_ras.meta['crs'] = {'proj':'cea'}
centr_ras.set_area_pixel()
centr_ras.check()
self.assertTrue(np.allclose(centr_ras.area_pixel,
np.ones(60*50)*0.009000000000000341*0.009000000000000341))
def test_get_pixel_polygons_pass(self):
"""Test calc_pixels_polygons"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr.geometry.crs = {'init': 'epsg:4326'}
poly = centr.calc_pixels_polygons()
self.assertIsInstance(poly[0], Polygon)
self.assertTrue(np.allclose(poly.centroid[:].y.values, centr.lat))
self.assertTrue(np.allclose(poly.centroid[:].x.values, centr.lon))
def test_append_pass(self):
"""Append points"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr_bis = Centroids()
centr_bis.set_lat_lon(np.array([1, 2, 3]), np.array([4, 5, 6]))
with self.assertRaises(ValueError):
centr_bis.append(centr)
centr.geometry.crs = {'init': 'epsg:4326'}
centr_bis.append(centr)
self.assertAlmostEqual(centr_bis.lat[0], 1)
self.assertAlmostEqual(centr_bis.lat[1], 2)
self.assertAlmostEqual(centr_bis.lat[2], 3)
self.assertAlmostEqual(centr_bis.lon[0], 4)
self.assertAlmostEqual(centr_bis.lon[1], 5)
self.assertAlmostEqual(centr_bis.lon[2], 6)
self.assertTrue(np.array_equal(centr_bis.lat[3:], centr.lat))
self.assertTrue(np.array_equal(centr_bis.lon[3:], centr.lon))
def test_centroids_check_pass(self):
"""Test vector data in Centroids"""
data_vec = TestVector.data_vector()
centr = Centroids()
centr.lat, centr.lon, centr.geometry = data_vec
centr.check()
self.assertEqual(centr.crs, data_vec[2].crs)
self.assertIsInstance(centr.total_bounds, tuple)
for i in range(4):
self.assertEqual(centr.total_bounds[i],
data_vec[2].total_bounds[i])
self.assertIsInstance(centr.lat, np.ndarray)
self.assertIsInstance(centr.lon, np.ndarray)
self.assertIsInstance(centr.coord, np.ndarray)
self.assertTrue(np.array_equal(centr.lat, VEC_LAT))
self.assertTrue(np.array_equal(centr.lon, VEC_LON))
self.assertTrue(
np.array_equal(centr.coord,
np.array([VEC_LAT, VEC_LON]).transpose()))
self.assertEqual(centr.size, VEC_LON.size)
centr.area_pixel = np.array([1])
with self.assertRaises(ValueError):
centr.check()
centr.area_pixel = np.array([])
centr.dist_coast = np.array([1])
with self.assertRaises(ValueError):
centr.check()
centr.dist_coast = np.array([])
centr.on_land = np.array([1])
with self.assertRaises(ValueError):
centr.check()
centr.on_land = np.array([])
centr.region_id = np.array([1])
with self.assertRaises(ValueError):
centr.check()
centr.region_id = np.array([])
centr.lat = np.array([1])
with self.assertRaises(ValueError):
centr.check()
centr.lat = np.array([])
centr.lon = np.array([1])
with self.assertRaises(ValueError):
centr.check()
centr.lon = np.array([])
centr.geometry = gpd.GeoSeries(np.ones(1))
with self.assertRaises(ValueError):
centr.check()
def test_on_land(self):
"""Test set_on_land"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr.geometry.crs = {'init': 'epsg:4326'}
centr.set_on_land()
centr.set_region_id()
centr.region_id[centr.region_id > 0] = 1
self.assertTrue(
np.array_equal(centr.on_land.astype(int), centr.region_id))
