def test_glintcorr_8():
"""
Ensure that GlintCorr will raise an Exception if
fmask information can't be found in odc-metadata.yaml
This will test GlintCorr.get_fmask_file()
"""
# load the odc_meta_file
meta_dict = load_yaml_file(odc_meta_file)
# change "oa_fmask" key
meta_dict["measurements"]["no_mask"] = meta_dict["measurements"].pop(
"oa_fmask")
# save to data_path where the bands exist. This file will be deleted
mod_meta_file = data_path / "ga_ls8c_aard_3-2-0_091086_MODIFIED.odc-metadata.yaml"
with open(mod_meta_file, "w") as ofid:
yaml.dump(meta_dict, ofid)
with pytest.raises(Exception) as excinfo:
deglint.GlintCorr(mod_meta_file, product)
assert "Unable to extract fmask" in str(excinfo)
# remove yaml
mod_meta_file.unlink()
def test_load_bands_10():
"""
test the outputs of load_bands()
"""
g = deglint.GlintCorr(odc_meta_file, product)
b2_file = g.band_list[g.band_ids.index("2")]
b3_file = g.band_list[g.band_ids.index("3")]
b4_file = g.band_list[g.band_ids.index("4")]
spectral_cube, meta = rio_funcs.load_bands(
[b2_file, b3_file, b4_file], g.scale_factor, False
)
assert isinstance(spectral_cube, np.ndarray)
assert isinstance(meta, dict)
assert isinstance(meta["crs"], CRS)
assert isinstance(meta["transform"], Affine)
assert spectral_cube.ndim == 3
assert spectral_cube.shape[0] == meta["count"]
assert spectral_cube.shape[1] == meta["height"]
assert spectral_cube.shape[2] == meta["width"]
assert spectral_cube.dtype == np.dtype(meta["dtype"])
for z in range(spectral_cube.shape[0]):
assert not np.all(spectral_cube[z, :, :] == meta["nodata"])
def test_empty_band(tmp_path):
"""
Ensure that hedley_2005() raises an Exception if
the VIS and NIR band only contain nodata pixels
"""
g = deglint.GlintCorr(odc_meta_file, sub_product)
hedley_dir = tmp_path / "HEDLEY"
hedley_dir.mkdir()
with pytest.raises(Exception) as excinfo:
g.hedley_2005(
vis_bands=["7"], # dummy band only contains nodata (-999)
corr_band="6",
roi_shpfile=shp_file,
odir=hedley_dir,
water_val=5,
plot=False,
)
assert "only contains a single value" in str(excinfo)
with pytest.raises(Exception) as excinfo:
g.hedley_2005(
vis_bands=["3"],
corr_band="7", # dummy band only contains nodata (-999)
roi_shpfile=shp_file,
odir=hedley_dir,
water_val=5,
plot=False,
)
assert "only contains a single value" in str(excinfo)
def test_load_bands_11():
"""
test that scaling actually occurs in load_bands()
"""
g = deglint.GlintCorr(odc_meta_file, product)
b2_file = g.band_list[g.band_ids.index("2")]
scaled_im, meta = rio_funcs.load_bands([b2_file], g.scale_factor, True)
unscaled_im, meta = rio_funcs.load_bands([b2_file], g.scale_factor, False)
scaled_im = np.array(scaled_im[0, :, :], copy=True, order="K")
unscaled_im = np.array(unscaled_im[0, :, :], copy=True, order="K", dtype=np.float32)
ix = (unscaled_im > 0) & (unscaled_im <= g.scale_factor)
ratio = unscaled_im[ix] / scaled_im[ix] # e.g. 834/0.0834 = 10,000
ratio_mean = ratio.mean()
range_about_mean = 100.0 * (ratio.max() - ratio.min()) / ratio_mean
# Due to rounding errors, associated with converting to np.float32
# during the scaling, we can't expect the ratio of all pixels to
# equal g.scale_factor. Hence test that the mean == g.scale_factor
# and that percentage range about the mean <= 0.0001.
# A value of 0.0001 for a scale_factor of 10,000 implies that:
# ratio.min() = 9999.99
# ratio.mean() = 10000.00
# ratio.max() = 10000.01
assert np.all(ratio_mean == g.scale_factor)
assert range_about_mean <= 0.0001
def test_mnir_image():
"""
Check that the generated deglinted band is nearly identical
to the expected deglinted band
"""
# Initiate the sunglint correction class
g = deglint.GlintCorr(odc_meta_file, sub_product)
# ---------------------- #
# NIR subtraction #
# ---------------------- #
mnir_xarrlist = g.glint_subtraction(
vis_bands=["3"],
corr_band="6",
water_val=5,
)
sungc_band = mnir_xarrlist[0].lmbadj_green.values # 3D array
# path to expected sunglint corrected output from NIR subtraction
exp_sungc_band = (
data_path / "MINUS_NIR" /
"ga_ls8c_lmbadj_3-2-0_091086_2014-11-06_final_band03-deglint-600m.tif")
# ensure that all valid sungint corrected pixels match expected
with rasterio.open(exp_sungc_band, "r") as exp_sungc_ds:
urd_band = urd(sungc_band[0, :, :], exp_sungc_ds.read(1),
exp_sungc_ds.nodata)
assert urd_band.max() < 0.001
def test_geom_same_dims(tmp_path):
"""
Ensure that the Cox and Munk module will raise an
Exception if a view-solar geometry band does not
have the same dimensions as the other bands.
"""
g = deglint.GlintCorr(odc_meta_file, sub_product)
cxmk_dir = tmp_path / "COX_MUNK"
cxmk_dir.mkdir()
# create a small view-zenith tiff
resmpl_tifs, rio_meta = create_halved_band(g.find_file("satellite_view"), cxmk_dir)
# cox_munk() should raise an Exception as vzen band does not
# have the same shape as the solar-zenith and relative-azimuth
# bands
with pytest.raises(Exception) as excinfo:
g.cox_munk(
vis_bands=["3"],
vzen_file=resmpl_tifs[0],
wind_speed=5,
water_val=5,
)
assert "Dimension mismatch" in str(excinfo)
def test_hedley_bands(tmp_path):
"""
Ensure that hedley_2005() raises an Exception if
the specifued vis_band_id and corr_band do not exist
"""
g = deglint.GlintCorr(odc_meta_file, sub_product)
hedley_dir = tmp_path / "HEDLEY"
hedley_dir.mkdir()
# check VIS band
with pytest.raises(Exception) as excinfo:
g.hedley_2005(
vis_bands=["20"], # this band doesn't exist
corr_band="6",
roi_shpfile=shp_file,
odir=hedley_dir,
water_val=5,
plot=False,
)
assert "is missing from bands" in str(excinfo)
# check NIR band
with pytest.raises(Exception) as excinfo:
g.hedley_2005(
vis_bands=["3"],
corr_band="20", # this band doesn't exist
roi_shpfile=shp_file,
odir=hedley_dir,
water_val=5,
plot=False,
)
assert "is missing from bands" in str(excinfo)
def test_resample_1():
"""
Ensures that rio_funcs.resample_bands() raises and Exception when:
* resample_spatial_res <= 0
* if save=True and odir=None
* if save=True and odir does not exist.
"""
g = deglint.GlintCorr(odc_meta_file, product)
b3_file = g.band_list[g.band_ids.index("3")]
with rasterio.open(b3_file, "r") as ds:
spatial_res = ds.transform.a
# ------------------------- #
# Raise Exception when #
# resample_spatial_res <= 0 #
# ------------------------- #
with pytest.raises(Exception) as excinfo:
rio_funcs.resample_bands(
bandlist=[b3_file],
resample_spatial_res=0,
resample_option=Resampling.nearest,
load=True,
save=False,
odir=None,
)
assert "resample_spatial_res must be > 0" in str(excinfo)
# ------------------------- #
# Raise Exception when #
# save=True and odir=None #
# ------------------------- #
with pytest.raises(Exception) as excinfo:
rio_funcs.resample_bands(
bandlist=[b3_file],
resample_spatial_res=3 * spatial_res,
resample_option=Resampling.nearest,
load=False,
save=True,
odir=None,
)
assert "save requested for resampled geotiff, but odir not specified" in str(excinfo)
# ------------------------------- #
# Raise Exception when #
# save=True & not odir.exists() #
# ------------------------------- #
non_path = Path("/freo/give/em/the/old/heave/ho")
with pytest.raises(Exception) as excinfo:
rio_funcs.resample_bands(
bandlist=[b3_file],
resample_spatial_res=3 * spatial_res,
resample_option=Resampling.nearest,
load=False,
save=True,
odir=non_path,
)
assert f"{non_path} does not exist" in str(excinfo)
def test_glintcorr_1(tmp_path):
"""
Ensure that GlintCorr will raise an Exception if
".odc-metadata.yaml" not in yaml basename
"""
random_yaml = tmp_path / "random.yaml"
with pytest.raises(Exception) as excinfo:
deglint.GlintCorr(random_yaml, product)
assert "is not a .odc-metadata.yaml" in str(excinfo)
def test_glintcorr_6():
"""
Ensure that GlintCorr will raise an Exception if
geotiffs associated with products that were not
packaged/indexed are requested. Here, lmbadj
products were packaged, however, lmbskyg bands
are requested.
This will test GlintCorr.get_band_list()
"""
with pytest.raises(Exception) as excinfo:
deglint.GlintCorr(odc_meta_file, "lmbskyg")
assert "Could not find any geotifs in" in str(excinfo)
def test_nodata_band():
"""
Ensure that the Cox and Munk module raises an
Exception if the input band only contains nodata
"""
g = deglint.GlintCorr(odc_meta_file, sub_product)
with pytest.raises(Exception) as excinfo:
g.cox_munk(
vis_bands=["7"], # dummy band only contains nodata (-999)
wind_speed=5,
water_val=5,
)
assert "only contains a single value" in str(excinfo)
def test_cxmk_bands():
"""
Ensure that the Cox and Munk module raises an
Exception if the specified vis_band_id does not exist
"""
g = deglint.GlintCorr(odc_meta_file, sub_product)
with pytest.raises(Exception) as excinfo:
g.cox_munk(
vis_bands=["20"], # this band id doesn't exist
wind_speed=5,
water_val=5,
)
assert "is missing from bands" in str(excinfo)
def test_windspeed_lt0():
"""
Ensure that the Cox and Munk module will raise an
Exception if the wind speed < 0 m/s
"""
g = deglint.GlintCorr(odc_meta_file, sub_product)
with pytest.raises(Exception) as excinfo:
g.cox_munk(
vis_bands=["3"],
wind_speed=-1,
water_val=5,
)
assert "wind_speed must be greater than 0 m/s" in str(excinfo)
def test_quicklook_gen(tmp_path):
"""
Test that the quicklook rgb is as expected
"""
dwnscale_factor = 3
g = deglint.GlintCorr(odc_meta_file, sub_product)
# generate a quicklook
rgb_im, rgb_meta = quicklook_rgb(
rgb_bandlist=g.rgb_bandlist,
scale_factor=g.scale_factor,
dwnscale_factor=dwnscale_factor,
)
rgb_shape = rgb_im.shape
assert isinstance(rgb_im, np.ndarray) is True
assert rgb_im.ndim == 3
assert rgb_shape[2] == 3
assert rgb_im.dtype == np.uint8
assert rgb_meta["band_1"] == "ga_ls8c_lmbadj_3-2-0_091086_2014-11-06_final_band04"
assert rgb_meta["band_2"] == "ga_ls8c_lmbadj_3-2-0_091086_2014-11-06_final_band03"
assert rgb_meta["band_3"] == "ga_ls8c_lmbadj_3-2-0_091086_2014-11-06_final_band02"
ix_b3 = g.band_ids.index("3")
# check that the downsampling procedure worked!
with rasterio.open(g.band_list[ix_b3], "r") as b3_ds:
b3_meta = b3_ds.meta.copy()
assert rgb_meta["height"] == b3_meta["height"] // dwnscale_factor
assert rgb_meta["width"] == b3_meta["width"] // dwnscale_factor
assert rgb_meta["transform"].b == b3_meta["transform"].b
assert rgb_meta["transform"].c == b3_meta["transform"].c
assert rgb_meta["transform"].d == b3_meta["transform"].d
assert rgb_meta["transform"].f == b3_meta["transform"].f
assert rgb_meta["transform"].a == b3_meta["transform"].a * dwnscale_factor
assert rgb_meta["transform"].e == b3_meta["transform"].e * dwnscale_factor
# check Exception is raised if dwnscale_factor < 1
with pytest.raises(ValueError) as excinfo:
quicklook_rgb(
rgb_bandlist=g.rgb_bandlist,
scale_factor=g.scale_factor,
dwnscale_factor=0.999,
)
assert "dwnscale_factor must be a float >= 1" in str(excinfo)
def test_resample_4(tmp_path):
"""
Ensures that the outputs from resample_bands() are as expected.
In this test, load=True and save=True, meaning that the output
values should be:
resmpl_ofiles: list, len=2
spectral_cube: np.ndarray
* ndim = 3 as a TWO bands is used.
* same dtype as input band
* dimensions 1/3 the size of input band
metad: dict
"""
g = deglint.GlintCorr(odc_meta_file, product)
downscale_factor = 3
b2_file = g.band_list[g.band_ids.index("2")]
b3_file = g.band_list[g.band_ids.index("3")]
with rasterio.open(b3_file, "r") as ds:
# in the test dataset, b2 and b3 have the same ds.meta
ini_meta = ds.meta.copy()
spatial_res = ini_meta["transform"].a
resmpl_dir = tmp_path / "resample_test"
resmpl_dir.mkdir()
resmpl_ofiles, resmpl_cube, resmpl_metad = rio_funcs.resample_bands(
bandlist=[b2_file, b3_file],
resample_spatial_res=downscale_factor * spatial_res,
resample_option=Resampling.nearest,
load=True,
save=True,
odir=resmpl_dir,
)
# check resmpl_ofiles
assert isinstance(resmpl_ofiles, list)
assert len(resmpl_ofiles) == 2
for resmpl_tiff in resmpl_ofiles:
assert isinstance(resmpl_tiff, Path)
assert resmpl_tiff.suffix == ".tif"
assert resmpl_tiff.exists()
check_resampled_array(resmpl_cube, resmpl_metad, ini_meta, downscale_factor)
check_resampled_metad(resmpl_cube, resmpl_metad, ini_meta)
def test_glint_images():
"""
Tes that the generated glint reflectance is nearly
identical to expected glint reflectance
"""
exp_glint_band = (
data_path
/ "COX_MUNK"
/ "ga_ls8c_lmbadj_3-2-0_091086_2014-11-06_final_cm_glint.tif"
)
# Initiate the sunglint correction class
g = deglint.GlintCorr(odc_meta_file, sub_product)
vzen_file = g.find_file("satellite_view")
szen_file = g.find_file("solar_zenith")
razi_file = g.find_file("relative_azimuth")
# load the required geometry images
vzen_im, vzen_meta = load_singleband(vzen_file)
szen_im, szen_meta = load_singleband(szen_file)
razi_im, razi_meta = load_singleband(razi_file)
cm_meta = vzen_meta.copy()
# cox and munk:
p_glint, p_fresnel = coxmunk_backend(
view_zenith=vzen_im,
solar_zenith=szen_im,
relative_azimuth=razi_im,
wind_speed=5,
return_fresnel=False,
)
# convert p_glint & p_fresnel from np.float32 to np.int16
p_nodata = cm_meta["nodata"] # this is np.nan
p_glint[p_glint != p_nodata] *= g.scale_factor
p_glint[p_glint == p_nodata] = -999.0
p_glint = np.array(p_glint, order="C", dtype=np.int16)
# ensure that all valid sungint corrected pixels match expected
with rasterio.open(exp_glint_band, "r") as eglint_ds:
urd_glint = urd(p_glint, eglint_ds.read(1), eglint_ds.nodata)
assert urd_glint.max() < 0.001
def test_glintcorr_7(tmp_path):
"""
Ensure that GlintCorr will raise an Exception if
the bands specified in .odc-metadata.yaml do not
exists.
This will test GlintCorr.get_band_list()
"""
# load the odc_meta_file
meta_dict = load_yaml_file(odc_meta_file)
# save to tmp_path where the bands won't exist
mod_meta_file = tmp_path / "ga_ls8c_aard_3-2-0_091086_MODIFIED.odc-metadata.yaml"
with open(mod_meta_file, "w") as ofid:
yaml.dump(meta_dict, ofid)
band2 = tmp_path / meta_dict["measurements"]["lmbadj_blue"]["path"]
with pytest.raises(Exception) as excinfo:
deglint.GlintCorr(mod_meta_file, product)
assert f"Error: {band2} does not exist." in str(excinfo)
def test_resample_5(tmp_path):
"""
Ensures that the outputs from resample_bands() are as expected.
In this test, load=False and save=True, meaning that the output
values should be:
resmpl_ofiles: list, len=2
spectral_cube: NoneType
metad: NoneType
"""
g = deglint.GlintCorr(odc_meta_file, product)
downscale_factor = 3
b2_file = g.band_list[g.band_ids.index("2")]
b3_file = g.band_list[g.band_ids.index("3")]
with rasterio.open(b3_file, "r") as ds:
# in the test dataset, b2 and b3 have the same ds.meta
spatial_res = ds.meta["transform"].a
resmpl_dir = tmp_path / "resample_test"
resmpl_dir.mkdir()
resmpl_ofiles, resmpl_cube, resmpl_metad = rio_funcs.resample_bands(
bandlist=[b2_file, b3_file],
resample_spatial_res=downscale_factor * spatial_res,
resample_option=Resampling.nearest,
load=False,
save=True,
odir=resmpl_dir,
)
# check resmpl_ofiles
assert isinstance(resmpl_ofiles, list)
assert len(resmpl_ofiles) == 2
for resmpl_tiff in resmpl_ofiles:
assert isinstance(resmpl_tiff, Path)
assert resmpl_tiff.suffix == ".tif"
assert resmpl_tiff.exists()
assert isinstance(resmpl_cube, type(None))
assert isinstance(resmpl_metad, type(None))
def test_glintcorr_4(tmp_path):
"""
Ensure that GlintCorr will raise an Exception if
the sensor in the .odc-metadata.yaml isn't supported.
This will test GlintCorr.check_sensor()
"""
# load the odc_meta_file
meta_dict = load_yaml_file(odc_meta_file)
# change sensor to something random
meta_dict["properties"]["eo:platform"] = "DESIS-999"
# save changes
mod_meta_file = tmp_path / "ga_ls8c_aard_3-2-0_091086_MODIFIED.odc-metadata.yaml"
with open(mod_meta_file, "w") as ofid:
yaml.dump(meta_dict, ofid)
with pytest.raises(Exception) as excinfo:
deglint.GlintCorr(mod_meta_file, product)
assert "Supported sensors are" in str(excinfo)
def test_resample_3():
"""
Ensures that the outputs from resample_bands() are as expected.
In this test, load=True and save=False, meaning that the output
values should be:
resmpl_ofiles: NoneType (as save=False)
spectral_cube: np.ndarray
* ndim = 3 as a TWO bands is used.
* same dtype as input band
* dimensions 1/3 the size of input band
metad: dict
"""
g = deglint.GlintCorr(odc_meta_file, product)
downscale_factor = 3
b2_file = g.band_list[g.band_ids.index("2")]
b3_file = g.band_list[g.band_ids.index("3")]
with rasterio.open(b3_file, "r") as ds:
# in the test dataset, b2 and b3 have the same ds.meta
ini_meta = ds.meta.copy()
spatial_res = ini_meta["transform"].a
resmpl_ofiles, resmpl_cube, resmpl_metad = rio_funcs.resample_bands(
bandlist=[b2_file, b3_file],
resample_spatial_res=downscale_factor * spatial_res,
resample_option=Resampling.nearest,
load=True,
save=False,
odir=None,
)
# check resmpl_ofiles
assert resmpl_ofiles is None
# check resampled output
check_resampled_array(resmpl_cube, resmpl_metad, ini_meta, downscale_factor)
# check the resampled metadata
check_resampled_metad(resmpl_cube, resmpl_metad, ini_meta)
def test_empty_inputs():
"""
Ensure that glint_subtraction() raises and Exception if
the VIS and NIR band only contain nodata pixels
"""
g = deglint.GlintCorr(odc_meta_file, sub_product)
with pytest.raises(Exception) as excinfo:
g.glint_subtraction(
vis_bands=["3"],
corr_band="7", # this dummy band only contains nodata
water_val=5,
)
assert "only contains a single value" in str(excinfo)
with pytest.raises(Exception) as excinfo:
g.glint_subtraction(
vis_bands=["7"], # this dummy band only contains nodata
corr_band="6",
water_val=5,
)
assert "only contains a single value" in str(excinfo)
def test_mnir_bands():
"""
Ensure that glint_subtraction() raises and Exception if
the specified vis_band_id/corr_band do not exist
"""
g = deglint.GlintCorr(odc_meta_file, sub_product)
with pytest.raises(Exception) as excinfo:
g.glint_subtraction(
vis_bands=["20"], # this band id doesn't exist
corr_band="6",
water_val=5,
)
assert "is missing from bands" in str(excinfo)
with pytest.raises(Exception) as excinfo:
g.glint_subtraction(
vis_bands=["3"],
corr_band="20", # this band id doesn't exist
water_val=5,
)
assert "is missing from bands" in str(excinfo)
def test_load_singleband_8():
"""
test load_singleband() function
"""
g = deglint.GlintCorr(odc_meta_file, product)
b3_file = g.band_list[g.band_ids.index("3")]
im, meta = rio_funcs.load_singleband(b3_file)
# check for consistency between im and it's metadata dict
assert isinstance(im, np.ndarray)
assert isinstance(meta, dict)
assert isinstance(meta["crs"], CRS)
assert isinstance(meta["transform"], Affine)
assert im.ndim == 2
assert im.shape[0] == meta["height"]
assert im.shape[1] == meta["width"]
assert im.dtype == np.dtype(meta["dtype"])
assert meta["count"] == 1
assert meta["driver"] == "GTiff"
assert meta["nodata"] == -999.0
assert not np.all(im == meta["nodata"])
def test_nodata_vzen(tmp_path):
"""
Ensure that the Cox and Munk module raises an
Exception if any of the solar-view geometry
band only contains nodata. We will test this
with the sensor view-zenith.
"""
g = deglint.GlintCorr(odc_meta_file, sub_product)
cxmk_dir = tmp_path / "COX_MUNK"
cxmk_dir.mkdir()
# create empty view-zenith tiff
dum_vzen = cxmk_dir / "ga_ls8c_oa_3-2-0_091086_2014-11-06_final_DUMMY_view-zenith.tif"
with rasterio.open(g.find_file("satellite_view"), "r") as vzen_ds:
kwargs = vzen_ds.meta.copy()
# write dummy geotiff
nrows = vzen_ds.height
ncols = vzen_ds.width
dtype = np.dtype(kwargs["dtype"])
nodata = kwargs["nodata"] # np.nan
arr = np.zeros([nrows, ncols], order="C", dtype=dtype)
arr[:] = nodata
with rasterio.open(dum_vzen, "w", **kwargs) as dst:
dst.write(arr, 1)
# specify dummy band
with pytest.raises(Exception) as excinfo:
g.cox_munk(
vis_bands=["3"],
vzen_file=dum_vzen, # dummy band only contains nodata (np.nan)
wind_speed=5,
water_val=5,
)
assert "only contains a single value" in str(excinfo)
def test_hedley_image(tmp_path):
"""
Test if the generated deglinted band is nearly identical
to expected deglinted band
"""
g = deglint.GlintCorr(odc_meta_file, sub_product)
hedley_dir = tmp_path / "HEDLEY"
hedley_dir.mkdir()
# ------------------ #
# Hedley et al. 2005 #
# ------------------ #
# deglint the vis bands using band 6
hedley_xarrlist = g.hedley_2005(
vis_bands=["3"],
corr_band="6",
roi_shpfile=shp_file,
odir=hedley_dir,
water_val=5,
plot=False,
)
sungc_band = hedley_xarrlist[0].lmbadj_green.values # 3D array
# path to expected sunglint corrected output from Hedley et al.
exp_sungc_band = (
data_path / "HEDLEY" /
"ga_ls8c_lmbadj_3-2-0_091086_2014-11-06_final_band03-deglint-600m.tif")
# ensure that all valid sungint corrected pixels match expected
with rasterio.open(exp_sungc_band, "r") as exp_sungc_ds:
urd_band = urd(sungc_band[0, :, :], exp_sungc_ds.read(1),
exp_sungc_ds.nodata)
assert urd_band.max() < 0.001
# plot=False. Ensure that no png was created in hedley_dir
png_list = list(hedley_dir.glob("Correlation_*_vs_*.png"))
assert len(png_list) == 0
def test_hedley_plot(tmp_path):
"""
Check if a correlation plot (png) is generated. The
contents of the png are not checked
"""
hedley_dir = tmp_path / "HEDLEY"
hedley_dir.mkdir()
g = deglint.GlintCorr(odc_meta_file, sub_product)
g.hedley_2005(
vis_bands=["3"],
corr_band="6",
roi_shpfile=shp_file,
odir=hedley_dir,
water_val=5,
plot=True, # a plot should be generated in hedley_dir
)
# The above function should have generated a png file in
# hedley_dir with the following naming convention Correlation_*_vs_*.png
png_list = list(hedley_dir.glob("Correlation_*_vs_*.png"))
assert len(png_list) == 1
def test_glintcorr_5(tmp_path):
"""
Ensure that GlintCorr will raise an Exception if
GlintCorr is unable to extract the overpass
datetime information from .odc-metadata.yaml
This will test GlintCorr.get_overpass_datetime()
"""
# load the odc_meta_file
meta_dict = load_yaml_file(odc_meta_file)
# change "datetime" key
meta_dict["properties"]["overpass_time"] = meta_dict["properties"].pop(
"datetime")
# save changes
mod_meta_file = tmp_path / "ga_ls8c_aard_3-2-0_091086_MODIFIED.odc-metadata.yaml"
with open(mod_meta_file, "w") as ofid:
yaml.dump(meta_dict, ofid)
with pytest.raises(Exception) as excinfo:
deglint.GlintCorr(mod_meta_file, product)
assert "Unable to extract overpass datetime" in str(excinfo)
def test_glintcorr_2(tmp_path):
"""
Ensure that GlintCorr will raise an Exception if
it couldn't find the "measurement" key in
.odc-metadata.yaml. The dictionary contained in
this key has the required band names.
This will test GlintCorr.get_meas_dict()
"""
# load the odc_meta_file
meta_dict = load_yaml_file(odc_meta_file)
# change "measurement" key
meta_dict["image_data"] = meta_dict.pop("measurements")
# save changes
mod_meta_file = tmp_path / "ga_ls8c_aard_3-2-0_091086_MODIFIED.odc-metadata.yaml"
with open(mod_meta_file, "w") as ofid:
yaml.dump(meta_dict, ofid)
with pytest.raises(Exception) as excinfo:
deglint.GlintCorr(mod_meta_file, product)
assert "neither image nor measurements keys were found in" in str(excinfo)
def test_fake_shp(tmp_path):
"""
Ensure that hedley_2005() raises an Exception if
the input shapefile isn't really a shapefile
"""
g = deglint.GlintCorr(odc_meta_file, sub_product)
hedley_dir = tmp_path / "HEDLEY"
hedley_dir.mkdir()
fake_shp = hedley_dir / "fake.shp"
with open(fake_shp, "w", encoding="utf-8") as fid:
fid.write("bogus_geometry")
with pytest.raises(Exception) as excinfo:
g.hedley_2005(
vis_bands=["3"],
corr_band="6",
roi_shpfile=fake_shp,
odir=hedley_dir,
water_val=5,
plot=False,
)
assert "not recognized as a supported file format" in str(excinfo)
def test_glintcorr_3(tmp_path):
"""
Ensure that GlintCorr will raise an Exception if
it can't find the sensor information from the
.odc-metadata.yaml.
This will test GlintCorr.get_sensor()
"""
# load the odc_meta_file
meta_dict = load_yaml_file(odc_meta_file)
# change "sensor" key
meta_dict["properties"]["sensor_info"] = meta_dict["properties"].pop(
"eo:platform")
# save changes
mod_meta_file = tmp_path / "ga_ls8c_aard_3-2-0_091086_MODIFIED.odc-metadata.yaml"
with open(mod_meta_file, "w") as ofid:
yaml.dump(meta_dict, ofid)
with pytest.raises(Exception) as excinfo:
deglint.GlintCorr(mod_meta_file, product)
assert "Unable to extract sensor name" in str(excinfo)
