def test_spectra_find_common_wavelengths_called_with_tuple():
one = ([1, 2, 3, 4, 5], [10, 20, 30, 40, 50])
two = ([2, 3, 4], [2, 3, 4])
mask_wavs = sbc.spectra_find_common_wavelengths(one[0], two[0])
mask_tuple = sbc.spectra_find_common_wavelengths(one, two)
assert np.allclose(mask_wavs, mask_tuple)
def test_mask_spectra_wavelengths_actual_data():
filename = resource_filename(sbc.__name__,
"tests/data/siop/aw_340_900_lw2002_1nm.csv")
# load_spectral_library returns a dictionary. Popitem simply extracts the
# only value. We don't care about the key in this instance.
one = sbc.load_spectral_library(filename).popitem()[1]
one_wavs, one_values = one[0], one[1]
assert one_wavs.min() == 340
assert one_wavs.max() == 901
filename = resource_filename(sbc.__name__,
"tests/data/siop/WL_aphy_1nm.hdr")
two = sbc.load_spectral_library(filename).popitem()[1]
two_wavs, two_values = two[0], two[1]
assert two_wavs.min() == 350
assert two_wavs.max() == 800
# generate the mask
mask = sbc.spectra_find_common_wavelengths(one, two)
assert len(mask) == len(two_wavs)
# mask the larger spectra to the smaller set of wavelengths
masked_wavs, masked_values = sbc.spectra_apply_wavelength_mask(one, mask)
assert masked_wavs.min() == mask[0]
assert masked_wavs.max() == mask[-1]
assert len(masked_wavs) == len(mask)
assert len(masked_values) == len(mask)
def test_spectra_find_common_wavelengths_4_spectra():
# build 4 fake spectra tuples (wavelengths, values)
a = ([1, 2, 3, 4, 5], [10, 20, 30, 40, 50])
b = ([2, 3, 4], [6, 13, 9])
c = ([3, 4, 5], [11, 42, 8])
d = ([1, 2, 3, 4], [19, 7, 73, 13])
mask = sbc.spectra_find_common_wavelengths(a, b, c, d)
assert len(mask) == 2
assert np.allclose(mask, [3, 4])
def test_mask_spectra_wavelengths():
one = (np.asarray([1, 2, 3, 4, 5]), np.asarray([10, 20, 30, 40, 50]))
two = (np.asarray([2, 3, 4]), np.asarray([2, 3, 4]))
mask = sbc.spectra_find_common_wavelengths(one, two)
masked_wavs, masked_values = sbc.spectra_apply_wavelength_mask(one, mask)
assert len(masked_wavs) == len(mask)
assert len(masked_values) == len(mask)
assert np.allclose(masked_wavs, [2, 3, 4])
assert np.allclose(masked_values, [20, 30, 40])
def input_prepare(siop, envmeta, image_info, error_name):
a_water = siop['a_water']
a_ph_star = siop['a_ph_star']
substrates = siop['substrates']
substrate_names = siop['substrate_names']
sensor_filter = image_info['sensor_filter']
observed_rrs_width = image_info['observed_rrs_width']
observed_rrs_height = image_info['observed_rrs_height']
nedr = image_info['nedr']
wavelengths = sbc.spectra_find_common_wavelengths(a_water, a_ph_star,
*substrates)
#TODO check not empty
#print('Common wavelength range: {0} - {1}'.format(min(wavelengths), max(wavelengths)))
#Use the common wavelengths to mask the inputs:
a_water = sbc.spectra_apply_wavelength_mask(a_water, wavelengths)
a_ph_star = sbc.spectra_apply_wavelength_mask(a_ph_star, wavelengths)
for i, substrate in enumerate(substrates):
substrates[i] = sbc.spectra_apply_wavelength_mask(
substrate, wavelengths)
print('awater: min: {0} max: {1}'.format(min(a_water[0]),
max(a_water[0])))
print('a_ph_star: min: {0} max: {1}'.format(min(a_ph_star[0]),
max(a_ph_star[0])))
for substrate_name, substrate in zip(substrate_names, substrates):
print('{0}: min: {1} max: {2}'.format(substrate_name,
min(substrate[0]),
max(substrate[0])))
"""Truncate the sensor filter to match the common wavelength range
It remains to be seen whether this is the best approach, but it works for this demo. An alternative approach would be to truncate the entire band for any band that falls outside the common wavelength range.
If this approach, or something based on it, is valid, then this should be moved into a sambuca_core function with appropriate unit tests."""
filter_mask = (sensor_filter[0] >=
wavelengths.min()) & (sensor_filter[0] <= wavelengths.max())
sensor_filter = sensor_filter[0][filter_mask], sensor_filter[
1][:, filter_mask]
fixed_parameters = sb.create_fixed_parameter_set(
wavelengths=wavelengths,
a_water=a_water,
a_ph_star=a_ph_star,
substrates=substrates,
sub1_frac=None,
sub2_frac=None,
sub3_frac=None,
chl=None,
cdom=None,
nap=None,
depth=None,
a_cdom_slope=siop['a_cdom_slope'],
a_nap_slope=siop['a_nap_slope'],
bb_ph_slope=siop['bb_ph_slope'],
bb_nap_slope=siop['bb_nap_slope'],
lambda0cdom=siop['lambda0cdom'],
lambda0nap=siop['lambda0nap'],
lambda0x=siop['lambda0x'],
x_ph_lambda0x=siop['x_ph_lambda0x'],
x_nap_lambda0x=siop['x_nap_lambda0x'],
a_cdom_lambda0cdom=siop['a_cdom_lambda0cdom'],
a_nap_lambda0nap=siop['a_nap_lambda0nap'],
bb_lambda_ref=siop['bb_lambda_ref'],
water_refractive_index=siop['water_refractive_index'],
theta_air=envmeta['theta_air'],
off_nadir=envmeta['off_nadir'],
q_factor=envmeta['q_factor'])
result_recorder = sb.ArrayResultWriter(observed_rrs_height,
observed_rrs_width, sensor_filter,
nedr, fixed_parameters)
error_dict = {
'alpha': sb.distance_alpha,
'alpha_f': sb.distance_alpha_f,
'lsq': sb.distance_lsq,
'f': sb.distance_f
}
objective = sb.SciPyObjective(
sensor_filter,
fixed_parameters,
error_function=error_dict[error_name.lower()],
nedr=nedr)
siop['a_water'] = a_water
siop['a_ph_star'] = a_ph_star
siop['substrates'] = substrates
siop['substrate_names'] = substrate_names
image_info['sensor_filter'] = sensor_filter
image_info['observed_rrs_width'] = observed_rrs_width
image_info['observed_rrs_height'] = observed_rrs_height
image_info['nedr'] = nedr
#print ('EXIT PREPARE')
return wavelengths, siop, image_info, fixed_parameters, result_recorder, objective
def sam_obs():
if __name__ == 'sen2coral2.obs':
print(
os.path.isfile(
'bioopti_data\\..\\sambuca\\reference\\wl_alos_data\\inputs\\WL_ALOS_R_0_sub120.img'
))
base_path = 'bioopti_data\\'
observed_rrs_base_path = base_path + '..\\sambuca\\reference\\wl_alos_data\\inputs\\'
observed_rrs_raster_path = join(observed_rrs_base_path,
'WL_ALOS_R_0_sub120.img')
sensor_filter_path = join(base_path, 'sensor_filters')
sensor_filter_name = 'ALOS'
substrate_path = join(base_path, 'Substrates')
substrate1_name = 'moreton_bay_speclib:white Sand'
substrate2_name = 'moreton_bay_speclib:brown Mud'
substrate3_name = 'moreton_bay_speclib:Syringodium isoetifolium'
substrate4_name = 'moreton_bay_speclib:brown algae'
substrate5_name = 'moreton_bay_speclib:green algae'
#substrate_names= ( substrate1_name, substrate2_name)
#substrate_names= ( substrate1_name, substrate2_name, substrate3_name)
#substrate_names= ( substrate1_name, substrate2_name, substrate3_name, substrate4_name)
substrate_names = (substrate1_name, substrate2_name, substrate3_name,
substrate4_name, substrate5_name)
aphy_star_path = join(base_path, 'SIOP/WL08_aphy_1nm.hdr')
aphy_star_name = 'wl08_aphy_1nm:WL08_aphy_star_mean_correct.csv:C2'
awater_path = join(base_path, 'SIOP/aw_350_900_lw2002_1nm.csv')
awater_name = 'aw_350_900_lw2002_1nm:a_water'
nedr_path = join(observed_rrs_base_path, 'WL_ALOS_NEDR_0_4bands.hdr')
sensor_filter_path = join(base_path, 'sensor_filters')
sensor_filter_name = 'ALOS'
observed_rrs_width = 0
observed_rrs_height = 0
observed_rrs = None
with rasterio.drivers():
with rasterio.open(observed_rrs_raster_path) as src:
print('Observed rrs file: ', observed_rrs_raster_path)
print('Width, height: ', src.width, src.height)
print('crs: ', src.crs)
print('affine: ', src.affine)
print('num bands: ', src.count)
print('band indicies: ', src.indexes)
observed_rrs_width = src.width
observed_rrs_height = src.height
observed_rrs = src.read()
all_substrates = sbc.load_all_spectral_libraries(substrate_path)
substrates = []
for substrate_name in substrate_names:
substrates.append(all_substrates[substrate_name])
# load all filters from the given directory
sensor_filters = sbc.load_sensor_filters(sensor_filter_path)
# We don't need to do this, but it lets us see the name of all loaded filters
sensor_filters.keys()
# retrieve the specified filter
sensor_filter = sensor_filters[sensor_filter_name]
#Plot the sensor filter:
#plot_items.clear() #Python 3.3 and later only
aphy_star = sbc.load_spectral_library(aphy_star_path)[aphy_star_name]
awater = sbc.load_spectral_library(awater_path)[awater_name]
nedr = sbc.load_spectral_library(
nedr_path, validate=False)['wl_alos_nedr_0_4bands:33']
nedr
wavelengths = sbc.spectra_find_common_wavelengths(
awater, aphy_star, *substrates)
print('Common wavelength range: {0} - {1}'.format(
min(wavelengths), max(wavelengths)))
#Use the common wavelengths to mask the inputs:
awater = sbc.spectra_apply_wavelength_mask(awater, wavelengths)
aphy_star = sbc.spectra_apply_wavelength_mask(aphy_star, wavelengths)
for i, substrate in enumerate(substrates):
substrates[i] = sbc.spectra_apply_wavelength_mask(
substrate, wavelengths)
print('awater: min: {0} max: {1}'.format(min(awater[0]),
max(awater[0])))
print('aphy_star: min: {0} max: {1}'.format(min(aphy_star[0]),
max(aphy_star[0])))
for substrate_name, substrate in zip(substrate_names, substrates):
print('{0}: min: {1} max: {2}'.format(substrate_name,
min(substrate[0]),
max(substrate[0])))
"""Truncate the sensor filter to match the common wavelength range
It remains to be seen whether this is the best approach, but it works for this demo. An alternative approach would be to truncate the entire band for any band that falls outside the common wavelength range.
If this approach, or something based on it, is valid, then this should be moved into a sambuca_core function with appropriate unit tests."""
filter_mask = (sensor_filter[0] >= wavelengths.min()) & (
sensor_filter[0] <= wavelengths.max())
sensor_filter = sensor_filter[0][filter_mask], sensor_filter[
1][:, filter_mask]
xstart = 0
xend = 10
xspan = xend - xstart
ystart = 0
yend = 120
print('CIAO ', xstart)
num_pixels = xspan * (yend - ystart)
assert xend <= observed_rrs_width
assert yend <= observed_rrs_height
fixed_parameters = sb.create_fixed_parameter_set(
wavelengths=wavelengths,
a_water=awater,
a_ph_star=aphy_star,
substrates=substrates,
)
result_recorder = sb.ArrayResultWriter(observed_rrs_width,
observed_rrs_height,
sensor_filter, nedr,
fixed_parameters)
objective = sb.SciPyObjective(sensor_filter,
fixed_parameters,
error_function=sb.distance_f,
nedr=nedr)
return wavelengths, observed_rrs, observed_rrs_width, observed_rrs_height, awater, aphy_star, substrates, nedr, sensor_filter, xstart, xend, ystart, yend, num_pixels, fixed_parameters, result_recorder, objective
def test_spectra_find_common_wavelengths():
one = ([1, 2, 3, 4, 5], [10, 20, 30, 40, 50])
two = ([2, 3, 4], [2, 3, 4])
mask = sbc.spectra_find_common_wavelengths(one[0], two[0])
assert len(mask) == 3
assert np.allclose(mask, [2, 3, 4])
def test_spectra_find_common_wavelengths_no_args():
with pytest.raises(ValueError):
sbc.spectra_find_common_wavelengths()
def test_spectra_find_common_wavelengths_no_intersection_returns_empty_array():
a = ([1, 2, 3, 4, 5], [10, 20, 30, 40, 50])
b = ([25, 26, 27], [6, 13, 9])
c = ([26, 27, 28], [11, 42, 8])
mask = sbc.spectra_find_common_wavelengths(a, b, c)
assert len(mask) == 0
# ## Find the Common Wavelengths Subset
# In[86]:
print('awater: min: {0} max: {1}'.format(min(awater[0]), max(awater[0])))
print('aphy_star: min: {0} max: {1}'.format(min(aphy_star[0]),
max(aphy_star[0])))
for substrate_name, substrate in zip(substrate_names, substrates):
print('{0}: min: {1} max: {2}'.format(substrate_name,
min(substrate[0]),
max(substrate[0])))
# In[87]:
wavelengths = sbc.spectra_find_common_wavelengths(awater, aphy_star,
*substrates)
print('Common wavelength range: {0} - {1}'.format(min(wavelengths),
max(wavelengths)))
# Use the common wavelengths to mask the inputs:
# In[88]:
awater = sbc.spectra_apply_wavelength_mask(awater, wavelengths)
aphy_star = sbc.spectra_apply_wavelength_mask(aphy_star, wavelengths)
for i, substrate in enumerate(substrates):
substrates[i] = sbc.spectra_apply_wavelength_mask(
substrate, wavelengths)
print('awater: min: {0} max: {1}'.format(min(awater[0]), max(awater[0])))
print('aphy_star: min: {0} max: {1}'.format(min(aphy_star[0]),
