def test_equal_pass(self):
"""Test equal"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = data_vector()
centr_bis = Centroids.from_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_from_lat_lon_pass(self):
"""Test from_lat_lon"""
centr = Centroids.from_lat_lon(VEC_LAT, VEC_LON)
self.assertTrue(np.allclose(centr.lat, VEC_LAT))
self.assertTrue(np.allclose(centr.lon, VEC_LON))
self.assertTrue(u_coord.equal_crs(centr.crs, DEF_CRS))
self.assertTrue(u_coord.equal_crs(centr.geometry.crs, DEF_CRS))
self.assertEqual(centr.geometry.size, 0)
centr.set_area_pixel()
self.assertEqual(centr.geometry.size, centr.lat.size)
def test_union_meta(self):
cent1 = Centroids.from_pnt_bounds((-1, -1, 0, 0), res=1)
cent2 = Centroids.from_pnt_bounds((0, 0, 1, 1), res=1)
cent3 = Centroids.from_lat_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_write_read_points_h5(self):
file_name = str(DATA_DIR.joinpath('test_centr.h5'))
centr = Centroids.from_lat_lon(VEC_LAT, VEC_LON)
centr.write_hdf5(file_name)
centr_read = Centroids.from_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_select_pass(self):
"""Test Centroids.select method"""
centr = Centroids.from_lat_lon(VEC_LAT, VEC_LON)
centr.region_id = np.zeros(VEC_LAT.size)
centr.region_id[[100, 200]] = 10
fil_centr = centr.select(10)
self.assertEqual(fil_centr.size, 2)
self.assertEqual(fil_centr.lat[0], VEC_LAT[100])
self.assertEqual(fil_centr.lat[1], VEC_LAT[200])
self.assertEqual(fil_centr.lon[0], VEC_LON[100])
self.assertEqual(fil_centr.lon[1], VEC_LON[200])
self.assertTrue(np.array_equal(fil_centr.region_id, np.ones(2) * 10))
def test_area_pass(self):
"""Test set_area"""
ulx, xres, lrx = 60, 1, 90
uly, yres, lry = 0, 1, 20
xx, yy = np.meshgrid(np.arange(ulx + xres / 2, lrx, xres),
np.arange(uly + yres / 2, lry, yres))
vec_data = gpd.GeoDataFrame(crs={'proj': 'cea'})
vec_data['geometry'] = list(zip(xx.flatten(), yy.flatten()))
vec_data['geometry'] = vec_data['geometry'].apply(Point)
vec_data['lon'] = xx.flatten()
vec_data['lat'] = yy.flatten()
centr = Centroids.from_lat_lon(vec_data.lat.values,
vec_data.lon.values)
centr.geometry = vec_data.geometry
centr.set_area_pixel()
self.assertTrue(np.allclose(centr.area_pixel, np.ones(centr.size)))
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.from_lat_lon(lats, lons)
cent.set_area_pixel()
cent.set_on_land()
return cent
def test_append_pass(self):
"""Append points"""
centr = Centroids()
centr.lat, centr.lon, centr.geometry = data_vector()
centr_bis = Centroids.from_lat_lon(np.array([1, 2, 3]),
np.array([4, 5, 6]))
with self.assertRaises(ValueError):
centr_bis.append(centr)
centr.geometry.crs = '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_select_extent_pass(self):
"""Test select extent"""
centr = Centroids.from_lat_lon(np.array([-5, -3, 0, 3, 5]),
np.array([-180, -175, -170, 170, 175]))
centr.check()
centr.region_id = np.zeros(len(centr.lat))
ext_centr = centr.select(extent=[-175, -170, -5, 5])
np.testing.assert_array_equal(ext_centr.lon, np.array([-175, -170]))
np.testing.assert_array_equal(ext_centr.lat, np.array([-3, 0]))
# Cross antimeridian, version 1
ext_centr = centr.select(extent=[170, -175, -5, 5])
np.testing.assert_array_equal(ext_centr.lon,
np.array([-180, -175, 170, 175]))
np.testing.assert_array_equal(ext_centr.lat, np.array([-5, -3, 3, 5]))
# Cross antimeridian, version 2
ext_centr = centr.select(extent=[170, 185, -5, 5])
np.testing.assert_array_equal(ext_centr.lon,
np.array([-180, -175, 170, 175]))
np.testing.assert_array_equal(ext_centr.lat, np.array([-5, -3, 3, 5]))
def test_get_closest_point(self):
"""Test get_closest_point"""
for y_sign in [1, -1]:
centr_ras = Centroids()
centr_ras.meta = {
'width':
10,
'height':
20,
'transform':
rasterio.Affine(0.5, 0, 0.1, 0, y_sign * 0.6, y_sign * (-0.3)),
'crs':
DEF_CRS,
}
test_data = np.array([
[0.4, 0.1, 0.35, 0.0, 0],
[-0.1, 0.2, 0.35, 0.0, 0],
[2.2, 0.1, 2.35, 0.0, 4],
[1.4, 2.5, 1.35, 2.4, 42],
[5.5, -0.1, 4.85, 0.0, 9],
])
test_data[:, [1, 3]] *= y_sign
for x_in, y_in, x_out, y_out, idx_out in test_data:
x, y, idx = centr_ras.get_closest_point(x_in, y_in)
self.assertEqual(x, x_out)
self.assertEqual(y, y_out)
self.assertEqual(idx, idx_out)
self.assertEqual(centr_ras.lon[idx], x)
self.assertEqual(centr_ras.lat[idx], y)
centr_ras = Centroids.from_lat_lon(np.array([0, 0.2, 0.7]),
np.array([-0.4, 0.2, 1.1]))
x, y, idx = centr_ras.get_closest_point(0.1, 0.0)
self.assertEqual(x, 0.2)
self.assertEqual(y, 0.2)
self.assertEqual(idx, 1)
def test_area_pass(self):
"""Test set_area"""
ulx, xres, lrx = 60, 1, 90
uly, yres, lry = 0, 1, 20
xx, yy = np.meshgrid(np.arange(ulx + xres / 2, lrx, xres),
np.arange(uly + yres / 2, lry, yres))
vec_data = gpd.GeoDataFrame(
{
'geometry': [
Point(xflat, yflat)
for xflat, yflat in zip(xx.flatten(), yy.flatten())
],
'lon':
xx.flatten(),
'lat':
yy.flatten(),
},
crs={'proj': 'cea'})
centr = Centroids.from_lat_lon(vec_data.lat.values,
vec_data.lon.values)
centr.geometry = vec_data.geometry
centr.set_area_pixel()
self.assertTrue(np.allclose(centr.area_pixel, np.ones(centr.size)))
