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 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_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_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 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_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_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_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_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_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))
def test_ne_crs_geom_pass(self):
"""Test _ne_crs_geom"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
xy_vec = centr._ne_crs_geom()
lon, lat = xy_vec.geometry[:].x.values, xy_vec.geometry[:].y.values
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_get_closest_point(self):
"""Test get_closest_point"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr.geometry.crs = {'init': 'epsg:4326'}
x, y, idx = centr.get_closest_point(-58.13, 14.38)
self.assertAlmostEqual(x, -58.125)
self.assertAlmostEqual(y, 14.375)
self.assertEqual(idx, 295)
self.assertEqual(centr.lon[idx], x)
self.assertEqual(centr.lat[idx], y)
def test_remove_duplicate_pass(self):
"""Test remove_duplicate_points"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = data_vector()
centr.geometry.crs = 'epsg:4326'
# create duplicates manually:
centr.geometry.values[100] = centr.geometry.values[101]
centr.geometry.values[120] = centr.geometry.values[101]
centr.geometry.values[5] = Point([-59.7, 12.5])
centr.geometry.values[133] = Point([-59.7, 12.5])
centr.geometry.values[121] = Point([-59.7, 12.5])
centr.lon = centr.geometry.apply(lambda pt: pt.x).values
centr.lat = centr.geometry.apply(lambda pt: pt.y).values
self.assertEqual(centr.size, 296)
rem_centr = centr.remove_duplicate_points()
self.assertEqual(centr.size, 296)
self.assertEqual(rem_centr.size, 292)
rem2_centr = rem_centr.remove_duplicate_points()
self.assertEqual(rem_centr.size, 292)
self.assertEqual(rem2_centr.size, 292)
def test_set_lat_lon_to_meta_pass(self):
"""Test set_lat_lon_to_meta"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr.geometry.crs = {'init': 'epsg:4326'}
centr.set_lat_lon_to_meta()
self.assertEqual(centr.meta['crs'], {'init': 'epsg:4326'})
self.assertEqual(centr.meta['width'], 36)
self.assertEqual(centr.meta['height'], 31)
self.assertEqual(centr.meta['transform'][1], 0.0)
self.assertEqual(centr.meta['transform'][3], 0.0)
self.assertAlmostEqual(centr.meta['transform'][0], 0.08333333)
self.assertAlmostEqual(centr.meta['transform'][2], -61.08333333)
self.assertAlmostEqual(centr.meta['transform'][4], 0.08333333)
self.assertAlmostEqual(centr.meta['transform'][5], 11.83333333)
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_set_meta_to_lat_lon_pass(self):
"""Test set_meta_to_lat_lon by using its inverse set_lat_lon_to_meta"""
lat, lon, geometry = TestVector.data_vector()
centr = Centroids()
centr.lat, centr.lon, centr.geometry = lat, lon, geometry
centr.set_lat_lon_to_meta()
meta = centr.meta
centr.set_meta_to_lat_lon()
self.assertEqual(centr.meta, meta)
self.assertAlmostEqual(lat.max(), centr.lat.max(), 6)
self.assertAlmostEqual(lat.min(), centr.lat.min(), 6)
self.assertAlmostEqual(lon.max(), centr.lon.max(), 6)
self.assertAlmostEqual(lon.min(), centr.lon.min(), 6)
self.assertAlmostEqual(np.diff(centr.lon).max(), meta['transform'][0])
self.assertAlmostEqual(np.diff(centr.lat).max(), meta['transform'][4])
self.assertEqual(geometry.crs, centr.geometry.crs)
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_elevation_3_pass(self):
""" test set_elevation """
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr.geometry.crs = DEF_CRS
centr.set_elevation(product='SRTM3', resampling=Resampling.nearest)
centr.set_on_land()
self.assertTrue(np.all(centr.elevation[centr.on_land] > 0))
self.assertTrue(
np.all(
centr.elevation[np.logical_not(centr.on_land)] == DEM_NODATA))
self.assertEqual(centr.elevation[0], 23)
self.assertEqual(centr.elevation[1], 92)
self.assertEqual(centr.elevation[2], 69)
self.assertEqual(centr.elevation[3], 77)
self.assertEqual(centr.elevation[4], 133)
self.assertEqual(centr.elevation[5], 41)
self.assertEqual(centr.elevation.min(), DEM_NODATA)
def test_remove_duplicate_pass(self):
"""Test remove_duplicate_points"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr.geometry.crs = {'init': 'epsg:4326'}
# create duplicates manually:
centr.geometry.values[100] = centr.geometry.values[101]
centr.geometry.values[120] = centr.geometry.values[101]
centr.geometry.values[5] = Point([-59.7, 12.5])
centr.geometry.values[133] = Point([-59.7, 12.5])
centr.geometry.values[121] = Point([-59.7, 12.5])
self.assertEqual(centr.size, 296)
rem_centr = centr.remove_duplicate_points()
self.assertEqual(centr.size, 296)
self.assertEqual(rem_centr.size, 292) # 5 centroids removed
rem2_centr = rem_centr.remove_duplicate_points()
self.assertEqual(rem_centr.size, 292)
self.assertEqual(rem2_centr.size, 292)
def test_size_pass(self):
"""Test size property"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = self.data_vector()
centr.geometry.crs = {'init': 'epsg:4326'}
self.assertEqual(centr.size, 296)
def test_centroids_check_pass(self):
"""Test vector data in Centroids"""
data_vec = data_vector()
centr = Centroids()
centr.lat, centr.lon, centr.geometry = data_vec
centr.check()
self.assertTrue(u_coord.equal_crs(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()
cen = Centroids()
cen.meta = {
'width': 10,
'height': 20,
'transform': rasterio.Affine(0.1, 0, 0, 0, 0.1, 0),
'crs': DEF_CRS,
}
with self.assertRaises(ValueError):
cen.check()
