def test_interpolate_irregular_arbitrary_2dims(self):
""" irregular interpolation """
# try >2 dims
source = np.random.rand(5, 5, 3)
coords_src = Coordinates(
[clinspace(0, 10, 5),
clinspace(0, 10, 5), [2, 3, 5]],
dims=['lat', 'lon', 'time'])
coords_dst = Coordinates(
[clinspace(1, 11, 5),
clinspace(1, 11, 5), [2, 3, 5]],
dims=['lat', 'lon', 'time'])
node = MockArrayDataSource(source=source,
native_coordinates=coords_src,
interpolation={
'method': 'nearest',
'interpolators': [ScipyGrid]
})
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert np.all(output.lon.values == coords_dst.coords['lon'])
assert np.all(output.time.values == coords_dst.coords['time'])
def test_interpolate_scipy_point(self):
""" interpolate point data to nearest neighbor with various coords_dst"""
source = np.random.rand(6)
coords_src = Coordinates(
[[[0, 2, 4, 6, 8, 10], [0, 2, 4, 5, 6, 10]]], dims=['lat_lon'])
coords_dst = Coordinates([[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]],
dims=['lat_lon'])
node = MockArrayDataSource(source=source,
native_coordinates=coords_src,
interpolation={
'method': 'nearest',
'interpolators': [ScipyPoint]
})
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(
output.lat_lon.values == coords_dst.coords['lat_lon'])
assert output.values[0] == source[0]
assert output.values[-1] == source[3]
coords_dst = Coordinates([[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
dims=['lat', 'lon'])
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert output.values[0, 0] == source[0]
assert output.values[-1, -1] == source[3]
def test_time_tolerance(self):
# unstacked 1D
source = np.random.rand(5, 5)
coords_src = Coordinates([
np.linspace(0, 10, 5),
clinspace('2018-01-01', '2018-01-09', 5)
],
dims=['lat', 'time'])
node = MockArrayDataSource(source=source,
native_coordinates=coords_src,
interpolation={
'default': {
'method': 'nearest',
'params': {
'spatial_tolerance':
1.1,
'time_tolerance':
np.timedelta64(1, 'D')
}
}
})
coords_dst = Coordinates(
[[1, 1.2, 1.5, 5, 9],
clinspace('2018-01-01', '2018-01-09', 3)],
dims=['lat', 'time'])
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert output.values[0, 0] == source[0, 0] and output.values[0, 1] == source[0, 2] and \
np.isnan(output.values[1, 0]) and np.isnan(output.values[1, 1]) and \
output.values[2, 0] == source[1, 0] and output.values[2, 1] == source[1, 2]
def test_spatial_tolerance(self):
# unstacked 1D
source = np.random.rand(5)
coords_src = Coordinates([np.linspace(0, 10, 5)], dims=['lat'])
node = MockArrayDataSource(source=source,
native_coordinates=coords_src,
interpolation={
'default': {
'method': 'nearest',
'params': {
'spatial_tolerance': 1.1
}
}
})
coords_dst = Coordinates([[1, 1.2, 1.5, 5, 9]], dims=['lat'])
output = node.eval(coords_dst)
print(output)
print(source)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert output.values[0] == source[0] and \
np.isnan(output.values[1]) and \
output.values[2] == source[1]
def test_interpolate_scipy_grid(self):
source = np.arange(0, 25)
source.resize((5, 5))
coords_src = Coordinates(
[clinspace(0, 10, 5), clinspace(0, 10, 5)],
dims=['lat', 'lon'])
coords_dst = Coordinates(
[clinspace(1, 11, 5), clinspace(1, 11, 5)],
dims=['lat', 'lon'])
# try one specific rasterio case to measure output
node = MockArrayDataSource(source=source,
native_coordinates=coords_src)
node.interpolation = {
'method': 'nearest',
'interpolators': [ScipyGrid]
}
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
print(output)
assert output.data[0, 0] == 0.
assert output.data[0, 3] == 3.
assert output.data[1, 3] == 8.
assert np.isnan(
output.data[0, 4]) # TODO: how to handle outside bounds
node.interpolation = {
'method': 'cubic_spline',
'interpolators': [ScipyGrid]
}
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert int(output.data[0, 0]) == 2
assert int(output.data[2, 4]) == 16
node.interpolation = {
'method': 'bilinear',
'interpolators': [ScipyGrid]
}
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert int(output.data[0, 0]) == 2
assert int(output.data[3, 3]) == 20
assert np.isnan(
output.data[4, 4]) # TODO: how to handle outside bounds
def test_interpolate_irregular_arbitrary_swap(self):
"""should handle descending"""
source = np.random.rand(5, 5)
coords_src = Coordinates(
[clinspace(0, 10, 5), clinspace(0, 10, 5)],
dims=['lat', 'lon'])
coords_dst = Coordinates(
[clinspace(2, 12, 5), clinspace(2, 12, 5)],
dims=['lat', 'lon'])
node = MockArrayDataSource(source=source,
native_coordinates=coords_src,
interpolation={
'method': 'nearest',
'interpolators': [ScipyGrid]
})
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert np.all(output.lon.values == coords_dst.coords['lon'])
def test_interpolate_irregular_lat_lon(self):
""" irregular interpolation """
source = np.random.rand(5, 5)
coords_src = Coordinates(
[clinspace(0, 10, 5), clinspace(0, 10, 5)],
dims=['lat', 'lon'])
coords_dst = Coordinates(
[[[0, 2, 4, 6, 8, 10], [0, 2, 4, 5, 6, 10]]], dims=['lat_lon'])
node = MockArrayDataSource(source=source,
native_coordinates=coords_src,
interpolation={
'method': 'nearest',
'interpolators': [ScipyGrid]
})
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(
output.lat_lon.values == coords_dst.coords['lat_lon'])
assert output.values[0] == source[0, 0]
assert output.values[1] == source[1, 1]
assert output.values[-1] == source[-1, -1]
def test_interpolate_rasterio(self):
""" regular interpolation using rasterio"""
assert rasterio is not None
source = np.arange(0, 15)
source.resize((3, 5))
coords_src = Coordinates(
[clinspace(0, 10, 3), clinspace(0, 10, 5)],
dims=['lat', 'lon'])
coords_dst = Coordinates(
[clinspace(1, 11, 3), clinspace(1, 11, 5)],
dims=['lat', 'lon'])
# try one specific rasterio case to measure output
node = MockArrayDataSource(source=source,
native_coordinates=coords_src)
node.interpolation = {'method': 'min', 'interpolators': [Rasterio]}
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert output.data[0, 3] == 3.
assert output.data[0, 4] == 4.
node.interpolation = {'method': 'max', 'interpolators': [Rasterio]}
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert output.data[0, 3] == 9.
assert output.data[0, 4] == 9.
node.interpolation = {
'method': 'bilinear',
'interpolators': [Rasterio]
}
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert int(output.data[0, 0]) == 1
assert int(output.data[0, 4]) == 5
def test_interpolation(self):
for interpolation in ['nearest', 'nearest_preview']:
# unstacked 1D
source = np.random.rand(5)
coords_src = Coordinates([np.linspace(
0,
10,
5,
)],
dims=['lat'])
node = MockArrayDataSource(source=source,
native_coordinates=coords_src,
interpolation=interpolation)
coords_dst = Coordinates([[1, 1.2, 1.5, 5, 9]], dims=['lat'])
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert output.values[0] == source[0] and \
output.values[1] == source[0] and \
output.values[2] == source[1]
# unstacked N-D
source = np.random.rand(5, 5)
coords_src = Coordinates(
[clinspace(0, 10, 5),
clinspace(0, 10, 5)],
dims=['lat', 'lon'])
coords_dst = Coordinates(
[clinspace(2, 12, 5),
clinspace(2, 12, 5)],
dims=['lat', 'lon'])
node = MockArrayDataSource(source=source,
native_coordinates=coords_src,
interpolation=interpolation)
output = node.eval(coords_dst)
assert isinstance(output, UnitsDataArray)
assert np.all(output.lat.values == coords_dst.coords['lat'])
assert output.values[0, 0] == source[1, 1]
# stacked
# TODO: implement stacked handling
source = np.random.rand(5)
coords_src = Coordinates(
[(np.linspace(0, 10, 5), np.linspace(0, 10, 5))],
dims=['lat_lon'])
node = MockArrayDataSource(source=source,
native_coordinates=coords_src)
node.interpolation = {
'method': 'nearest',
'interpolators': [NearestNeighbor]
}
coords_dst = Coordinates(
[(np.linspace(1, 9, 3), np.linspace(1, 9, 3))],
dims=['lat_lon'])
with pytest.raises(InterpolationException):
output = node.eval(coords_dst)
# TODO: implement stacked handling
# source = stacked, dest = unstacked
source = np.random.rand(5)
coords_src = Coordinates(
[(np.linspace(0, 10, 5), np.linspace(0, 10, 5))],
dims=['lat_lon'])
node = MockArrayDataSource(source=source,
native_coordinates=coords_src)
node.interpolation = {
'method': 'nearest',
'interpolators': [NearestNeighbor]
}
coords_dst = Coordinates(
[np.linspace(1, 9, 3),
np.linspace(1, 9, 3)],
dims=['lat', 'lon'])
with pytest.raises(InterpolationException):
output = node.eval(coords_dst)
# TODO: implement stacked handling
# source = unstacked, dest = stacked
source = np.random.rand(5, 5)
coords_src = Coordinates(
[np.linspace(0, 10, 5),
np.linspace(0, 10, 5)],
dims=['lat', 'lon'])
node = MockArrayDataSource(source=source,
native_coordinates=coords_src)
node.interpolation = {
'method': 'nearest',
'interpolators': [NearestNeighbor]
}
coords_dst = Coordinates(
[(np.linspace(1, 9, 3), np.linspace(1, 9, 3))],
dims=['lat_lon'])
with pytest.raises(InterpolationException):
output = node.eval(coords_dst)