def test_chunks_are_larger_than_sizes(self):
cube1 = new_cube(variables=dict(chl=0.6, tsm=0.9, flags=16))
for var in cube1.variables.values():
self.assertIsNone(var.chunks)
rc = CubeRechunker()
cube2, gm, cc = rc.transform_cube(
cube1, GridMapping.from_dataset(cube1),
CubeConfig(chunks=dict(time=64, lat=512, lon=512)))
self.assertIsInstance(cube2, xr.Dataset)
self.assertIsInstance(gm, GridMapping)
self.assertIsInstance(cc, CubeConfig)
self.assertEqual(cube1.attrs, cube2.attrs)
self.assertEqual(set(cube1.coords), set(cube2.coords))
self.assertEqual(set(cube1.data_vars), set(cube2.data_vars))
for k, v in cube2.coords.items():
if v.chunks is not None:
self.assertIsInstance(v.chunks, tuple, msg=f'{k!r}={v!r}')
self.assertNotIn('chunks', v.encoding)
for k, v in cube2.data_vars.items():
self.assertIsInstance(v.chunks, tuple, msg=f'{k!r}={v!r}')
self.assertEqual(((5, ), (180, ), (360, )), v.chunks)
self.assertNotIn('chunks', v.encoding)
def test_rectify_2x2_to_13x13_output_ij_names(self):
source_ds = self.new_2x2_dataset_with_irregular_coords()
target_gm = GridMapping.regular(size=(13, 13),
xy_min=(-0.25, 49.75),
xy_res=0.5,
crs=CRS_WGS84)
target_ds = rectify_dataset(source_ds,
target_gm=target_gm,
output_ij_names=('source_i', 'source_j'))
lon, lat, rad, source_i, source_j = self._assert_shape_and_dim(
target_ds, (13, 13), var_names=('rad', 'source_i', 'source_j'))
np.testing.assert_almost_equal(
lon.values,
np.array([
0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5., 5.5, 6.
],
dtype=lon.dtype))
np.testing.assert_almost_equal(
lat.values,
np.array([
56., 55.5, 55., 54.5, 54., 53.5, 53., 52.5, 52., 51.5, 51.,
50.5, 50.
],
dtype=lat.dtype))
np.testing.assert_almost_equal(rad.values,
self.expected_rad_13x13(rad.dtype))
np.testing.assert_almost_equal(np.floor(source_i.values + 0.5),
self.expected_i_13x13())
np.testing.assert_almost_equal(np.floor(source_j.values + 0.5),
self.expected_j_13x13())
def test_chunks_are_smaller_than_sizes(self):
cube1 = new_cube(variables=dict(chl=0.6, tsm=0.9, flags=16))
for var in cube1.variables.values():
self.assertIsNone(var.chunks)
rc = CubeRechunker()
cube2, gm, cc = rc.transform_cube(
cube1, GridMapping.from_dataset(cube1),
CubeConfig(chunks=dict(time=2, lat=100, lon=200)))
self.assertIsInstance(cube2, xr.Dataset)
self.assertIsInstance(gm, GridMapping)
self.assertIsInstance(cc, CubeConfig)
self.assertEqual(cube1.attrs, cube2.attrs)
self.assertEqual({'time': 2, 'lat': 100, 'lon': 200}, cc.chunks)
self.assertEqual(set(cube1.coords), set(cube2.coords))
self.assertEqual(set(cube1.data_vars), set(cube2.data_vars))
for k, v in cube2.coords.items():
if v.chunks is not None:
self.assertIsInstance(v.chunks, tuple, msg=f'{k!r}={v!r}')
self.assertNotIn('chunks', v.encoding)
# self.assertIn('chunks', v.encoding)
# self.assertEqual([v.sizes[d] for d in v.dims],
# v.encoding['chunks'])
for k, v in cube2.data_vars.items():
self.assertIsInstance(v.chunks, tuple, msg=f'{k!r}={v!r}')
self.assertEqual(((2, 2, 1), (100, 80), (200, 160)), v.chunks)
self.assertNotIn('chunks', v.encoding)
def test_rectify_2x2_to_13x13_dask_13x3(self):
source_ds = self.new_2x2_dataset_with_irregular_coords()
target_gm = GridMapping.regular(size=(13, 13),
xy_min=(-0.25, 49.75),
xy_res=0.5,
crs=CRS_WGS84,
tile_size=(13, 3))
target_ds = rectify_dataset(source_ds, target_gm=target_gm)
lon, lat, rad = self._assert_shape_and_dim(target_ds, (13, 13),
chunks=((3, 3, 3, 3, 1),
(13, )))
np.testing.assert_almost_equal(
lon.values,
np.array([
0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5., 5.5, 6.
],
dtype=lon.dtype))
np.testing.assert_almost_equal(
lat.values,
np.array([
56., 55.5, 55., 54.5, 54., 53.5, 53., 52.5, 52., 51.5, 51.,
50.5, 50.
],
dtype=lat.dtype))
np.testing.assert_almost_equal(rad.values,
self.expected_rad_13x13(rad.dtype))
def test_rectify_2x2_to_13x13_antimeridian(self):
source_ds = self.new_2x2_dataset_with_irregular_coords_antimeridian()
target_gm = GridMapping.regular(size=(13, 13),
xy_min=(177.75, 49.75),
xy_res=0.5,
crs=CRS_WGS84)
self.assertEqual(True, target_gm.is_lon_360)
target_ds = rectify_dataset(source_ds, target_gm=target_gm)
self.assertIsNotNone(target_ds)
lon, lat, rad = self._assert_shape_and_dim(target_ds, (13, 13))
np.testing.assert_almost_equal(
lon.values,
np.array([
178., 178.5, 179., 179.5, 180., -179.5, -179., -178.5, -178.,
-177.5, -177., -176.5, -176.
],
dtype=lon.dtype))
np.testing.assert_almost_equal(
lat.values,
np.array([
56., 55.5, 55., 54.5, 54., 53.5, 53., 52.5, 52., 51.5, 51.,
50.5, 50.
],
dtype=lat.dtype))
np.testing.assert_almost_equal(rad.values,
self.expected_rad_13x13(rad.dtype))
def test_from_regular_cube_with_crs(self):
dataset = xcube.core.new.new_cube(variables=dict(rad=0.5),
x_start=0,
y_start=0,
x_name='x',
y_name='y',
crs='epsg:25832')
gm1 = GridMapping.from_dataset(dataset)
self.assertEqual(pyproj.CRS.from_string('epsg:25832'), gm1.crs)
dataset = dataset.drop_vars('crs')
gm2 = GridMapping.from_dataset(dataset)
self.assertEqual(GEO_CRS, gm2.crs)
gm3 = GridMapping.from_dataset(dataset, crs=gm1.crs)
self.assertEqual(gm1.crs, gm3.crs)
self.assertEqual(('x', 'y'), gm3.xy_var_names)
self.assertEqual(('x', 'y'), gm3.xy_dim_names)
def test_tile_grid(self):
gm = GridMapping.regular((7200, 3600),
(-180, -90),
360 / 7200,
'epsg:4326',
tile_size=(720, 360),
is_j_axis_up=True)
tile_grid = gm.tile_grid
self.assertIsInstance(tile_grid, TileGrid)
self.assertEqual([(1, 1),
(2, 2),
(3, 3),
(5, 5),
(10, 10)],
[tile_grid.get_num_tiles(i)
for i in range(tile_grid.num_levels)])
self.assertEqual([(450, 225),
(900, 450),
(1800, 900),
(3600, 1800),
(7200, 3600)],
[tile_grid.get_image_size(i)
for i in range(tile_grid.num_levels)])
self.assertEqual([0.8,
0.4,
0.2,
0.1,
0.05],
[tile_grid.get_resolution(i)
for i in range(tile_grid.num_levels)])
def _new_xy_coords(self) -> xr.DataArray:
return GridMapping.regular(size=self.size,
tile_size=self.tile_size,
is_j_axis_up=self.is_j_axis_up,
xy_res=self.xy_res,
xy_min=(self.xy_bbox[0], self.xy_bbox[1]),
crs=self.crs).xy_coords
def test_rectify_2x2_to_7x7_subset(self):
source_ds = self.new_2x2_dataset_with_irregular_coords()
target_gm = GridMapping.regular(size=(7, 7),
xy_min=(1.5, 50.5),
xy_res=1.0,
crs=CRS_WGS84)
target_ds = rectify_dataset(source_ds, target_gm=target_gm)
lon, lat, rad = self._assert_shape_and_dim(target_ds, (7, 7))
np.testing.assert_almost_equal(
lon.values,
np.array([2.0, 3.0, 4.0, 5., 6., 7., 8.], dtype=lon.dtype))
np.testing.assert_almost_equal(
lat.values,
np.array([57., 56., 55., 54., 53., 52., 51.], dtype=lat.dtype))
np.testing.assert_almost_equal(
rad.values,
np.array([
[nan, nan, nan, nan, nan, nan, nan],
[nan, nan, nan, nan, nan, nan, nan],
[1.0, nan, nan, nan, nan, nan, nan],
[1.0, 1.0, 2.0, nan, nan, nan, nan],
[3.0, 1.0, 2.0, 2.0, 2.0, nan, nan],
[3.0, 4.0, 2.0, nan, nan, nan, nan],
[4.0, 4.0, nan, nan, nan, nan, nan],
],
dtype=rad.dtype))
def transform_cube(self,
cube: xr.Dataset,
gm: GridMapping,
cube_config: CubeConfig) -> TransformedCube:
desired_var_names = cube_config.variable_names
if desired_var_names:
cube = select_variables_subset(cube,
var_names=desired_var_names)
cube_config = cube_config.drop_props('variable_names')
desired_bbox = cube_config.bbox
if desired_bbox is not None:
# Find out whether its possible to make a spatial subset
# without resampling. First, grid mapping must be regular.
can_do_spatial_subset = False
if gm.is_regular:
can_do_spatial_subset = True
# Current spatial resolution must be the
# desired spatial resolution, otherwise spatial resampling
# is required later, which will include the desired
# subsetting.
desired_res = cube_config.spatial_res
if desired_res is not None \
and not (math.isclose(gm.x_res, desired_res)
and math.isclose(gm.y_res, desired_res)):
can_do_spatial_subset = False
if can_do_spatial_subset:
# Finally, the desired CRS must be equal to the current
# one, or they must both be geographic.
desired_crs = cube_config.crs
if desired_crs:
desired_crs = pyproj.CRS.from_string(desired_crs)
if desired_crs != gm.crs \
and not (desired_crs.is_geographic
and gm.crs.is_geographic):
can_do_spatial_subset = False
if can_do_spatial_subset:
cube = select_spatial_subset(cube,
xy_bbox=desired_bbox)
# Now that we have a new cube subset, we must adjust
# its grid mapping.
gm = GridMapping.from_dataset(
cube,
crs=gm.crs,
xy_var_names=gm.xy_var_names,
)
# Consume spatial properties
cube_config = cube_config.drop_props(['bbox',
'spatial_res',
'crs'])
desired_time_range = cube_config.time_range
if desired_time_range:
cube = select_temporal_subset(cube,
time_range=desired_time_range)
cube_config = cube_config.drop_props('time_range')
return cube, gm, cube_config
def test_rectify_dataset(self):
source_ds = create_s2plus_dataset()
expected_data = np.array([
[nan, nan, nan, nan, nan, nan, nan, nan, nan],
[
nan, 0.019001, 0.019001, 0.008999, 0.012001, 0.012001,
0.022999, nan, nan
],
[
nan, 0.021, 0.021, 0.009998, 0.009998, 0.008999, 0.022999, nan,
nan
],
[
nan, 0.022999, 0.022999, 0.007999, 0.007999, 0.008999,
0.023998, nan, nan
],
[nan, 0.022999, 0.022999, 0.007, 0.007, 0.009998, 0.021, nan, nan],
[nan, nan, nan, nan, nan, nan, nan, nan, nan]
])
source_gm = GridMapping.from_dataset(source_ds, prefer_crs=CRS_WGS84)
target_ds = rectify_dataset(source_ds,
source_gm=source_gm,
tile_size=None)
self.assertEqual(None, target_ds.rrs_665.chunks)
print(repr(target_ds.rrs_665.values))
np.testing.assert_almost_equal(target_ds.rrs_665.values,
expected_data,
decimal=3)
target_ds = rectify_dataset(source_ds,
source_gm=source_gm,
tile_size=5)
self.assertEqual(((5, 1), (5, 4)), target_ds.rrs_665.chunks)
np.testing.assert_almost_equal(target_ds.rrs_665.values,
expected_data,
decimal=3)
target_ds = rectify_dataset(source_ds,
source_gm=source_gm,
tile_size=None,
is_j_axis_up=True)
self.assertEqual(None, target_ds.rrs_665.chunks)
np.testing.assert_almost_equal(target_ds.rrs_665.values,
expected_data[::-1],
decimal=3)
target_ds = rectify_dataset(source_ds,
source_gm=source_gm,
tile_size=5,
is_j_axis_up=True)
self.assertEqual(((5, 1), (5, 4)), target_ds.rrs_665.chunks)
np.testing.assert_almost_equal(target_ds.rrs_665.values,
expected_data[::-1],
decimal=3)
def test_non_geographical_crs(self):
cube = new_cube(x_name='x',
y_name='y',
crs='epsg:25832',
variables=dict(a=1, b=2, c=3))
gm = GridMapping.from_dataset(cube)
dataset = encode_cube(cube, gm, xr.Dataset(dict(d=True)))
self.assertIsInstance(dataset, xr.Dataset)
self.assertEqual({'a', 'b', 'c', 'd', 'crs'}, set(dataset.data_vars))
def test_default_props(self):
gm = GridMapping.regular((1000, 1000), (10, 53), 0.01, CRS_WGS84)
self.assertEqual((1000, 1000), gm.size)
self.assertEqual((1000, 1000), gm.tile_size)
self.assertEqual(10, gm.x_min)
self.assertEqual(53, gm.y_min)
self.assertEqual((0.01, 0.01), gm.xy_res)
self.assertEqual(True, gm.is_regular)
self.assertEqual(False, gm.is_j_axis_up)
def test_easter_egg(self):
cube = new_cube()
md_adjuster = CubeMetadataAdjuster()
with self.assertRaises(ValueError) as cm:
md_adjuster.transform_cube(
cube, GridMapping.from_dataset(cube),
CubeConfig(metadata=dict(inverse_fine_structure_constant=136)))
self.assertEqual(('inverse_fine_structure_constant must be 137'
' or running in wrong universe', ),
cm.exception.args)
def test_geographical_crs(self):
cube = new_cube(variables=dict(a=1, b=2, c=3))
gm = GridMapping.from_dataset(cube)
dataset = encode_cube(cube, gm)
self.assertIs(cube, dataset)
dataset = encode_cube(cube, gm, xr.Dataset(dict(d=True)))
self.assertIsInstance(dataset, xr.Dataset)
self.assertEqual({'a', 'b', 'c', 'd'}, set(dataset.data_vars))
def test_derive(self):
gm = GridMapping.regular((1000, 1000), (10, 53), 0.01, CRS_WGS84)
self.assertEqual((1000, 1000), gm.size)
self.assertEqual((1000, 1000), gm.tile_size)
self.assertEqual(False, gm.is_j_axis_up)
derived_gm = gm.derive(tile_size=500, is_j_axis_up=True)
self.assertIsNot(gm, derived_gm)
self.assertIsInstance(derived_gm, RegularGridMapping)
self.assertEqual((1000, 1000), derived_gm.size)
self.assertEqual((500, 500), derived_gm.tile_size)
self.assertEqual(True, derived_gm.is_j_axis_up)
def test_1d_xy_coords(self):
gm = GridMapping.from_coords(
x_coords=xr.DataArray(np.linspace(1.5, 8.5, 8), dims='lon'),
y_coords=xr.DataArray(np.linspace(4.5, -4.5, 10), dims='lat'),
crs=GEO_CRS)
xy_coords = gm.xy_coords
self.assertIsInstance(xy_coords, xr.DataArray)
self.assertIs(xy_coords, gm.xy_coords)
self.assertEqual(('coord', 'lat', 'lon'), xy_coords.dims)
self.assertEqual((2, 10, 8), xy_coords.shape)
self.assertEqual(('lon', 'lat'), gm.xy_var_names)
self.assertEqual(('lon', 'lat'), gm.xy_dim_names)
def test_from_regular_cube(self):
dataset = xcube.core.new.new_cube(variables=dict(rad=0.5))
gm = GridMapping.from_dataset(dataset)
self.assertEqual((360, 180), gm.size)
self.assertEqual((360, 180), gm.tile_size)
self.assertEqual(GEO_CRS, gm.crs)
self.assertEqual((1, 1), gm.xy_res)
self.assertEqual(True, gm.is_regular)
self.assertEqual(False, gm.is_lon_360)
self.assertEqual(True, gm.is_j_axis_up)
self.assertEqual((2, 180, 360), gm.xy_coords.shape)
self.assertEqual(('coord', 'lat', 'lon'), gm.xy_coords.dims)
def _compute_target_grid_mapping(cube_config: CubeConfig,
source_gm: GridMapping) -> GridMapping:
# assert_true(source_gm.is_regular, 'source_gm must be regular')
target_crs = cube_config.crs
target_bbox = cube_config.bbox
target_spatial_res = cube_config.spatial_res
if target_crs is None \
and target_bbox is None \
and target_spatial_res is None:
# Nothing to do
if source_gm.is_regular:
return source_gm
return source_gm.to_regular(tile_size=cube_config.tile_size)
if target_spatial_res is not None:
xy_res = (target_spatial_res, target_spatial_res)
else:
xy_res = source_gm.xy_res
if target_bbox is not None:
x_res, y_res = xy_res
x_min, y_min, x_max, y_max = target_bbox
xy_min = x_min, y_min
size = round((x_max - x_min) / x_res), round((y_max - y_min) / y_res)
else:
xy_min = source_gm.x_min, source_gm.y_min
size = source_gm.size
if target_crs is not None:
crs = pyproj.crs.CRS.from_string(target_crs)
else:
crs = source_gm.crs
target_gm = GridMapping.regular(size=size,
xy_min=xy_min,
xy_res=xy_res,
crs=crs,
tile_size=source_gm.tile_size,
is_j_axis_up=source_gm.is_j_axis_up)
return target_gm.derive(xy_var_names=source_gm.xy_var_names,
xy_dim_names=source_gm.xy_dim_names)
def test_1d_lon_360(self):
gm = GridMapping.from_coords(
x_coords=xr.DataArray(np.linspace(177.5, 184.5, 8), dims='lon'),
y_coords=xr.DataArray(np.linspace(4.5, -4.5, 10), dims='lat'),
crs=GEO_CRS)
self.assertEqual((8, 10), gm.size)
self.assertEqual((8, 10), gm.tile_size)
self.assertEqual((1, 1), gm.xy_res)
self.assertEqual((177, -5, 185, 5), gm.xy_bbox)
self.assertEqual(GEO_CRS, gm.crs)
self.assertEqual(True, gm.is_regular)
self.assertEqual(False, gm.is_j_axis_up)
self.assertEqual(True, gm.is_lon_360)
def test_it(self):
cube = new_cube(variables=dict(a=0.5))
gm = GridMapping.from_dataset(cube)
cube_config = CubeConfig()
identity = CubeIdentity()
t_cube = identity.transform_cube(cube,
gm,
cube_config)
self.assertIsInstance(t_cube, tuple)
self.assertEqual(3, len(t_cube))
self.assertIs(cube, t_cube[0])
self.assertIs(gm, t_cube[1])
self.assertIs(cube_config, t_cube[2])
def assertCallableWorks(self, user_code_callable):
code_config = CodeConfig(_callable=user_code_callable,
callable_params=self.good_params)
executor = CubeUserCodeExecutor(code_config)
ds_input = new_cube(variables=dict(a=1))
ds_output, gm, cc = executor.transform_cube(
ds_input, GridMapping.from_dataset(ds_input), CubeConfig())
self.assertIsInstance(ds_output, xr.Dataset)
self.assertIsInstance(gm, GridMapping)
self.assertIsInstance(cc, CubeConfig)
self.assertIsNot(ds_output, ds_input)
self.assertIn('X', ds_output)
self.assertEqual(42, ds_output.X)
def test_transform_s2(self):
dataset = create_s2plus_dataset()
gm = GridMapping.from_dataset(dataset, prefer_is_regular=True)
# Assert we've picked the projected one which is regular
self.assertEqual("Projected CRS", gm.crs.type_name)
self.assertEqual(True, gm.is_regular)
gm_t = gm.transform(CRS_CRS84)
self.assertEqual(CRS_CRS84, gm_t.crs)
gm_t = gm.transform(CRS_WGS84)
self.assertEqual(CRS_WGS84, gm_t.crs)
def test_metadata_adjusted_geo_crs(self):
(x1, x2), (y1, y2) = (53, 54), (11, 12)
cube1 = new_cube(
width=1000,
height=1000,
variables=dict(chl=0.6, tsm=0.9, flags=16),
x_start=x1,
y_start=y1,
x_res=(x2 - x1) / 1000,
y_res=(x2 - x1) / 1000,
)
cube1.attrs = {}
md_adjuster = CubeMetadataAdjuster()
cube2, gm, cc = md_adjuster.transform_cube(
cube1, GridMapping.from_dataset(cube1),
CubeConfig(metadata=dict(title='S2L2A subset'),
variable_metadata=dict(
chl=dict(long_name='Chlorophyll'),
tsm=dict(long_name='Total suspended matter'),
flags=dict(long_name='Quality flags'),
)))
self.assertIsNot(cube1, cube2)
self.assertIsInstance(gm, GridMapping)
self.assertIsInstance(cc, CubeConfig)
date_created = cube2.attrs.pop('date_created', None)
self.assertIsInstance(date_created, str)
history = cube2.attrs.pop('history', None)
self.assertIsInstance(history, list)
self.assertEqual(
{
'Conventions': 'CF-1.7',
'title': 'S2L2A subset',
'geospatial_bounds_crs': 'CRS84',
'geospatial_bounds': 'POLYGON((53 11, 53 12,'
' 54 12, 54 11, 53 11))',
'geospatial_lat_max': 12,
'geospatial_lat_min': 11,
'geospatial_lat_resolution': 0.001,
'geospatial_lat_units': 'degrees_north',
'geospatial_lon_max': 54,
'geospatial_lon_min': 53,
'geospatial_lon_resolution': 0.001,
'geospatial_lon_units': 'degrees_east',
}, cube2.attrs)
self.assertEqual({'long_name': 'Chlorophyll'}, cube2.chl.attrs)
self.assertEqual({'long_name': 'Total suspended matter'},
cube2.tsm.attrs)
self.assertEqual({'long_name': 'Quality flags'}, cube2.flags.attrs)
def test_empty_cube(self):
cube = new_cube()
gm = GridMapping.from_dataset(cube)
cube_config = CubeConfig(tile_size=180)
t_cube = transform_cube((cube, gm, cube_config), MyTiler())
self.assertIsInstance(t_cube, tuple)
self.assertEqual(3, len(t_cube))
cube2, gm2, cc2 = t_cube
self.assertIs(cube, cube2)
self.assertIs(gm, gm2)
self.assertIs(cube_config, cc2)
self.assertEqual((180, 180), cc2.tile_size)
def test_non_empty_cube(self):
cube = new_cube(variables=dict(a=0.5))
gm = GridMapping.from_dataset(cube)
cube_config = CubeConfig(tile_size=180)
t_cube = transform_cube((cube, gm, cube_config), MyTiler())
self.assertIsInstance(t_cube, tuple)
self.assertEqual(3, len(t_cube))
cube2, gm2, cc2 = t_cube
self.assertIsNot(cube, cube2)
self.assertEqual(((5,), (180,), (180, 180)), cube2.a.chunks)
self.assertIs(gm, gm2)
self.assertEqual(None, cc2.tile_size)
def test_1d_x_irregular(self):
gm = GridMapping.from_coords(
x_coords=xr.DataArray([1.5, 2.5, 3.5, 4.5, 5.49, 6.5, 7.5, 8.5],
dims='lon'),
y_coords=xr.DataArray(np.linspace(4.5, -4.5, 10), dims='lat'),
crs=GEO_CRS)
self.assertEqual((8, 10), gm.size)
self.assertEqual((8, 10), gm.tile_size)
self.assertEqual((1, 1), gm.xy_res)
self.assertEqual((1, -5, 9, 5), gm.xy_bbox)
self.assertEqual(GEO_CRS, gm.crs)
self.assertEqual(False, gm.is_regular)
self.assertEqual(False, gm.is_j_axis_up)
self.assertEqual(False, gm.is_lon_360)
def _compute_ij_images_xarray_dask(src_geo_coding: GridMapping,
output_geom: GridMapping,
uv_delta: float) -> da.Array:
"""
Compute dask.array.Array destination image
with source pixel i,j coords from xarray.DataArray x,y sources.
"""
dst_width = output_geom.width
dst_height = output_geom.height
dst_tile_width = output_geom.tile_width
dst_tile_height = output_geom.tile_height
dst_var_shape = 2, dst_height, dst_width
dst_var_chunks = 2, dst_tile_height, dst_tile_width
dst_x_min, dst_y_min, dst_x_max, dst_y_max = output_geom.xy_bbox
dst_x_res, dst_y_res = output_geom.xy_res
dst_is_j_axis_up = output_geom.is_j_axis_up
# Compute an empirical xy_border as a function of the
# number of tiles, because the more tiles we have
# the smaller the destination xy-bboxes and the higher
# the risk to not find any source ij-bbox for a given xy-bbox.
# xy_border will not be larger than half of the
# coverage of a tile.
#
num_tiles_x = dst_width / dst_tile_width
num_tiles_y = dst_height / dst_tile_height
xy_border = min(
min(2 * num_tiles_x * output_geom.x_res,
2 * num_tiles_y * output_geom.y_res),
min(0.5 * (dst_x_max - dst_x_min), 0.5 * (dst_y_max - dst_y_min)))
dst_xy_bboxes = output_geom.xy_bboxes
src_ij_bboxes = src_geo_coding.ij_bboxes_from_xy_bboxes(
dst_xy_bboxes, xy_border=xy_border, ij_border=1)
return compute_array_from_func(
_compute_ij_images_xarray_dask_block,
dst_var_shape,
dst_var_chunks,
np.float64,
ctx_arg_names=[
'dtype',
'block_id',
'block_shape',
'block_slices',
],
args=(src_geo_coding.xy_coords, src_ij_bboxes, dst_x_min, dst_y_min,
dst_y_max, dst_x_res, dst_y_res, dst_is_j_axis_up, uv_delta),
name='ij_pixels')
def test_xy_bboxes(self):
gm = GridMapping.regular(size=(2000, 1000),
xy_min=(10.0, 20.0),
xy_res=0.1,
crs=NOT_A_GEO_CRS)
np.testing.assert_almost_equal(gm.xy_bboxes,
np.array([[10., 20., 210., 120.]],
dtype=np.float64))
gm = GridMapping.regular(size=(2000, 1000),
xy_min=(10.0, 20.0),
xy_res=0.1,
crs=NOT_A_GEO_CRS).derive(tile_size=500)
np.testing.assert_almost_equal(gm.xy_bboxes,
np.array([
[10., 70, 60, 120.],
[60., 70, 110, 120.],
[110., 70, 160, 120.],
[160., 70, 210, 120.],
[10., 20, 60, 70.],
[60., 20, 110, 70.],
[110., 20, 160, 70.],
[160., 20, 210, 70.]
], dtype=np.float64))
def test_ij_bboxes(self):
gm = GridMapping.regular(size=(2000, 1000),
xy_min=(10.0, 20.0),
xy_res=0.1,
crs=NOT_A_GEO_CRS)
np.testing.assert_almost_equal(gm.ij_bboxes,
np.array([[0, 0, 2000, 1000]],
dtype=np.int64))
gm = GridMapping.regular(size=(2000, 1000),
xy_min=(10.0, 20.0),
xy_res=0.1,
crs=NOT_A_GEO_CRS).derive(tile_size=500)
np.testing.assert_almost_equal(gm.ij_bboxes,
np.array([
[0, 0, 500, 500],
[500, 0, 1000, 500],
[1000, 0, 1500, 500],
[1500, 0, 2000, 500],
[0, 500, 500, 1000],
[500, 500, 1000, 1000],
[1000, 500, 1500, 1000],
[1500, 500, 2000, 1000]
], dtype=np.int64))
