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 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
wavelengths.min()) & (sensor_filter[0] <= wavelengths.max())
sensor_filter = sensor_filter[0][filter_mask], sensor_filter[
1][:, filter_mask]
#plot_items.clear() #Python 3.3 and later only
del plot_items[:]
add_sensor_filter_to_plot(sensor_filter)
show_plot()
# ## Build the fixed parameters structure
# For this demo, we use the default values for every all parameters not specified below. See the API documentation for the remaining parameters and their default values.
# In[90]:
fixed_parameters = sb.create_fixed_parameter_set(
wavelengths=wavelengths,
a_water=awater,
a_ph_star=aphy_star,
substrates=substrates,
)
# # Spatial run with multiple substrate pairs
# **The outline of the algorithm here is**:
# - Load the input data
# - Load the observed rrs raster with rasterio
# - Set the parameter bounds and initial values
# - Create the objective function object
# - Create a pixel result handler that does something with the pixel results from the parameter estimator
# - run the parameter estimator on the pixel range
# - Do something with the results. In this notebook we simply plot a few of them, but they could be saved to files or passed via messages to the coordinator process in a parallel run.
# ## A note on parallelism