def test_type_preserve(self):
"""Check that the type of resampled datasets is preserved."""
from satpy.resample import resample_dataset
import xarray as xr
import dask.array as da
import numpy as np
from pyresample.geometry import SwathDefinition
source_area = SwathDefinition(
xr.DataArray(da.arange(4, chunks=5).reshape((2, 2)),
dims=['y', 'x']),
xr.DataArray(da.arange(4, chunks=5).reshape((2, 2)),
dims=['y', 'x']))
dest_area = SwathDefinition(
xr.DataArray(da.arange(4, chunks=5).reshape((2, 2)) + .0001,
dims=['y', 'x']),
xr.DataArray(da.arange(4, chunks=5).reshape((2, 2)) + .0001,
dims=['y', 'x']))
expected_gap = np.array([[1, 2], [3, 255]])
data = xr.DataArray(da.from_array(expected_gap, chunks=5),
dims=['y', 'x'])
data.attrs['_FillValue'] = 255
data.attrs['area'] = source_area
res = resample_dataset(data, dest_area)
self.assertEqual(res.dtype, data.dtype)
self.assertTrue(np.all(res.values == expected_gap))
expected_filled = np.array([[1, 2], [3, 3]])
res = resample_dataset(data, dest_area, radius_of_influence=1000000)
self.assertEqual(res.dtype, data.dtype)
self.assertTrue(np.all(res.values == expected_filled))
def test_3d_ewa(self, ll2cr, fornav):
"""Test EWA with a 3D dataset."""
import numpy as np
import dask.array as da
import xarray as xr
from satpy.resample import resample_dataset
from pyresample.geometry import SwathDefinition, AreaDefinition
from pyresample.utils import proj4_str_to_dict
lons = xr.DataArray(da.zeros((10, 10), chunks=5))
lats = xr.DataArray(da.zeros((10, 10), chunks=5))
ll2cr.return_value = (100, np.zeros(
(10, 10), dtype=np.float32), np.zeros((10, 10), dtype=np.float32))
fornav.return_value = ([100 * 200] * 3,
[np.zeros((200, 100), dtype=np.float32)] * 3)
sgd = SwathDefinition(lons, lats)
proj_dict = proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 '
'+lon_0=-95. +lat_0=25 +lat_1=25 '
'+units=m +no_defs')
tgd = AreaDefinition(
'test',
'test',
'test',
proj_dict,
100,
200,
(-1000., -1500., 1000., 1500.),
)
input_data = xr.DataArray(da.zeros((3, 10, 10),
chunks=5,
dtype=np.float32),
dims=('bands', 'y', 'x'),
attrs={
'area': sgd,
'test': 'test'
})
new_data = resample_dataset(input_data, tgd, resampler='ewa')
self.assertTupleEqual(new_data.shape, (3, 200, 100))
self.assertEqual(new_data.dtype, np.float32)
self.assertEqual(new_data.attrs['test'], 'test')
self.assertIs(new_data.attrs['area'], tgd)
# make sure we can actually compute everything
new_data.compute()
previous_calls = ll2cr.call_count
# resample a different dataset and make sure cache is used
input_data = xr.DataArray(da.zeros((3, 10, 10),
chunks=5,
dtype=np.float32),
dims=('bands', 'y', 'x'),
attrs={
'area': sgd,
'test': 'test'
})
new_data = resample_dataset(input_data, tgd, resampler='ewa')
self.assertEqual(ll2cr.call_count, previous_calls)
new_data.compute()
def test_3d_ewa(self, get_lonlats, ll2cr, fornav):
"""Test EWA with a 3D dataset."""
import numpy as np
import xarray as xr
from satpy.resample import resample_dataset
_, _, swath_data, source_swath, target_area = get_test_data(
input_shape=(3, 200, 100), input_dims=('bands', 'y', 'x'))
swath_data.data = swath_data.data.astype(np.float32)
ll2cr.return_value = (100, np.zeros(
(10, 10), dtype=np.float32), np.zeros((10, 10), dtype=np.float32))
fornav.return_value = ([100 * 200] * 3,
[np.zeros((200, 100), dtype=np.float32)] * 3)
get_lonlats.return_value = (source_swath.lons, source_swath.lats)
num_chunks = len(source_swath.lons.chunks[0]) * len(
source_swath.lons.chunks[1])
new_data = resample_dataset(swath_data, target_area, resampler='ewa')
self.assertTupleEqual(new_data.shape, (3, 200, 100))
self.assertEqual(new_data.dtype, np.float32)
self.assertEqual(new_data.attrs['test'], 'test')
self.assertIs(new_data.attrs['area'], target_area)
# make sure we can actually compute everything
new_data.compute()
lonlat_calls = get_lonlats.call_count
ll2cr_calls = ll2cr.call_count
# resample a different dataset and make sure cache is used
swath_data = xr.DataArray(swath_data.data,
dims=('bands', 'y', 'x'),
coords={'bands': ['R', 'G', 'B']},
attrs={
'area': source_swath,
'test': 'test'
})
new_data = resample_dataset(swath_data, target_area, resampler='ewa')
new_data.compute()
# ll2cr will be called once more because of the computation
self.assertEqual(ll2cr.call_count, ll2cr_calls + num_chunks)
# but we should already have taken the lonlats from the SwathDefinition
self.assertEqual(get_lonlats.call_count, lonlat_calls)
self.assertIn('y', new_data.coords)
self.assertIn('x', new_data.coords)
self.assertIn('bands', new_data.coords)
self.assertIn('crs', new_data.coords)
self.assertIsInstance(new_data.coords['crs'].item(), CRS)
self.assertIn(
'lambert', new_data.coords['crs'].item().coordinate_operation.
method_name.lower())
self.assertEqual(new_data.coords['y'].attrs['units'], 'meter')
self.assertEqual(new_data.coords['x'].attrs['units'], 'meter')
np.testing.assert_equal(new_data.coords['bands'].values,
['R', 'G', 'B'])
self.assertEqual(target_area.crs, new_data.coords['crs'].item())
def test_2d_ewa(self, get_lonlats, ll2cr, fornav):
"""Test EWA with a 2D dataset."""
import numpy as np
import xarray as xr
from satpy.resample import resample_dataset
ll2cr.return_value = (100, np.zeros(
(10, 10), dtype=np.float32), np.zeros((10, 10), dtype=np.float32))
fornav.return_value = (100 * 200, np.zeros((200, 100),
dtype=np.float32))
_, _, swath_data, source_swath, target_area = get_test_data()
get_lonlats.return_value = (source_swath.lons, source_swath.lats)
swath_data.data = swath_data.data.astype(np.float32)
num_chunks = len(source_swath.lons.chunks[0]) * len(
source_swath.lons.chunks[1])
new_data = resample_dataset(swath_data, target_area, resampler='ewa')
self.assertTupleEqual(new_data.shape, (200, 100))
self.assertEqual(new_data.dtype, np.float32)
self.assertEqual(new_data.attrs['test'], 'test')
self.assertIs(new_data.attrs['area'], target_area)
# make sure we can actually compute everything
new_data.compute()
lonlat_calls = get_lonlats.call_count
ll2cr_calls = ll2cr.call_count
# resample a different dataset and make sure cache is used
data = xr.DataArray(swath_data.data,
dims=('y', 'x'),
attrs={
'area': source_swath,
'test': 'test2',
'name': 'test2'
})
new_data = resample_dataset(data, target_area, resampler='ewa')
new_data.compute()
# ll2cr will be called once more because of the computation
self.assertEqual(ll2cr.call_count, ll2cr_calls + num_chunks)
# but we should already have taken the lonlats from the SwathDefinition
self.assertEqual(get_lonlats.call_count, lonlat_calls)
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())
def test_3d_ewa(self, ll2cr, fornav):
"""Test EWA with a 3D dataset."""
import numpy as np
import dask.array as da
import xarray as xr
from satpy.resample import resample_dataset
from pyresample.geometry import SwathDefinition, AreaDefinition
from pyresample.utils import proj4_str_to_dict
lons = xr.DataArray(da.zeros((10, 10), chunks=5))
lats = xr.DataArray(da.zeros((10, 10), chunks=5))
ll2cr.return_value = (100,
np.zeros((10, 10), dtype=np.float32),
np.zeros((10, 10), dtype=np.float32))
fornav.return_value = ([100 * 200] * 3,
[np.zeros((200, 100), dtype=np.float32)] * 3)
sgd = SwathDefinition(lons, lats)
proj_dict = proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 '
'+lon_0=-95. +lat_0=25 +lat_1=25 '
'+units=m +no_defs')
tgd = AreaDefinition(
'test',
'test',
'test',
proj_dict,
x_size=100,
y_size=200,
area_extent=(-1000., -1500., 1000., 1500.),
)
input_data = xr.DataArray(
da.zeros((3, 10, 10), chunks=5, dtype=np.float32),
dims=('bands', 'y', 'x'), attrs={'area': sgd, 'test': 'test'})
new_data = resample_dataset(input_data, tgd, resampler='ewa')
self.assertTupleEqual(new_data.shape, (3, 200, 100))
self.assertEqual(new_data.dtype, np.float32)
self.assertEqual(new_data.attrs['test'], 'test')
self.assertIs(new_data.attrs['area'], tgd)
# make sure we can actually compute everything
new_data.compute()
previous_calls = ll2cr.call_count
# resample a different dataset and make sure cache is used
input_data = xr.DataArray(
da.zeros((3, 10, 10), chunks=5, dtype=np.float32),
dims=('bands', 'y', 'x'), attrs={'area': sgd, 'test': 'test'})
new_data = resample_dataset(input_data, tgd, resampler='ewa')
self.assertEqual(ll2cr.call_count, previous_calls)
new_data.compute()
def _resampled_scene(self, new_scn, destination_area, **resample_kwargs):
"""Resample `datasets` to the `destination` area."""
new_datasets = {}
datasets = list(new_scn.datasets.values())
max_area = None
if isinstance(destination_area, (str, six.text_type)):
destination_area = get_area_def(destination_area)
if hasattr(destination_area, 'freeze'):
try:
max_area = new_scn.max_area()
destination_area = destination_area.freeze(max_area)
except ValueError:
raise ValueError("No dataset areas available to freeze "
"DynamicAreaDefinition.")
resamplers = {}
for dataset, parent_dataset in dataset_walker(datasets):
ds_id = DatasetID.from_dict(dataset.attrs)
pres = None
if parent_dataset is not None:
pres = new_datasets[DatasetID.from_dict(parent_dataset.attrs)]
if ds_id in new_datasets:
replace_anc(dataset, pres)
continue
if dataset.attrs.get('area') is None:
if parent_dataset is None:
new_scn.datasets[ds_id] = dataset
else:
replace_anc(dataset, pres)
continue
LOG.debug("Resampling %s", ds_id)
source_area = dataset.attrs['area']
try:
slice_x, slice_y = source_area.get_area_slices(
destination_area)
source_area = source_area[slice_y, slice_x]
dataset = dataset.isel(x=slice_x, y=slice_y)
assert ('x', source_area.x_size) in dataset.sizes.items()
assert ('y', source_area.y_size) in dataset.sizes.items()
dataset.attrs['area'] = source_area
except NotImplementedError:
LOG.info("Not reducing data before resampling.")
if source_area not in resamplers:
key, resampler = prepare_resampler(source_area,
destination_area,
**resample_kwargs)
resamplers[source_area] = resampler
self.resamplers[key] = resampler
kwargs = resample_kwargs.copy()
kwargs['resampler'] = resamplers[source_area]
res = resample_dataset(dataset, destination_area, **kwargs)
new_datasets[ds_id] = res
if parent_dataset is None:
new_scn.datasets[ds_id] = res
else:
replace_anc(res, pres)
def test_3d_ewa(self, ll2cr, fornav):
"""Test EWA with a 3D dataset."""
import numpy as np
import xarray as xr
from satpy.resample import resample_dataset
_, _, swath_data, source_swath, target_area = get_test_data(
input_shape=(3, 200, 100), input_dims=('bands', 'y', 'x'))
swath_data.data = swath_data.data.astype(np.float32)
ll2cr.return_value = (100,
np.zeros((10, 10), dtype=np.float32),
np.zeros((10, 10), dtype=np.float32))
fornav.return_value = ([100 * 200] * 3,
[np.zeros((200, 100), dtype=np.float32)] * 3)
new_data = resample_dataset(swath_data, target_area, resampler='ewa')
self.assertTupleEqual(new_data.shape, (3, 200, 100))
self.assertEqual(new_data.dtype, np.float32)
self.assertEqual(new_data.attrs['test'], 'test')
self.assertIs(new_data.attrs['area'], target_area)
# make sure we can actually compute everything
new_data.compute()
previous_calls = ll2cr.call_count
# resample a different dataset and make sure cache is used
swath_data = xr.DataArray(
swath_data.data,
dims=('bands', 'y', 'x'), coords={'bands': ['R', 'G', 'B']},
attrs={'area': source_swath, 'test': 'test'})
new_data = resample_dataset(swath_data, target_area, resampler='ewa')
self.assertEqual(ll2cr.call_count, previous_calls)
new_data.compute()
self.assertIn('y', new_data.coords)
self.assertIn('x', new_data.coords)
self.assertIn('bands', 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')
np.testing.assert_equal(new_data.coords['bands'].values,
['R', 'G', 'B'])
