def test_open_rasterio_mask_chunk_clip():
with rioxarray.open_rasterio(
os.path.join(TEST_COMPARE_DATA_DIR, "small_dem_3m_merged.tif"),
masked=True,
chunks=True,
default_name="dem",
) as xdi:
assert xdi.name == "dem"
assert str(xdi.dtype) == "float64"
assert str(xdi.data.dtype) == "float64"
assert str(type(xdi.data)) == "<class 'dask.array.core.Array'>"
assert xdi.chunks == ((1, ), (245, ), (574, ))
assert np.isnan(xdi.values).sum() == 52119
test_encoding = dict(xdi.encoding)
assert test_encoding.pop("source").endswith("small_dem_3m_merged.tif")
assert test_encoding == {"_FillValue": 0.0}
attrs = dict(xdi.attrs)
assert_almost_equal(
tuple(xdi.rio._cached_transform())[:6],
(3.0, 0.0, 425047.68381405267, 0.0, -3.0, 4615780.040546387),
)
assert attrs == {
"grid_mapping": "spatial_ref",
"add_offset": 0.0,
"scale_factor": 1.0,
}
# get subset for testing
subset = xdi.isel(x=slice(150, 160), y=slice(100, 150))
comp_subset = subset.isel(x=slice(1, None), y=slice(1, None))
# add transform for test
comp_subset.rio.write_transform()
geometries = [{
"type":
"Polygon",
"coordinates": [[
[subset.x.values[0], subset.y.values[-1]],
[subset.x.values[0], subset.y.values[0]],
[subset.x.values[-1], subset.y.values[0]],
[subset.x.values[-1], subset.y.values[-1]],
[subset.x.values[0], subset.y.values[-1]],
]],
}]
# test data array
clipped = xdi.rio.clip(geometries, comp_subset.rio.crs)
_assert_xarrays_equal(clipped, comp_subset)
test_encoding = dict(clipped.encoding)
assert test_encoding.pop("source").endswith("small_dem_3m_merged.tif")
assert test_encoding == {"_FillValue": 0.0}
# test dataset
clipped_ds = xdi.to_dataset(name="test_data").rio.clip(
geometries, subset.rio.crs)
comp_subset_ds = comp_subset.to_dataset(name="test_data")
_assert_xarrays_equal(clipped_ds, comp_subset_ds)
test_encoding = dict(clipped.encoding)
assert test_encoding.pop("source").endswith("small_dem_3m_merged.tif")
assert test_encoding == {"_FillValue": 0.0}
def test_reproject__no_nodata(modis_reproject):
mask_args = (dict(masked=False) if modis_reproject["open"].__name__
== "open_rasterio" else dict(mask_and_scale=False))
with modis_reproject["open"](modis_reproject["input"],
**mask_args) as mda, modis_reproject["open"](
modis_reproject["compare"],
**mask_args) as mdc:
orig_fill = _get_attr(mda, "_FillValue")
_del_attr(mda, "_FillValue")
_del_attr(mda, "nodata")
# reproject
mds_repr = mda.rio.reproject(modis_reproject["to_proj"])
# overwrite test dataset
# if isinstance(modis_reproject['open'], xarray.DataArray):
# mds_repr.to_netcdf(modis_reproject['compare'])
# replace -9999 with original _FillValue for testing
if hasattr(mds_repr, "variables"):
for var in mds_repr.rio.vars:
mds_repr[var].values[mds_repr[var].values == -9999] = orig_fill
else:
mds_repr.values[mds_repr.values == -9999] = orig_fill
_mod_attr(mdc, "_FillValue", val=-9999)
# test
_assert_xarrays_equal(mds_repr, mdc)
def test_interpolate_na_3d(interpolate_na_3d):
with xarray.open_dataset(
interpolate_na_3d["input"]) as mda, xarray.open_dataset(
interpolate_na_3d["compare"]) as mdc:
interpolated_ds = mda.rio.interpolate_na()
# test
_assert_xarrays_equal(interpolated_ds, mdc)
def test_reproject__masked(modis_reproject):
with modis_reproject["open"](
modis_reproject["input"]) as mda, modis_reproject["open"](
modis_reproject["compare"]) as mdc:
# reproject
mds_repr = mda.rio.reproject(modis_reproject["to_proj"])
# test
_assert_xarrays_equal(mds_repr, mdc)
def test_interpolate_na(interpolate_na):
mask_args = (dict(masked=False) if interpolate_na["open"].__name__
== "open_rasterio" else dict(mask_and_scale=False))
with interpolate_na["open"](interpolate_na["input"],
**mask_args) as mda, interpolate_na["open"](
interpolate_na["compare"],
**mask_args) as mdc:
interpolated_ds = mda.rio.interpolate_na()
# test
_assert_xarrays_equal(interpolated_ds, mdc)
def test_reproject(modis_reproject):
mask_args = (dict(masked=False) if modis_reproject["open"].__name__
== "open_rasterio" else dict(mask_and_scale=False))
with modis_reproject["open"](modis_reproject["input"],
**mask_args) as mda, modis_reproject["open"](
modis_reproject["compare"],
**mask_args) as mdc:
mds_repr = mda.rio.reproject(modis_reproject["to_proj"])
# test
_assert_xarrays_equal(mds_repr, mdc)
def test_geographic_resample_integer(request):
sentinel_2_geographic = os.path.join(TEST_INPUT_DATA_DIR,
"sentinel_2_L1C_geographic.nc")
sentinel_2_interp = os.path.join(TEST_COMPARE_DATA_DIR,
"sentinel_2_L1C_interpolate_na.nc")
with request.param(sentinel_2_geographic) as mda, request.param(
sentinel_2_interp) as mdc:
mds_interp = mda.rio.interpolate_na()
# mds_interp.to_netcdf(sentinel_2_interp)
# test
_assert_xarrays_equal(mds_interp, mdc)
def test_geographic_reproject(request):
sentinel_2_geographic = os.path.join(TEST_INPUT_DATA_DIR,
"sentinel_2_L1C_geographic.nc")
sentinel_2_utm = os.path.join(TEST_COMPARE_DATA_DIR,
"sentinel_2_L1C_utm.nc")
with request.param(sentinel_2_geographic) as mda, request.param(
sentinel_2_utm) as mdc:
mds_repr = mda.rio.reproject("+init=epsg:32721")
# mds_repr.to_netcdf(sentinel_2_utm)
# test
_assert_xarrays_equal(mds_repr, mdc)
def test_reproject_match__masked(modis_reproject_match):
mask_args = (dict(masked=True) if modis_reproject_match["open"].__name__
== "open_rasterio" else dict(mask_and_scale=True))
with modis_reproject_match["open"](
modis_reproject_match["input"],
**mask_args) as mda, modis_reproject_match["open"](
modis_reproject_match["compare"],
**mask_args) as mdc, xarray.open_dataarray(
modis_reproject_match["match"]) as mdm:
# reproject
mds_repr = mda.rio.reproject_match(mdm)
# test
_assert_xarrays_equal(mds_repr, mdc)
def test_reproject__no_transform(modis_reproject):
with modis_reproject["open"](
modis_reproject["input"]) as mda, modis_reproject["open"](
modis_reproject["compare"]) as mdc:
orig_trans = _get_attr(mda, "transform")
_del_attr(mda, "transform")
# reproject
mds_repr = mda.rio.reproject(modis_reproject["to_proj"])
# test
if hasattr(mds_repr, "variables"):
for var in mds_repr.rio.vars:
assert_array_equal(orig_trans, tuple(mda[var].rio.transform()))
else:
assert_array_equal(orig_trans, tuple(mda.rio.transform()))
_assert_xarrays_equal(mds_repr, mdc)
def test_clip_box(modis_clip):
with modis_clip["open"](modis_clip["input"]) as xdi, modis_clip["open"](
modis_clip["compare"]) as xdc:
clipped_ds = xdi.rio.clip_box(
minx=xdi.x[4].values,
miny=xdi.y[6].values,
maxx=xdi.x[6].values,
maxy=xdi.y[4].values,
)
if isinstance(xdc, xarray.Dataset):
xdc.attrs["creation_date"] = clipped_ds.attrs["creation_date"]
_assert_xarrays_equal(clipped_ds, xdc)
# make sure it safely writes to netcdf
clipped_ds.to_netcdf(modis_clip["output"])
def test_interpolate_na__nodata_filled(interpolate_na_filled):
mask_args = (dict(masked=False) if interpolate_na_filled["open"].__name__
== "open_rasterio" else dict(mask_and_scale=False))
with interpolate_na_filled["open"](
interpolate_na_filled["input"],
**mask_args) as mda, interpolate_na_filled["open"](
interpolate_na_filled["compare"], **mask_args) as mdc:
if hasattr(mda, "variables"):
for var in mda.rio.vars:
mda[var].values[mda[var].values == mda[var].rio.nodata] = 400
else:
mda.values[mda.values == mda.rio.nodata] = 400
interpolated_ds = mda.rio.interpolate_na()
# test
_assert_xarrays_equal(interpolated_ds, mdc)
def test_interpolate_na__all_nodata(interpolate_na_nan):
rio_opened = interpolate_na_nan["open"].__name__ == "open_rasterio"
mask_args = dict(masked=True) if rio_opened else dict(mask_and_scale=True)
with interpolate_na_nan["open"](
interpolate_na_nan["input"],
**mask_args) as mda, interpolate_na_nan["open"](
interpolate_na_nan["compare"], **mask_args) as mdc:
if hasattr(mda, "variables"):
for var in mda.rio.vars:
mda[var].values[~numpy.isnan(mda[var].values)] = numpy.nan
else:
mda.values[~numpy.isnan(mda.values)] = numpy.nan
interpolated_ds = mda.rio.interpolate_na()
if rio_opened and "__xarray_dataarray_variable__" in mdc:
mdc = mdc["__xarray_dataarray_variable__"]
mdc.attrs.pop("coordinates")
# test
_assert_xarrays_equal(interpolated_ds, mdc)
def test_reproject__grid_mapping(modis_reproject):
mask_args = (dict(masked=False) if modis_reproject["open"].__name__
== "open_rasterio" else dict(mask_and_scale=False))
with modis_reproject["open"](modis_reproject["input"],
**mask_args) as mda, modis_reproject["open"](
modis_reproject["compare"],
**mask_args) as mdc:
# remove 'crs' attribute and add grid mapping
mda.coords["spatial_ref"] = 0
mda.coords["spatial_ref"].attrs["spatial_ref"] = CRS.from_user_input(
_get_attr(mda, "crs")).wkt
_mod_attr(mda, "grid_mapping", val="spatial_ref")
_del_attr(mda, "crs")
mdc.coords["spatial_ref"] = 0
mdc.coords["spatial_ref"].attrs["spatial_ref"] = CRS.from_user_input(
_get_attr(mdc, "crs")).wkt
_mod_attr(mdc, "grid_mapping", val="spatial_ref")
_del_attr(mdc, "crs")
# reproject
mds_repr = mda.rio.reproject(modis_reproject["to_proj"])
# test
_assert_xarrays_equal(mds_repr, mdc)
def test_clip_geojson(request):
with request.param(
os.path.join(TEST_COMPARE_DATA_DIR,
"small_dem_3m_merged.tif")) as xdi:
# get subset for testing
subset = xdi.isel(x=slice(150, 160), y=slice(100, 150))
comp_subset = subset.isel(x=slice(1, None), y=slice(1, None))
# add transform for test
comp_subset.attrs["transform"] = tuple(
comp_subset.rio.transform(recalc=True))
# add grid mapping for test
comp_subset.rio.write_crs(subset.rio.crs, inplace=True)
# make sure nodata exists for test
comp_subset.attrs["_FillValue"] = comp_subset.rio.nodata
geometries = [{
"type":
"Polygon",
"coordinates": [[
[subset.x.values[0], subset.y.values[-1]],
[subset.x.values[0], subset.y.values[0]],
[subset.x.values[-1], subset.y.values[0]],
[subset.x.values[-1], subset.y.values[-1]],
[subset.x.values[0], subset.y.values[-1]],
]],
}]
# test data array
clipped = xdi.rio.clip(geometries, comp_subset.rio.crs)
_assert_xarrays_equal(clipped, comp_subset)
# test dataset
clipped_ds = xdi.to_dataset(name="test_data").rio.clip(
geometries, subset.rio.crs)
comp_subset_ds = comp_subset.to_dataset(name="test_data")
_assert_xarrays_equal(clipped_ds, comp_subset_ds)
def test_reproject_3d(request, modis_reproject_3d):
with request.param(modis_reproject_3d["input"]) as mda, request.param(
modis_reproject_3d["compare"]) as mdc:
mds_repr = mda.rio.reproject(modis_reproject_3d["to_proj"])
# test
_assert_xarrays_equal(mds_repr, mdc)
