def test_ndvi_gpu():
# cupy
nir_cupy = create_test_arr(nir_data, backend='cupy')
red_cupy = create_test_arr(red_data, backend='cupy')
cupy_result = ndvi(nir_cupy, red_cupy)
general_output_checks(nir_cupy, cupy_result, ndvi_expected_results)
# dask + cupy
nir_dask = create_test_arr(nir_data, backend='dask+cupy')
red_dask = create_test_arr(red_data, backend='dask+cupy')
dask_cupy_result = ndvi(nir_dask, red_dask)
general_output_checks(nir_dask, dask_cupy_result, ndvi_expected_results)
def test_ndvi_cpu():
# vanilla numpy version
nir_numpy = create_test_arr(nir_data)
red_numpy = create_test_arr(red_data)
numpy_result = ndvi(nir_numpy, red_numpy)
general_output_checks(nir_numpy, numpy_result, ndvi_expected_results)
# dask
nir_dask = create_test_arr(nir_data, backend='dask')
red_dask = create_test_arr(red_data, backend='dask')
dask_result = ndvi(nir_dask, red_dask)
general_output_checks(nir_dask, dask_result, ndvi_expected_results)
def test_ndvi_dask_cupy_equals_numpy():
# vanilla numpy version
nir = create_test_arr(arr1)
red = create_test_arr(arr2)
numpy_result = ndvi(nir, red)
# dask + cupy
nir_dask = create_test_arr(arr1, backend='dask+cupy')
red_dask = create_test_arr(arr2, backend='dask+cupy')
test_result = ndvi(nir_dask, red_dask)
assert is_dask_cupy(test_result)
test_result.data = test_result.data.compute()
assert np.isclose(numpy_result, test_result, equal_nan=True).all()
def test_ndvi_cupy_equals_numpy():
import cupy
# vanilla numpy version
nir = create_test_arr(arr1)
red = create_test_arr(arr2)
numpy_result = ndvi(nir, red)
# cupy
nir_cupy = create_test_arr(arr1, backend='cupy')
red_cupy = create_test_arr(arr2, backend='cupy')
test_result = ndvi(nir_cupy, red_cupy)
assert isinstance(test_result.data, cupy.ndarray)
assert np.isclose(numpy_result, test_result, equal_nan=True).all()
def test_ndvi_numpy_contains_valid_values():
"""
Assert aspect transfer function
"""
_x = np.mgrid[1:0:21j]
a, b = np.meshgrid(_x, _x)
red = a*b
nir = (a*b)[::-1, ::-1]
da_nir = xr.DataArray(nir, dims=['y', 'x'])
# add crs for tests
da_nir = _add_EPSG4326_crs_to_da(da_nir)
da_red = xr.DataArray(red, dims=['y', 'x'])
da_ndvi = ndvi(da_nir, da_red)
# test preservation of dims, attrs, coords, including crs
assert da_ndvi.dims == da_nir.dims
assert da_ndvi.attrs == da_nir.attrs
for coord in da_nir.coords:
assert np.all(da_nir[coord] == da_ndvi[coord])
assert da_ndvi[0, 0] == -1
assert da_ndvi[-1, -1] == 1
assert da_ndvi[5, 10] == da_ndvi[10, 5] == -0.5
assert da_ndvi[15, 10] == da_ndvi[10, 15] == 0.5
def test_savi():
max_val = 2**16 - 1
arr1 = np.array([[max_val, max_val, max_val, max_val],
[max_val, 1000.0, 1000.0, max_val],
[max_val, 1000.0, 1000.0, max_val],
[max_val, 1000.0, 1000.0, max_val],
[max_val, max_val, max_val, max_val]],
dtype=np.float64)
arr2 = np.array(
[[100.0, 100.0, 100.0, 100.0], [100.0, max_val, max_val, 100.0],
[100.0, max_val, max_val, 100.0], [100.0, max_val, max_val, 100.0],
[100.0, 100.0, 100.0, 100.0]],
dtype=np.float64)
nir = create_test_arr(arr1)
red = create_test_arr(arr2)
# savi should be same as ndvi at soil_factor=0
result_savi = savi(nir, red, soil_factor=0.0)
result_ndvi = ndvi(nir, red)
assert (result_savi.data == result_ndvi.data).all()
assert result_savi.dims == nir.dims
result_savi = savi(nir, red, soil_factor=1.0)
assert isinstance(result_savi, xa.DataArray)
assert result_savi.dims == nir.dims
def test_savi_numpy():
nir = create_test_arr(arr1)
red = create_test_arr(arr2)
# savi should be same as ndvi at soil_factor=0
result_savi = savi(nir, red, soil_factor=0.0)
result_ndvi = ndvi(nir, red)
assert np.isclose(result_savi.data, result_ndvi.data, equal_nan=True).all()
assert result_savi.dims == nir.dims
result_savi = savi(nir, red, soil_factor=1.0)
assert isinstance(result_savi, xa.DataArray)
assert result_savi.dims == nir.dims
def test_savi_cpu():
nir_numpy = create_test_arr(nir_data)
red_numpy = create_test_arr(red_data)
# savi should be same as ndvi at soil_factor=0
result_savi = savi(nir_numpy, red_numpy, soil_factor=0.0)
result_ndvi = ndvi(nir_numpy, red_numpy)
assert np.isclose(result_savi.data, result_ndvi.data, equal_nan=True).all()
# test default savi where soil_factor = 1.0
numpy_result = savi(nir_numpy, red_numpy, soil_factor=1.0)
general_output_checks(nir_numpy, numpy_result, savi_expected_results)
# dask
nir_dask = create_test_arr(nir_data, backend='dask')
red_dask = create_test_arr(red_data, backend='dask')
dask_result = savi(nir_dask, red_dask)
general_output_checks(nir_dask, dask_result, savi_expected_results)
def test_ndvi_numpy_contains_valid_values():
_x = np.mgrid[1:0:21j]
a, b = np.meshgrid(_x, _x)
red_numpy = a * b
nir_numpy = (a * b)[::-1, ::-1]
da_nir = xr.DataArray(nir_numpy, dims=['y', 'x'])
da_red = xr.DataArray(red_numpy, dims=['y', 'x'])
da_ndvi = ndvi(da_nir, da_red)
assert da_ndvi.dims == da_nir.dims
assert da_ndvi.attrs == da_nir.attrs
for coord in da_nir.coords:
assert np.all(da_nir[coord] == da_ndvi[coord])
assert da_ndvi[0, 0] == -1
assert da_ndvi[-1, -1] == 1
assert da_ndvi[5, 10] == da_ndvi[10, 5] == -0.5
assert da_ndvi[15, 10] == da_ndvi[10, 15] == 0.5
def test_ndvi():
"""
Assert aspect transfer function
"""
_x = np.mgrid[1:0:21j]
a, b = np.meshgrid(_x, _x)
red = a * b
nir = (a * b)[::-1, ::-1]
da_red = xr.DataArray(red, dims=['y', 'x'])
da_nir = xr.DataArray(nir, dims=['y', 'x'])
da_ndvi = ndvi(da_nir, da_red)
assert da_ndvi.dims == da_nir.dims
assert da_ndvi.coords == da_nir.coords
assert da_ndvi.attrs == da_nir.attrs
assert da_ndvi[0, 0] == -1
assert da_ndvi[-1, -1] == 1
assert da_ndvi[5, 10] == da_ndvi[10, 5] == -0.5
assert da_ndvi[15, 10] == da_ndvi[10, 15] == 0.5
def test_savi_numpy():
nir = create_test_arr(arr1)
# add crs for tests
nir = _add_EPSG4326_crs_to_da(nir)
red = create_test_arr(arr2)
# savi should be same as ndvi at soil_factor=0
result_savi = savi(nir, red, soil_factor=0.0)
result_ndvi = ndvi(nir, red)
assert np.isclose(result_savi.data, result_ndvi.data, equal_nan=True).all()
assert result_savi.dims == nir.dims
result_savi = savi(nir, red, soil_factor=1.0)
assert isinstance(result_savi, xa.DataArray)
assert result_savi.dims == nir.dims
# crs tests
assert result_savi.attrs == nir.attrs
for coord in nir.coords:
assert np.all(result_savi[coord] == nir[coord])
def time_ndvi(self, nx, type):
ndvi(self.nir, self.red)
def test_ndvi_gpu(nir_data, red_data, result_ndvi):
result = ndvi(nir_data, red_data)
general_output_checks(nir_data, result, result_ndvi, verify_dtype=True)
