def test_bil_resampling(self, resampler, create_filename, load, savez):
"""Test the bilinear resampler."""
import numpy as np
import dask.array as da
from satpy.resample import BilinearResampler
from pyresample.geometry import SwathDefinition
source_area = mock.MagicMock()
source_swath = SwathDefinition(da.arange(5, chunks=5),
da.arange(5, chunks=5))
target_area = mock.MagicMock()
# Test that bilinear resampling info calculation is called,
# and the info is saved
load.side_effect = IOError()
resampler = BilinearResampler(source_swath, target_area)
resampler.precompute(mask=da.arange(5, chunks=5).astype(np.bool))
resampler.resampler.get_bil_info.assert_called()
resampler.resampler.get_bil_info.assert_called_with()
self.assertFalse(len(savez.mock_calls), 1)
resampler.resampler.reset_mock()
load.reset_mock()
load.side_effect = None
# Test that get_sample_from_bil_info is called properly
data = mock.MagicMock()
data.name = 'foo'
data.data = [1, 2, 3]
fill_value = 8
resampler.compute(data, fill_value=fill_value)
resampler.resampler.get_sample_from_bil_info.assert_called_with(
data, fill_value=fill_value, output_shape=target_area.shape)
# Test that the resampling info is tried to read from the disk
resampler = BilinearResampler(source_swath, target_area)
resampler.precompute(cache_dir='.')
load.assert_called()
# Test caching the resampling info
try:
the_dir = tempfile.mkdtemp()
resampler = BilinearResampler(source_area, target_area)
create_filename.return_value = os.path.join(
the_dir, 'test_cache.npz')
load.reset_mock()
load.side_effect = IOError()
resampler.precompute(cache_dir=the_dir)
savez.assert_called()
# assert data was saved to the on-disk cache
self.assertEqual(len(savez.mock_calls), 1)
# assert that load was called to try to load something from disk
self.assertEqual(len(load.mock_calls), 1)
nbcalls = len(resampler.resampler.get_bil_info.mock_calls)
# test reusing the resampler
load.side_effect = None
class FakeNPZ(dict):
def close(self):
pass
load.return_value = FakeNPZ(bilinear_s=1,
bilinear_t=2,
valid_input_index=3,
index_array=4)
resampler.precompute(cache_dir=the_dir)
# we already have things cached in-memory, no need to save again
self.assertEqual(len(savez.mock_calls), 1)
# we already have things cached in-memory, don't need to load
# self.assertEqual(len(load.mock_calls), 1)
self.assertEqual(len(resampler.resampler.get_bil_info.mock_calls),
nbcalls)
# test loading saved resampler
resampler = BilinearResampler(source_area, target_area)
resampler.precompute(cache_dir=the_dir)
self.assertEqual(len(load.mock_calls), 2)
self.assertEqual(len(resampler.resampler.get_bil_info.mock_calls),
nbcalls)
# we should have cached things in-memory now
# self.assertEqual(len(resampler._index_caches), 1)
finally:
shutil.rmtree(the_dir)
def test_bil_resampling(self, xr_resampler, create_filename,
move_existing_caches):
"""Test the bilinear resampler."""
import numpy as np
import dask.array as da
import xarray as xr
from satpy.resample import BilinearResampler
data, source_area, swath_data, source_swath, target_area = get_test_data(
)
# Test that bilinear resampling info calculation is called
resampler = BilinearResampler(source_swath, target_area)
resampler.precompute(mask=da.arange(5, chunks=5).astype(np.bool))
resampler.resampler.load_resampling_info.assert_not_called()
resampler.resampler.get_bil_info.assert_called_once()
resampler.resampler.reset_mock()
# Test that get_sample_from_bil_info is called properly
fill_value = 8
resampler.resampler.get_sample_from_bil_info.return_value = \
xr.DataArray(da.zeros(target_area.shape), dims=('y', 'x'))
new_data = resampler.compute(data, fill_value=fill_value)
resampler.resampler.get_sample_from_bil_info.assert_called_with(
data, fill_value=fill_value, output_shape=target_area.shape)
self.assertIn('y', new_data.coords)
self.assertIn('x', new_data.coords)
if CRS is not None:
self.assertIn('crs', new_data.coords)
self.assertIsInstance(new_data.coords['crs'].item(), CRS)
self.assertIn('lcc', new_data.coords['crs'].item().to_proj4())
self.assertEqual(new_data.coords['y'].attrs['units'], 'meter')
self.assertEqual(new_data.coords['x'].attrs['units'], 'meter')
if hasattr(target_area, 'crs'):
self.assertIs(target_area.crs, new_data.coords['crs'].item())
# Test that the resampling info is tried to read from the disk
resampler = BilinearResampler(source_swath, target_area)
resampler.precompute(cache_dir='.')
resampler.resampler.load_resampling_info.assert_called()
# Test caching the resampling info
try:
the_dir = tempfile.mkdtemp()
resampler = BilinearResampler(source_area, target_area)
create_filename.return_value = os.path.join(
the_dir, 'test_cache.zarr')
xr_resampler.return_value.load_resampling_info.side_effect = IOError
resampler.precompute(cache_dir=the_dir)
resampler.resampler.save_resampling_info.assert_called()
# assert data was saved to the on-disk cache
resampler.resampler.save_resampling_info.assert_called_once()
nbcalls = resampler.resampler.get_bil_info.call_count
resampler.resampler.load_resampling_info.side_effect = None
resampler.precompute(cache_dir=the_dir)
# we already have things cached in-memory, no need to save again
resampler.resampler.save_resampling_info.assert_called_once()
# we already have things cached in-memory, don't need to load
self.assertEqual(resampler.resampler.get_bil_info.call_count,
nbcalls)
# test loading saved resampler
resampler = BilinearResampler(source_area, target_area)
resampler.precompute(cache_dir=the_dir)
self.assertEqual(
resampler.resampler.load_resampling_info.call_count, 3)
self.assertEqual(resampler.resampler.get_bil_info.call_count,
nbcalls)
resampler = BilinearResampler(source_area, target_area)
resampler.precompute(cache_dir=the_dir)
resampler.save_bil_info(cache_dir=the_dir)
zarr_file = os.path.join(the_dir, 'test_cache.zarr')
# Save again faking the cache file already exists
with mock.patch('os.path.exists') as exists:
exists.return_value = True
resampler.save_bil_info(cache_dir=the_dir)
move_existing_caches.assert_called_once_with(the_dir, zarr_file)
finally:
shutil.rmtree(the_dir)
def test_bil_resampling(self, resampler, create_filename, load, savez):
"""Test the bilinear resampler."""
import numpy as np
import dask.array as da
import xarray as xr
from satpy.resample import BilinearResampler
data, source_area, swath_data, source_swath, target_area = get_test_data()
# Test that bilinear resampling info calculation is called,
# and the info is saved
load.side_effect = IOError()
resampler = BilinearResampler(source_swath, target_area)
resampler.precompute(
mask=da.arange(5, chunks=5).astype(np.bool))
resampler.resampler.get_bil_info.assert_called()
resampler.resampler.get_bil_info.assert_called_with()
self.assertFalse(len(savez.mock_calls), 1)
resampler.resampler.reset_mock()
load.reset_mock()
load.side_effect = None
# Test that get_sample_from_bil_info is called properly
fill_value = 8
resampler.resampler.get_sample_from_bil_info.return_value = \
xr.DataArray(da.zeros(target_area.shape), dims=('y', 'x'))
new_data = resampler.compute(data, fill_value=fill_value)
resampler.resampler.get_sample_from_bil_info.assert_called_with(
data, fill_value=fill_value, output_shape=target_area.shape)
self.assertIn('y', new_data.coords)
self.assertIn('x', new_data.coords)
if CRS is not None:
self.assertIn('crs', new_data.coords)
self.assertIsInstance(new_data.coords['crs'].item(), CRS)
self.assertIn('lcc', new_data.coords['crs'].item().to_proj4())
self.assertEqual(new_data.coords['y'].attrs['units'], 'meter')
self.assertEqual(new_data.coords['x'].attrs['units'], 'meter')
# Test that the resampling info is tried to read from the disk
resampler = BilinearResampler(source_swath, target_area)
resampler.precompute(cache_dir='.')
load.assert_called()
# Test caching the resampling info
try:
the_dir = tempfile.mkdtemp()
resampler = BilinearResampler(source_area, target_area)
create_filename.return_value = os.path.join(the_dir, 'test_cache.npz')
load.reset_mock()
load.side_effect = IOError()
resampler.precompute(cache_dir=the_dir)
savez.assert_called()
# assert data was saved to the on-disk cache
self.assertEqual(len(savez.mock_calls), 1)
# assert that load was called to try to load something from disk
self.assertEqual(len(load.mock_calls), 1)
nbcalls = len(resampler.resampler.get_bil_info.mock_calls)
# test reusing the resampler
load.side_effect = None
class FakeNPZ(dict):
def close(self):
pass
load.return_value = FakeNPZ(bilinear_s=1,
bilinear_t=2,
valid_input_index=3,
index_array=4)
resampler.precompute(cache_dir=the_dir)
# we already have things cached in-memory, no need to save again
self.assertEqual(len(savez.mock_calls), 1)
# we already have things cached in-memory, don't need to load
# self.assertEqual(len(load.mock_calls), 1)
self.assertEqual(len(resampler.resampler.get_bil_info.mock_calls), nbcalls)
# test loading saved resampler
resampler = BilinearResampler(source_area, target_area)
resampler.precompute(cache_dir=the_dir)
self.assertEqual(len(load.mock_calls), 2)
self.assertEqual(len(resampler.resampler.get_bil_info.mock_calls), nbcalls)
# we should have cached things in-memory now
# self.assertEqual(len(resampler._index_caches), 1)
finally:
shutil.rmtree(the_dir)
def test_bil_resampling(self, resampler, create_filename, zarr_open,
xr_dset, move_existing_caches):
"""Test the bilinear resampler."""
import numpy as np
import dask.array as da
import xarray as xr
from satpy.resample import BilinearResampler
data, source_area, swath_data, source_swath, target_area = get_test_data()
mock_dset = mock.MagicMock()
xr_dset.return_value = mock_dset
# Test that bilinear resampling info calculation is called,
# and the info is saved
zarr_open.side_effect = IOError()
resampler = BilinearResampler(source_swath, target_area)
resampler.precompute(
mask=da.arange(5, chunks=5).astype(np.bool))
resampler.resampler.get_bil_info.assert_called()
resampler.resampler.get_bil_info.assert_called_with()
self.assertFalse(len(mock_dset.to_zarr.mock_calls), 1)
resampler.resampler.reset_mock()
zarr_open.reset_mock()
zarr_open.side_effect = None
# Test that get_sample_from_bil_info is called properly
fill_value = 8
resampler.resampler.get_sample_from_bil_info.return_value = \
xr.DataArray(da.zeros(target_area.shape), dims=('y', 'x'))
new_data = resampler.compute(data, fill_value=fill_value)
resampler.resampler.get_sample_from_bil_info.assert_called_with(
data, fill_value=fill_value, output_shape=target_area.shape)
self.assertIn('y', new_data.coords)
self.assertIn('x', new_data.coords)
if CRS is not None:
self.assertIn('crs', new_data.coords)
self.assertIsInstance(new_data.coords['crs'].item(), CRS)
self.assertIn('lcc', new_data.coords['crs'].item().to_proj4())
self.assertEqual(new_data.coords['y'].attrs['units'], 'meter')
self.assertEqual(new_data.coords['x'].attrs['units'], 'meter')
if hasattr(target_area, 'crs'):
self.assertIs(target_area.crs, new_data.coords['crs'].item())
# Test that the resampling info is tried to read from the disk
resampler = BilinearResampler(source_swath, target_area)
resampler.precompute(cache_dir='.')
zarr_open.assert_called()
# Test caching the resampling info
try:
the_dir = tempfile.mkdtemp()
resampler = BilinearResampler(source_area, target_area)
create_filename.return_value = os.path.join(the_dir, 'test_cache.zarr')
zarr_open.reset_mock()
zarr_open.side_effect = IOError()
resampler.precompute(cache_dir=the_dir)
xr_dset.assert_called()
# assert data was saved to the on-disk cache
self.assertEqual(len(mock_dset.to_zarr.mock_calls), 1)
# assert that zarr.open was called to try to load
# something from disk
self.assertEqual(len(zarr_open.mock_calls), 1)
nbcalls = len(resampler.resampler.get_bil_info.mock_calls)
# test reusing the resampler
zarr_open.side_effect = None
class FakeZarr(dict):
def close(self):
pass
def astype(self, dtype):
return self
def compute(self):
return self
zarr_open.return_value = FakeZarr(bilinear_s=1,
bilinear_t=2,
slices_x=3,
slices_y=4,
mask_slices=5,
out_coords_x=6,
out_coords_y=7)
resampler.precompute(cache_dir=the_dir)
# we already have things cached in-memory, no need to save again
self.assertEqual(len(mock_dset.to_zarr.mock_calls), 1)
# we already have things cached in-memory, don't need to load
# self.assertEqual(len(zarr_open.mock_calls), 1)
self.assertEqual(len(resampler.resampler.get_bil_info.mock_calls), nbcalls)
# test loading saved resampler
resampler = BilinearResampler(source_area, target_area)
resampler.precompute(cache_dir=the_dir)
self.assertEqual(len(zarr_open.mock_calls), 2)
self.assertEqual(len(resampler.resampler.get_bil_info.mock_calls), nbcalls)
# we should have cached things in-memory now
# self.assertEqual(len(resampler._index_caches), 1)
resampler = BilinearResampler(source_area, target_area)
resampler.precompute(cache_dir=the_dir)
resampler.save_bil_info(cache_dir=the_dir)
zarr_file = os.path.join(the_dir, 'test_cache.zarr')
# Save again faking the cache file already exists
with mock.patch('os.path.exists') as exists:
exists.return_value = True
resampler.save_bil_info(cache_dir=the_dir)
move_existing_caches.assert_called_once_with(the_dir, zarr_file)
finally:
shutil.rmtree(the_dir)