def bqbars(values, colors, title, stake):
fig = plt.figure()
eo_bars = plt.bar(x_ticks, values, colors=colors)
plt.ylabel("Fraction (%)")
plt.xlabel(stake)
fig.title = title
return fig
def _make_plot(self):
plt.close(1)
margin = {'top': 25, 'bottom': 35, 'left': 35, 'right': 25}
fig_layout = {'height': '100%', 'width': '100%'}
self.I_fig = plt.figure(1,
title='Stokes I',
fig_margin=margin,
layout=fig_layout)
self.I_plot = plt.plot(self.u, self.I)
plt.xlabel("Δλ / ΔλD")
plt.close(2)
self.Q_fig = plt.figure(2,
title='Stokes Q',
fig_margin=margin,
layout=fig_layout)
self.Q_plot = plt.plot(self.u, self.Q)
plt.xlabel("Δλ / ΔλD")
plt.close(3)
self.U_fig = plt.figure(3,
title='Stokes U',
fig_margin=margin,
layout=fig_layout)
self.U_plot = plt.plot(self.u, self.U)
plt.xlabel("Δλ / ΔλD")
plt.close(4)
self.V_fig = plt.figure(4,
title='Stokes V',
fig_margin=margin,
layout=fig_layout)
self.V_plot = plt.plot(self.u, self.V)
plt.xlabel("Δλ / ΔλD")
def generate_group_bar(df, title="", scientific_notation=False):
fig = plt.figure(title=title)
bar_chart = plt.bar(
x=df.columns.values.tolist(),
y=df,
labels=df.index.values.tolist(),
display_legend=False,
type="grouped",
colors=chart_colors[:df.index.values.size],
)
if df.columns.name:
plt.xlabel(df.columns.name.rsplit(" ", 1)[0])
plt.ylim(0, np.amax(df.values))
if not scientific_notation:
fig.axes[1].tick_format = ".1f"
return fig
def _make_plot(self):
plt.close(1)
fig_margin = {'top': 25, 'bottom': 35, 'left': 35, 'right':25}
fig_layout = {'height': '100%', 'width': '100%' }
layout_args = {'fig_margin': fig_margin, 'layout': fig_layout,
'max_aspect_ratio': 1.618}
self.voigt_fig = plt.figure(1, title='Voigt profile', **layout_args)
self.voigt_plot = plt.plot(self.freq, self.h, scales={'y': LogScale()})
plt.xlabel("Δν / ΔνD")
plt.close(2)
self.abs_fig = plt.figure(2, title='(αᶜ + αˡ) / α₅₀₀', **layout_args)
self.abs_plot = plt.plot(self.freq, self.xq, scales={'y': LogScale()})
plt.xlabel("Δν / ΔνD")
plt.close(3)
self.int_fig = plt.figure(3, title='Intensity', **layout_args)
self.int_plot = plt.plot(self.freq, self.prof, scales={'y': LogScale()})
plt.xlabel("Δν / ΔνD")
plt.close(4)
self.source_fig = plt.figure(4, title='Source Function', **layout_args)
self.source_plot = plt.plot(np.log10(self.tau500), self.source_function,
scales={'y': LogScale()})
plt.xlabel("lg(τ₅₀₀)")
self.tau_labels = plt.label(['τᶜ = 1', 'τˡ = 1'], colors=['black'],
x=np.array([np.log10(self.tau500_cont),
np.log10(self.tau500_line)]),
y=np.array([self.source_function_cont,
self.source_function_line]),
y_offset=-25, align='middle')
self.tau_line_plot = plt.plot(np.array([np.log10(self.tau500_line),
np.log10(self.tau500_line)]),
np.array([self.source_function_line / 1.5,
self.source_function_line * 1.5]),
colors=['black'])
self.tau_cont_plot = plt.plot(np.array([np.log10(self.tau500_cont),
np.log10(self.tau500_cont)]),
np.array([self.source_function_cont / 1.5,
self.source_function_cont * 1.5]),
colors=['black'])
def feature_byProperty(features, xProperties, seriesProperty, **kwargs):
"""Generates a Chart from a set of features. Plots property values of one or more features.
Reference: https://developers.google.com/earth-engine/guides/charts_feature#uichartfeaturebyproperty
Args:
features (ee.FeatureCollection): The features to include in the chart.
xProperties (list | dict): One of (1) a list of properties to be plotted on the x-axis; or (2) a (property, label) dictionary specifying labels for properties to be used as values on the x-axis.
seriesProperty (str): The name of the property used to label each feature in the legend.
Raises:
Exception: If the provided xProperties is not a list or dict.
Exception: If the chart fails to create.
"""
try:
df = ee_to_df(features)
if isinstance(xProperties, list):
x_data = xProperties
y_data = df[xProperties].values
elif isinstance(xProperties, dict):
x_data = list(xProperties.values())
y_data = df[list(xProperties.keys())].values
else:
raise Exception("xProperties must be a list or dictionary.")
labels = list(df[seriesProperty])
if "ylim" in kwargs:
min_value = kwargs["ylim"][0]
max_value = kwargs["ylim"][1]
else:
min_value = y_data.min()
max_value = y_data.max()
max_value = max_value + 0.2 * (max_value - min_value)
if "title" not in kwargs:
title = ""
else:
title = kwargs["title"]
if "legend_location" not in kwargs:
legend_location = "top-left"
else:
legend_location = kwargs["legend_location"]
if "display_legend" not in kwargs:
display_legend = True
else:
display_legend = kwargs["display_legend"]
fig = plt.figure(
title=title,
legend_location=legend_location,
)
if "width" in kwargs:
fig.layout.width = kwargs["width"]
if "height" in kwargs:
fig.layout.height = kwargs["height"]
bar_chart = plt.bar(x=x_data,
y=y_data,
labels=labels,
display_legend=display_legend)
bar_chart.type = "grouped"
if "colors" in kwargs:
bar_chart.colors = kwargs["colors"]
if "xlabel" in kwargs:
plt.xlabel(kwargs["xlabel"])
if "ylabel" in kwargs:
plt.ylabel(kwargs["ylabel"])
plt.ylim(min_value, max_value)
if "xlabel" in kwargs and ("ylabel" in kwargs):
bar_chart.tooltip = Tooltip(
fields=["x", "y"], labels=[kwargs["xlabel"], kwargs["ylabel"]])
else:
bar_chart.tooltip = Tooltip(fields=["x", "y"])
plt.show()
except Exception as e:
raise Exception(e)
def feature_groups(features, xProperty, yProperty, seriesProperty, **kwargs):
"""Generates a Chart from a set of features.
Plots the value of one property for each feature.
Reference:
https://developers.google.com/earth-engine/guides/charts_feature#uichartfeaturegroups
Args:
features (ee.FeatureCollection): The feature collection to make a chart from.
xProperty (str): Features labeled by xProperty.
yProperty (str): Features labeled by yProperty.
seriesProperty (str): The property used to label each feature in the legend.
Raises:
Exception: Errors when creating the chart.
"""
try:
df = ee_to_df(features)
df[yProperty] = pd.to_numeric(df[yProperty])
unique_series_values = df[seriesProperty].unique().tolist()
new_column_names = []
for value in unique_series_values:
sample_filter = (df[seriesProperty] == value).map({
True: 1,
False: 0
})
column_name = str(yProperty) + "_" + str(value)
df[column_name] = df[yProperty] * sample_filter
new_column_names.append(column_name)
if "labels" in kwargs:
labels = kwargs["labels"]
else:
labels = [str(x) for x in unique_series_values]
if "ylim" in kwargs:
min_value = kwargs["ylim"][0]
max_value = kwargs["ylim"][1]
else:
min_value = df[yProperty].to_numpy().min()
max_value = df[yProperty].to_numpy().max()
max_value = max_value + 0.2 * (max_value - min_value)
if "title" not in kwargs:
title = ""
else:
title = kwargs["title"]
if "legend_location" not in kwargs:
legend_location = "top-left"
else:
legend_location = kwargs["legend_location"]
x_data = list(df[xProperty])
y_data = [df[x] for x in new_column_names]
plt.bar(x_data, y_data)
fig = plt.figure(
title=title,
legend_location=legend_location,
)
if "width" in kwargs:
fig.layout.width = kwargs["width"]
if "height" in kwargs:
fig.layout.height = kwargs["height"]
if "display_legend" not in kwargs:
display_legend = True
else:
display_legend = kwargs["display_legend"]
bar_chart = plt.bar(x_data,
y_data,
labels=labels,
display_legend=display_legend)
if "colors" in kwargs:
bar_chart.colors = kwargs["colors"]
if "xlabel" in kwargs:
plt.xlabel(kwargs["xlabel"])
if "ylabel" in kwargs:
plt.ylabel(kwargs["ylabel"])
plt.ylim(min_value, max_value)
if "xlabel" in kwargs and ("ylabel" in kwargs):
bar_chart.tooltip = Tooltip(
fields=["x", "y"], labels=[kwargs["xlabel"], kwargs["ylabel"]])
else:
bar_chart.tooltip = Tooltip(fields=["x", "y"])
plt.show()
except Exception as e:
raise Exception(e)
def feature_byFeature(features, xProperty, yProperties, **kwargs):
"""Generates a Chart from a set of features. Plots the value of one or more properties for each feature.
Reference: https://developers.google.com/earth-engine/guides/charts_feature#uichartfeaturebyfeature
Args:
features (ee.FeatureCollection): The feature collection to generate a chart from.
xProperty (str): Features labeled by xProperty.
yProperties (list): Values of yProperties.
Raises:
Exception: Errors when creating the chart.
"""
try:
df = ee_to_df(features)
if "ylim" in kwargs:
min_value = kwargs["ylim"][0]
max_value = kwargs["ylim"][1]
else:
min_value = df[yProperties].to_numpy().min()
max_value = df[yProperties].to_numpy().max()
max_value = max_value + 0.2 * (max_value - min_value)
if "title" not in kwargs:
title = ""
else:
title = kwargs["title"]
if "legend_location" not in kwargs:
legend_location = "top-left"
else:
legend_location = kwargs["legend_location"]
x_data = list(df[xProperty])
y_data = df[yProperties].values.T.tolist()
plt.bar(x_data, y_data)
fig = plt.figure(
title=title,
legend_location=legend_location,
)
if "width" in kwargs:
fig.layout.width = kwargs["width"]
if "height" in kwargs:
fig.layout.height = kwargs["height"]
if "labels" in kwargs:
labels = kwargs["labels"]
else:
labels = yProperties
if "display_legend" not in kwargs:
display_legend = True
else:
display_legend = kwargs["display_legend"]
bar_chart = plt.bar(x_data,
y_data,
labels=labels,
display_legend=display_legend)
bar_chart.type = "grouped"
if "colors" in kwargs:
bar_chart.colors = kwargs["colors"]
if "xlabel" in kwargs:
plt.xlabel(kwargs["xlabel"])
if "ylabel" in kwargs:
plt.ylabel(kwargs["ylabel"])
plt.ylim(min_value, max_value)
if "xlabel" in kwargs and ("ylabel" in kwargs):
bar_chart.tooltip = Tooltip(
fields=["x", "y"], labels=[kwargs["xlabel"], kwargs["ylabel"]])
else:
bar_chart.tooltip = Tooltip(fields=["x", "y"])
plt.show()
except Exception as e:
raise Exception(e)
def vue_do_aper_phot(self, *args, **kwargs):
if self._selected_data is None or self._selected_subset is None:
self.result_available = False
self.results = []
self.plot_available = False
self.radial_plot = ''
self.hub.broadcast(SnackbarMessage(
"No data for aperture photometry", color='error', sender=self))
return
data = self._selected_data
reg = self._selected_subset
try:
comp = data.get_component(data.main_components[0])
try:
bg = float(self.background_value)
except ValueError: # Clearer error message
raise ValueError('Missing or invalid background value')
comp_no_bg = comp.data - bg
# TODO: Use photutils when it supports astropy regions.
if not isinstance(reg, RectanglePixelRegion):
aper_mask = reg.to_mask(mode='exact')
else:
# TODO: https://github.com/astropy/regions/issues/404 (moot if we use photutils?)
aper_mask = reg.to_mask(mode='subpixels', subpixels=32)
npix = np.sum(aper_mask) * u.pix
img = aper_mask.get_values(comp_no_bg, mask=None)
aper_mask_stat = reg.to_mask(mode='center')
comp_no_bg_cutout = aper_mask_stat.cutout(comp_no_bg)
img_stat = aper_mask_stat.get_values(comp_no_bg, mask=None)
include_pixarea_fac = False
include_counts_fac = False
include_flux_scale = False
if comp.units:
img_unit = u.Unit(comp.units)
img = img * img_unit
img_stat = img_stat * img_unit
bg = bg * img_unit
comp_no_bg_cutout = comp_no_bg_cutout * img_unit
if u.sr in img_unit.bases: # TODO: Better way to detect surface brightness unit?
try:
pixarea = float(self.pixel_area)
except ValueError: # Clearer error message
raise ValueError('Missing or invalid pixel area')
if not np.allclose(pixarea, 0):
include_pixarea_fac = True
if img_unit != u.count:
try:
ctfac = float(self.counts_factor)
except ValueError: # Clearer error message
raise ValueError('Missing or invalid counts conversion factor')
if not np.allclose(ctfac, 0):
include_counts_fac = True
try:
flux_scale = float(self.flux_scaling)
except ValueError: # Clearer error message
raise ValueError('Missing or invalid flux scaling')
if not np.allclose(flux_scale, 0):
include_flux_scale = True
rawsum = np.nansum(img)
d = {'id': 1,
'xcenter': reg.center.x * u.pix,
'ycenter': reg.center.y * u.pix}
if data.coords is not None:
d['sky_center'] = data.coords.pixel_to_world(reg.center.x, reg.center.y)
else:
d['sky_center'] = None
d.update({'background': bg,
'npix': npix})
if include_pixarea_fac:
pixarea = pixarea * (u.arcsec * u.arcsec / u.pix)
pixarea_fac = npix * pixarea.to(u.sr / u.pix)
d.update({'aperture_sum': rawsum * pixarea_fac,
'pixarea_tot': pixarea_fac})
else:
d.update({'aperture_sum': rawsum,
'pixarea_tot': None})
if include_counts_fac:
ctfac = ctfac * (rawsum.unit / u.count)
sum_ct = rawsum / ctfac
d.update({'aperture_sum_counts': sum_ct,
'aperture_sum_counts_err': np.sqrt(sum_ct.value) * sum_ct.unit,
'counts_fac': ctfac})
else:
d.update({'aperture_sum_counts': None,
'aperture_sum_counts_err': None,
'counts_fac': None})
if include_flux_scale:
flux_scale = flux_scale * rawsum.unit
d.update({'aperture_sum_mag': -2.5 * np.log10(rawsum / flux_scale) * u.mag,
'flux_scaling': flux_scale})
else:
d.update({'aperture_sum_mag': None,
'flux_scaling': None})
# Extra stats beyond photutils.
d.update({'mean': np.nanmean(img_stat),
'stddev': np.nanstd(img_stat),
'median': np.nanmedian(img_stat),
'min': np.nanmin(img_stat),
'max': np.nanmax(img_stat),
'data_label': data.label,
'subset_label': reg.meta.get('label', ''),
'timestamp': Time(datetime.utcnow())})
# Attach to app for Python extraction.
if (not hasattr(self.app, '_aper_phot_results') or
not isinstance(self.app._aper_phot_results, QTable)):
self.app._aper_phot_results = _qtable_from_dict(d)
else:
try:
d['id'] = self.app._aper_phot_results['id'].max() + 1
self.app._aper_phot_results.add_row(d.values())
except Exception: # Discard incompatible QTable
d['id'] = 1
self.app._aper_phot_results = _qtable_from_dict(d)
# Radial profile
reg_bb = reg.bounding_box
reg_ogrid = np.ogrid[reg_bb.iymin:reg_bb.iymax, reg_bb.ixmin:reg_bb.ixmax]
radial_dx = reg_ogrid[1] - reg.center.x
radial_dy = reg_ogrid[0] - reg.center.y
radial_r = np.hypot(radial_dx, radial_dy).ravel() # pix
radial_img = comp_no_bg_cutout.ravel()
if comp.units:
y_data = radial_img.value
y_label = radial_img.unit.to_string()
else:
y_data = radial_img
y_label = 'Value'
bqplt.clear()
# NOTE: default margin in bqplot is 60 in all directions
fig = bqplt.figure(1, title='Radial profile from Subset center',
fig_margin={'top': 60, 'bottom': 60, 'left': 40, 'right': 10},
title_style={'font-size': '12px'}) # TODO: Jenn wants title at bottom. # noqa
bqplt.plot(radial_r, y_data, 'go', figure=fig, default_size=1)
bqplt.xlabel(label='pix', mark=fig.marks[-1], figure=fig)
bqplt.ylabel(label=y_label, mark=fig.marks[-1], figure=fig)
except Exception as e: # pragma: no cover
self.result_available = False
self.results = []
self.plot_available = False
self.radial_plot = ''
self.hub.broadcast(SnackbarMessage(
f"Aperture photometry failed: {repr(e)}", color='error', sender=self))
else:
# Parse results for GUI.
tmp = []
for key, x in d.items():
if key in ('id', 'data_label', 'subset_label', 'background', 'pixarea_tot',
'counts_fac', 'aperture_sum_counts_err', 'flux_scaling', 'timestamp'):
continue
if (isinstance(x, (int, float, u.Quantity)) and
key not in ('xcenter', 'ycenter', 'sky_center', 'npix',
'aperture_sum_counts')):
x = f'{x:.4e}'
tmp.append({'function': key, 'result': x})
elif key == 'sky_center' and x is not None:
tmp.append({'function': 'RA center', 'result': f'{x.ra.deg:.4f} deg'})
tmp.append({'function': 'Dec center', 'result': f'{x.dec.deg:.4f} deg'})
elif key in ('xcenter', 'ycenter', 'npix'):
x = f'{x:.1f}'
tmp.append({'function': key, 'result': x})
elif key == 'aperture_sum_counts' and x is not None:
x = f'{x:.4e} ({d["aperture_sum_counts_err"]:.4e})'
tmp.append({'function': key, 'result': x})
elif not isinstance(x, str):
x = str(x)
tmp.append({'function': key, 'result': x})
self.results = tmp
self.result_available = True
self.radial_plot = fig
self.bqplot_figs_resize = [fig]
self.plot_available = True
def submit_clicked(b):
with output_widget:
output_widget.clear_output()
print('Computing...')
Map.default_style = {'cursor': 'wait'}
try:
admin1_id = admin1_widget.value
admin2_id = admin2_widget.value
band1 = first_band.value
band2 = second_band.value
selected_year = year_widget.value
threshold = nd_threshold.value
bands = band_combo.value.split('/')
apply_fmask = fmask_widget.value
palette = nd_color.value
use_aoi = aoi_widget.value
download = download_widget.value
if use_aoi:
if Map.user_roi is not None:
roi = Map.user_roi
layer_name = 'User drawn AOI'
geom = roi
else:
output_widget.clear_output()
print('No user AOI could be found.')
return
else:
statefp = ee.Feature(states.filter(ee.Filter.eq('NAME', admin1_id)).first()).get('STATEFP')
roi = fc.filter(ee.Filter.And(ee.Filter.eq('NAME', admin2_id), ee.Filter.eq('STATEFP', statefp)))
layer_name = admin1_id + '-' + admin2_id
geom = roi.geometry()
Map.layers = Map.layers[:4]
Map.addLayer(ee.Image().paint(geom, 0, 2), {'palette': 'red'}, layer_name)
images = geemap.landsat_timeseries(roi=roi, start_year=1984, end_year=2020, start_date='01-01', end_date='12-31', apply_fmask=apply_fmask)
nd_images = images.map(lambda img: img.normalizedDifference([band1, band2]))
result_images = nd_images.map(lambda img: img.gt(threshold))
selected_image = ee.Image(images.toList(images.size()).get(selected_year - 1984))
selected_result_image = ee.Image(result_images.toList(result_images.size()).get(selected_year - 1984)).selfMask()
vis_params = {
'bands': bands,
'min': 0,
'max': 3000
}
Map.addLayer(selected_image, vis_params, 'Landsat ' + str(selected_year))
Map.addLayer(selected_result_image, {'palette': palette}, 'Result ' + str(selected_year))
def cal_area(img):
pixel_area = img.multiply(ee.Image.pixelArea()).divide(1e4)
img_area = pixel_area.reduceRegion(**{
'geometry': geom,
'reducer': ee.Reducer.sum(),
'scale': 1000,
'maxPixels': 1e12,
'bestEffort': True
})
return img.set({'area': img_area})
areas = result_images.map(cal_area)
stats = areas.aggregate_array('area').getInfo()
x = list(range(1984, 2021))
y = [item.get('nd') for item in stats]
fig = plt.figure(1)
fig.layout.height = '270px'
plt.clear()
plt.plot(x, y)
plt.title('Temporal trend (1984-2020)')
plt.xlabel('Year')
plt.ylabel('Area (ha)')
output_widget.clear_output()
plt.show()
if download:
out_dir = os.path.join(os.path.expanduser('~'), 'Downloads')
out_name = 'chart_' + geemap.random_string() + '.csv'
out_csv = os.path.join(out_dir, out_name)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
with open(out_csv, 'w') as f:
f.write('year, area (ha)\n')
for index, item in enumerate(x):
line = '{},{:.2f}\n'.format(item, y[index])
f.write(line)
link = geemap.create_download_link(
out_csv, title="Click here to download the chart data: ")
display(link)
except Exception as e:
print(e)
print('An error occurred during computation.')
Map.default_style = {'cursor': 'default'}
