def population():
xdr = FactorRange(factors=years)
ydr = DataRange1d()
plot = Plot(x_range=xdr,
y_range=ydr,
plot_width=600,
plot_height=150,
toolbar_location=None)
plot.add_layout(CategoricalAxis(major_label_orientation=pi / 4), 'below')
known = Line(x="x", y="y", line_color="violet", line_width=2)
known_glyph = plot.add_glyph(source_known, known)
predicted = Line(x="x",
y="y",
line_color="violet",
line_width=2,
line_dash="dashed")
predicted_glyph = plot.add_glyph(source_predicted, predicted)
legend = Legend(location="bottom_right",
items=[("known", [known_glyph]),
("predicted", [predicted_glyph])])
plot.add_layout(legend)
return plot
def population():
xdr = FactorRange(factors=years)
ydr = DataRange1d()
plot = Plot(title=None,
x_range=xdr,
y_range=ydr,
plot_width=800,
plot_height=200)
plot.add_layout(CategoricalAxis(major_label_orientation=pi / 4), 'below')
line_known = Line(x="x", y="y", line_color="violet", line_width=2)
line_known_glyph = plot.add_glyph(source_known, line_known)
line_predicted = Line(x="x",
y="y",
line_color="violet",
line_width=2,
line_dash="dashed")
line_predicted_glyph = plot.add_glyph(source_predicted, line_predicted)
plot.add_layout(
Legend(
location="bottom_right",
legends=[("known", [line_known_glyph]),
("predicted", [line_predicted_glyph])],
))
return plot
def test_line_rendering_with_selected_points(output_file_url, selenium,
screenshot):
plot = Plot(plot_height=400,
plot_width=400,
x_range=Range1d(0, 4),
y_range=Range1d(-1, 1))
x = [0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4]
y = [
0., 0.84147098, 0.90929743, 0.14112001, -0.7568025, -0.95892427,
-0.2794155, 0.6569866, 0.98935825
] # sin(2*x)
source = ColumnDataSource(data=dict(x=x, y=y))
plot.add_glyph(source, Circle(x='x', y='y'))
plot.add_glyph(source, Line(x='x', y='y'))
plot.add_tools(BoxSelectTool())
# Save the plot and start the test
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
# Perform selection and take screenshot
perform_box_selection(selenium, (0, 100), (400, 250))
screenshot.assert_is_valid()
def make_plot(title, xname, yname):
plot = Plot(x_range=xdr,
y_range=ydr,
width=400,
height=400,
background_fill_color='#efefef')
plot.title.text = title
xaxis = LinearAxis(axis_line_color=None)
plot.add_layout(xaxis, 'below')
yaxis = LinearAxis(axis_line_color=None)
plot.add_layout(yaxis, 'left')
plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker))
plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker))
line = Line(x='x', y='y', line_color="#666699", line_width=2)
plot.add_glyph(lines_source, line)
circle = Circle(x=xname,
y=yname,
size=12,
fill_color="#cc6633",
line_color="#cc6633",
fill_alpha=0.5)
plot.add_glyph(circles_source, circle)
return plot
def altitude_profile(data):
plot = Plot(plot_width=800, plot_height=400)
plot.title.text = "%s - Altitude Profile" % name
plot.y_range.range_padding = 0
xaxis = LinearAxis(axis_label="Distance (km)")
plot.add_layout(xaxis, 'below')
yaxis = LinearAxis(axis_label="Altitude (m)")
plot.add_layout(yaxis, 'left')
plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker)) # x grid
plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker)) # y grid
plot.add_tools(PanTool(), WheelZoomTool(), ResetTool())
X, Y = data.dist, data.alt
y0 = min(Y)
patches_source = ColumnDataSource(
dict(xs=[[X[i], X[i + 1], X[i + 1], X[i]] for i in range(len(X[:-1]))],
ys=[[y0, y0, Y[i + 1], Y[i]] for i in range(len(Y[:-1]))],
color=data.colors[:-1]))
patches = Patches(xs="xs", ys="ys", fill_color="color", line_color="color")
plot.add_glyph(patches_source, patches)
line_source = ColumnDataSource(dict(x=data.dist, y=data.alt))
line = Line(x='x', y='y', line_color="black", line_width=1)
plot.add_glyph(line_source, line)
return plot
def pages_queried_timeseries(df, plot_width=600, plot_height=200, rule='1T'):
ts = df[['url']].resample(rule, how='count').cumsum()
ts.index = ts.index.tz_convert(tzlocal())
#Bokeh=0.10.0 misencodes timestamps, so we have to shift by
ts.index = ts.index.shift(ts.index[0].utcoffset().total_seconds(), freq="S")
ts = pd.concat([ts[:1], ts]) # prepend 0-value for Line chart compat
ts.iloc[0]['url'] = 0
formatter = DatetimeTickFormatter(formats=DATETIME_FORMAT)
ticker = DatetimeTicker(desired_num_ticks=3)
source = ColumnDataSource(ts)
plot = Plot(plot_width=plot_width, plot_height=plot_height,
x_range=DataRange1d(range_padding=0.1),
y_range=DataRange1d(start=0),
**PLOT_FORMATS)
plot.add_glyph(
source,
Line(x='retrieved', y='url', **LINE_FORMATS)
)
plot.add_layout(
DatetimeAxis(axis_label="Date Retrieved", formatter=formatter,
ticker=ticker, **AXIS_FORMATS),
'below')
plot.add_layout(LinearAxis(axis_label="Total Pages", **AXIS_FORMATS), 'left')
return plot
def construct_line(source, value_string, line_color=BLUE):
xdr = Range1d(1990, 2013)
ydr = Range1d(0, 100)
line_plot = Plot(x_range=xdr,
y_range=ydr,
title="",
plot_width=250,
plot_height=150,
min_border_top=10,
min_border_left=50,
**PLOT_FORMATS)
xaxis = LinearAxis(SingleIntervalTicker(interval=50), **AXIS_FORMATS)
yaxis = LinearAxis(SingleIntervalTicker(interval=10), **AXIS_FORMATS)
line_plot.add_layout(xaxis, 'left')
line_plot.add_layout(yaxis, 'below')
line = Line(
x='year',
y=value_string,
line_width=5,
line_cap="round",
line_color=line_color,
)
line_plot.add_glyph(source, line)
return line_plot
def trail_map(data):
lon = (min(data.lon) + max(data.lon)) / 2
lat = (min(data.lat) + max(data.lat)) / 2
map_options = GMapOptions(lng=lon, lat=lat, zoom=13)
plot = GMapPlot(plot_width=800,
plot_height=800,
map_options=map_options,
api_key=API_KEY)
plot.title.text = "%s - Trail Map" % name
plot.x_range = Range1d()
plot.y_range = Range1d()
plot.add_tools(PanTool(), WheelZoomTool(), ResetTool())
line_source = ColumnDataSource(dict(x=data.lon, y=data.lat,
dist=data.dist))
line = Line(x="x", y="y", line_color="blue", line_width=2)
plot.add_glyph(line_source, line)
if plot.api_key == "GOOGLE_API_KEY":
plot.add_layout(
Label(x=240,
y=700,
x_units='screen',
y_units='screen',
text='Replace GOOGLE_API_KEY with your own key',
text_color='red'))
return plot
def plot(source):
fig = setup_figure()
# plot data
rect = Rect(x='dates',
y='y',
width='w',
height='h',
line_width=0,
fill_color='colors',
fill_alpha=1)
fig.add_glyph(source, rect)
line = Line(x='dates', y='avg_to_bed_times')
fig.add_glyph(source, line)
# circ = Circle(x='dates', y='avg_to_bed_times', size=3)
# fig.add_glyph(source, circ)
line = Line(x='dates', y='avg_get_up_times')
fig.add_glyph(source, line)
# circ = Circle(x='dates', y='avg_get_up_times', size=3)
# fig.add_glyph(source, circ)
# plot select
select = figure(
# background_fill_color='#333333'
title="",
plot_width=PLOT_WIDTH,
plot_height=80,
toolbar_location=None, # tools="xwheel_pan",
x_axis_type="datetime", # y_axis_type=None,
x_axis_location=None,
y_axis_location=None,
y_range=fig.y_range,
)
range_tool = RangeTool(x_range=fig.x_range)
select.add_tools(range_tool)
select.line(x=[dt(2013, 5, 1), dt.now()], y=[0, 0], color=None)
select.add_glyph(source, rect)
select.ygrid.grid_line_color = None
select.toolbar.active_multi = range_tool
select.yaxis.ticker = []
return fig, select
def add_lo_economic_growth_lines(plot, parameter):
sources, _ = get_lo_national_data(parameter)
line_renderers = {}
for scenario in scenarios:
source = sources[scenario]
line = Line(
x='t', y=parameter, line_color=scenarios_colors[scenario],
line_width=2, line_cap='round', line_join='round', line_dash='dashed'
)
line_renderer = plot.add_glyph(source, line)
line_renderers[scenario] = line_renderer
return (plot, line_renderers)
def get_y_module(self):
p2 = figure(title="Prediction Result",
tools=self.tools,
tooltips=self.tooltips,
plot_width=500,
plot_height=200)
p2 = self.get_attribute(p2)
c1 = p2.line('index',
self.y_pred_name,
legend_label="pred Y",
color="#C9C462",
name="pred Y",
source=self.source,
line_width=1.5)
c1.nonselection_glyph = Line(
line_color="#C9C462",
line_alpha=0.2) # when selected, change alpha
# c1.selection_glyph = Line(line_color="#C9C462", line_width=1.5)
c2 = p2.circle('index',
self.config['y_name'],
source=self.source,
name="real Y",
legend_label="real Y",
size=5,
color="#FF4040")
c2.nonselection_glyph = Circle(fill_color="#FF4040",
fill_alpha=0.2,
line_color=None,
size=5)
# c2.selection_glyph = Circle(fill_color='orange', line_color=None, size=10, line_width=15)
c2 = p2.circle('index',
self.y_pred_name,
source=self.source,
name="pred Y",
size=5,
color="#C9C462")
c2.nonselection_glyph = Circle(fill_color="#C9C462",
fill_alpha=0.2,
line_color=None,
size=5)
vline = Span(location=self.split_loc,
dimension='height',
line_color='seagreen',
line_width=3)
p2.add_layout(vline)
p2.legend.location = "top_left"
p2.legend.click_policy = "hide"
p2.legend.background_fill_alpha = 0.8
return p2
def large_plot(n):
from bokeh.models import (
Plot, LinearAxis, Grid, GlyphRenderer,
ColumnDataSource, DataRange1d, PanTool, ZoomInTool, ZoomOutTool, WheelZoomTool, BoxZoomTool,
BoxSelectTool, SaveTool, ResetTool
)
from bokeh.models import Column, Line
col = Column()
objects = set([col])
for i in range(n):
source = ColumnDataSource(data=dict(x=[0, i + 1], y=[0, i + 1]))
xdr = DataRange1d()
ydr = DataRange1d()
plot = Plot(x_range=xdr, y_range=ydr)
xaxis = LinearAxis()
plot.add_layout(xaxis, "below")
yaxis = LinearAxis()
plot.add_layout(yaxis, "left")
xgrid = Grid(dimension=0)
plot.add_layout(xgrid, "center")
ygrid = Grid(dimension=1)
plot.add_layout(ygrid, "center")
tickers = [xaxis.ticker, xaxis.formatter, yaxis.ticker, yaxis.formatter]
glyph = Line(x='x', y='y')
renderer = GlyphRenderer(data_source=source, glyph=glyph)
plot.renderers.append(renderer)
pan = PanTool()
zoom_in = ZoomInTool()
zoom_out = ZoomOutTool()
wheel_zoom = WheelZoomTool()
box_zoom = BoxZoomTool()
box_select = BoxSelectTool()
save = SaveTool()
reset = ResetTool()
tools = [pan, zoom_in, zoom_out, wheel_zoom, box_zoom, box_select, save, reset]
plot.add_tools(*tools)
col.children.append(plot)
objects |= set([
xdr, ydr,
xaxis, yaxis,
xgrid, ygrid,
renderer, renderer.view, glyph,
source, source.selected, source.selection_policy,
plot, plot.x_scale, plot.y_scale, plot.toolbar, plot.title,
box_zoom.overlay, box_select.overlay,
] + tickers + tools)
return col, objects
def __init__(self, stave, name, value, *args, **kwargs):
super().__init__(stave, name)
self.value = value
self.color = kwargs.setdefault('color', 'green')
self.width = kwargs.setdefault('width', 1)
self.dash = kwargs.setdefault('dash', 'solid')
self.kw_ = {
'name': self.name,
'line_color': self.color,
'line_width': self.width,
'line_dash': self.dash
}
self.line = Line(x='x', y='y', **self.kw_)
self.line_source = ColumnDataSource(data=dict(x=[], y=[]))
def _get_national_scenario_line_plot(sources, data, parameter=None, y_ticks=None, plot_width=600, grid=True, end_factor=None, y_range=None, include_bau=True):
if not y_range:
y_range = get_y_range(data)
plot = Plot(
x_range=get_year_range(end_factor),
y_range=y_range,
plot_width=plot_width,
**PLOT_FORMATS
)
plot = add_axes(plot, y_ticks, color=dark_grey, grid=grid)
hit_renderers = []
line_renderers = {}
if include_bau:
sc = scenarios
else:
sc = scenarios_no_bau
for scenario in sc:
source = sources[scenario]
line = Line(
x='t', y=parameter, line_color=scenarios_colors[scenario],
line_width=2, line_cap='round', line_join='round'
)
circle = Circle(
x='t', y=parameter, size=4,
line_color=scenarios_colors[scenario], line_width=0.5, line_alpha=deselected_alpha,
fill_color=scenarios_colors[scenario], fill_alpha=0.6
)
# invisible circle used for hovering
hit_target = Circle(
x='t', y=parameter, size=20,
line_color=None, fill_color=None
)
scenario_label = Text(
x=value(source.data['t'][-1] + 0.8), y=value(source.data[parameter][-1] * 0.98), text=value(names[scenario]),
text_color=scenarios_colors[scenario], text_font_size="8pt",
)
hit_renderer = plot.add_glyph(source, hit_target)
hit_renderers.append(hit_renderer)
line_renderer = plot.add_glyph(source, line)
line_renderers[scenario] = line_renderer
plot.add_glyph(source, circle)
plot.add_glyph(scenario_label)
plot.add_tools(HoverTool(tooltips="@%s{0,0} (@t)" % parameter, renderers=hit_renderers))
return (plot, line_renderers)
def set_glyphs(colors, column_names, column_time, plot, pos, source):
for i, name in enumerate(column_names):
color = colors[i]
line = Line(x=column_time,
y=name,
line_width=1,
line_alpha=.7,
line_color=color)
plot.add_layout(
LinearAxis(y_range_name=name,
major_label_text_color=color,
axis_line_color=color,
major_tick_line_color=color,
minor_tick_line_color=color), pos[i])
plot.add_glyph(source, line, y_range_name=name, name=name)
def get_pm25_national_plot(plot_width=600, end_factor=None, grid=True):
sources, data = get_pm25_national_data()
y_ticks = [30, 40, 50, 60, 70]
y_range = Range1d(30, 72)
pm25, line_renderers = _get_national_scenario_line_plot(
sources, data, 'PM25_exposure',
y_ticks=y_ticks, plot_width=plot_width, grid=grid, end_factor=end_factor, y_range=y_range
)
# Add Targets
pm25.add_glyph(
ColumnDataSource(data=dict(x=[2010, 2030], y=[35, 35])),
Line(x='x', y='y', line_width=2, line_dash='dotdash'),
)
pm25.add_glyph(
ColumnDataSource(data=dict(x=[2010.5], y=[32.5], text=['PM2.5 target'])),
Text(x='x', y='y', text='text', text_font_size='8pt'),
level='overlay',
)
return (pm25, line_renderers)
def st_plot_wind_pressure(self):
"""
Plot wind pressure along the sign face.
The value may change for 45 degrees and a large aspect ratio.
"""
#Set up plot
plot = Plot()
#Graph of Drag Factors along sign
x = np.linspace(0, self.sign_w, num=50)
if self.wind.loadcase is Cases.FAT:
y = [
0.5 * 1.2 * self.wind.V_sit_beta.value**2 * self.C_dyn / 1000 *
self.C_fig for ix in x
]
else:
y = [
0.5 * 1.2 * self.wind.V_sit_beta.value**2 *
self.C_dyn * self.K_p / 1000 * self.C_pn_func(
self.sign_w, self.sign_h, self.wind.Wind_mult.height, ix)
for ix in x
]
source = ColumnDataSource(dict(x=x, y=y))
drag_factor = Line(x='x', y='y', line_color="#f46d43", line_width=3)
plot.add_glyph(source, drag_factor)
#Fille area under line
fill_under = Band(base='x',
upper='y',
source=source,
level='underlay',
fill_color='#55FF88')
plot.add_layout(fill_under)
#Plot setup
plot.add_layout(LinearAxis(), 'below')
plot.add_layout(LinearAxis(), 'left')
plot.xaxis.axis_label = "Distance along sign (m)"
plot.yaxis.axis_label = "Wind Pressure (kPa)"
plot.y_range = Range1d(0, max(y) * 1.3)
return plot
def get_nonfossil(plot_width=750, end_factor=5, grid=True, include_bau=False):
plot, line_renderers = get_national_scenario_line_plot(
parameter='energy_nonfossil_share',
y_ticks=[10, 15, 20, 25],
plot_width=plot_width,
y_range=Range1d(8, 29),
grid=grid,
end_factor=end_factor,
include_bau=include_bau
)
plot.add_glyph(
ColumnDataSource(data=dict(x=[2010, 2030], y=[20, 20])),
Line(x='x', y='y', line_width=2, line_dash='dotdash'),
)
plot.add_glyph(
ColumnDataSource(data=dict(x=[2010.5], y=[20.2], text=['Non-fossil target'])),
Text(x='x', y='y', text='text', text_font_size='8pt'),
)
return (plot, line_renderers)
def large_plot():
source = ColumnDataSource(data=dict(x=[0, 1], y=[0, 1]))
xdr = Range1d(start=0, end=1)
xdr.tags.append("foo")
xdr.tags.append("bar")
ydr = Range1d(start=10, end=20)
ydr.tags.append("foo")
ydr.tags.append(11)
plot = Plot(x_range=xdr, y_range=ydr)
ydr2 = Range1d(start=0, end=100)
plot.extra_y_ranges = {"liny": ydr2}
circle = Circle(x="x", y="y", fill_color="red", size=5, line_color="black")
plot.add_glyph(source, circle, name="mycircle")
line = Line(x="x", y="y")
plot.add_glyph(source, line, name="myline")
rect = Rect(x="x", y="y", width=1, height=1, fill_color="green")
plot.add_glyph(source, rect, name="myrect")
plot.add_layout(DatetimeAxis(), 'below')
plot.add_layout(LogAxis(), 'left')
plot.add_layout(LinearAxis(y_range_name="liny"), 'left')
plot.add_layout(Grid(dimension=0), 'left')
plot.add_layout(Grid(dimension=1), 'left')
plot.add_tools(
BoxZoomTool(),
PanTool(),
SaveTool(),
ResetTool(),
WheelZoomTool(),
)
return plot
def plot_regions_comparison(regions_df, y_col, x_col):
df_regions_plot = pd.DataFrame(index=regions_df[x_col].unique())
plot = Plot(title=None,
plot_width=1000,
plot_height=600,
min_border=0,
toolbar_location='left')
colors = itertools.cycle(Dark2_5)
for region, df_region in regions_df.groupby("denominazione_regione"):
print(df_region.set_index(x_col)[y_col])
df_regions_plot.loc[df_region.set_index(x_col).index,
region] = df_region.set_index(x_col)[y_col].values
source = ColumnDataSource(
dict(x=df_region.set_index(x_col).index.values,
y=df_region.set_index(x_col)[y_col].values))
glyph = Line(
x="x",
y="y",
line_color=next(colors),
line_width=2,
line_alpha=0.7,
)
plot.add_glyph(source, glyph)
xaxis = LinearAxis()
plot.add_layout(xaxis, 'below')
yaxis = LinearAxis()
plot.add_layout(yaxis, 'left')
plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker))
plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker))
curdoc().add_root(plot)
show(plot)
def _make_base_plot(dfs, activities, x_range, plot_width=900):
plot = Plot(
x_range=x_range,
y_range=Range1d(0, 11),
outline_line_color=None,
background_fill=COLOR_PRIMARY,
border_fill=COLOR_PRIMARY,
plot_width=plot_width,
plot_height=150,
min_border_top=0,
toolbar_location=None,
)
yticker = BasicTicker(min_interval=3)
close_ticker = DatetimeTicker(desired_num_ticks=8)
close_ticks = DatetimeTickFormatter(
formats={
'years': ["%b"],
'months': ["%b"],
'days': ["%a %d %b"],
'hours': ["%I%p %d %b"]
}
)
plot.add_layout(LinearAxis(ticker=yticker, **AXIS_PROPERTIES), 'left')
plot.add_layout(DatetimeAxis(formatter=close_ticks, ticker=close_ticker, **AXIS_PROPERTIES), 'below')
plot.add_layout(Grid(dimension=1, ticker=yticker, grid_line_alpha=0.3))
palette = get_palette(activities)
for i, activity in enumerate(activities):
source = dfs[activity]
line = Line(
line_color=palette[i],
line_join='round', line_cap='round', line_width=5, line_alpha=0.75,
x='timestamp', y='cumsum_hrs'
)
plot.add_glyph(source, line)
return plot
def get_energy_mix_by_scenario(df, scenario, plot_width=700):
plot = Plot(
x_range=get_year_range(end_factor=15),
y_range=Range1d(0, 4300),
plot_width=plot_width,
**PLOT_FORMATS
)
plot = add_axes(plot, [0, 2000, 4000], color=scenarios_colors[scenario])
source = ColumnDataSource(df)
for energy_mix_column in energy_mix_columns.keys():
energy_name = energy_mix_columns[energy_mix_column]
parameter = '%s_%s' % (scenario, energy_mix_column)
line = Line(
x='t', y=parameter, line_color='black',
line_width=2, line_cap='round', line_join='round', line_alpha=0.8
)
circle = Circle(
x='t', y=parameter, size=4, fill_color='black', fill_alpha=0.6
)
# invisible circle used for hovering
hit_target = Circle(
x='t', y=parameter, size=10, line_color=None, fill_color=None
)
scenario_label = Text(
x=value(source.data['t'][-1] + 2), y=value(source.data[parameter][-1] - 200),
text=value(energy_name), text_color='grey', text_font_size='8pt',
)
hit_renderer = plot.add_glyph(source, hit_target)
plot.add_tools(HoverTool(tooltips="%s - @%s{0,0} (@t)" % (energy_name, parameter), renderers=[hit_renderer]))
plot.add_glyph(source, line)
plot.add_glyph(source, circle)
plot.add_glyph(scenario_label)
return plot
def source_MA_30_plot(daily_source):
t = Title()
t.text = 'Source Count MA30'
plot = Plot(
title=t, plot_width=400, plot_height=300,
min_border=0, toolbar_location=None)
mean_30 = Line(x="index", y="count_MA_30", line_color="#abd3b1", line_width=3, line_alpha=0.6)
plot.add_glyph(daily_source, mean_30)
xaxis = LinearAxis()
plot.add_layout(xaxis, 'below')
plot.xaxis.formatter = DatetimeTickFormatter(
hours=["%d %B %Y"],
days=["%d %B %Y"],
months=["%d %B %Y"],
years=["%d %B %Y"],
)
plot.xaxis.major_label_orientation = pi / 4
yaxis = LinearAxis()
plot.add_layout(yaxis, 'left')
plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker))
plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker))
return plot
def create(palm):
connected = False
current_message = None
stream_t = 0
doc = curdoc()
# Streaked and reference waveforms plot
waveform_plot = Plot(
title=Title(text="eTOF waveforms"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location='right',
)
# ---- tools
waveform_plot.toolbar.logo = None
waveform_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
waveform_plot.add_layout(LinearAxis(axis_label='Photon energy, eV'),
place='below')
waveform_plot.add_layout(LinearAxis(axis_label='Intensity',
major_label_orientation='vertical'),
place='left')
# ---- grid lines
waveform_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
waveform_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
waveform_source = ColumnDataSource(
dict(x_str=[], y_str=[], x_ref=[], y_ref=[]))
waveform_ref_line = waveform_plot.add_glyph(
waveform_source, Line(x='x_ref', y='y_ref', line_color='blue'))
waveform_str_line = waveform_plot.add_glyph(
waveform_source, Line(x='x_str', y='y_str', line_color='red'))
# ---- legend
waveform_plot.add_layout(
Legend(items=[("reference",
[waveform_ref_line]), ("streaked",
[waveform_str_line])]))
waveform_plot.legend.click_policy = "hide"
# Cross-correlation plot
xcorr_plot = Plot(
title=Title(text="Waveforms cross-correlation"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location='right',
)
# ---- tools
xcorr_plot.toolbar.logo = None
xcorr_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
xcorr_plot.add_layout(LinearAxis(axis_label='Energy shift, eV'),
place='below')
xcorr_plot.add_layout(LinearAxis(axis_label='Cross-correlation',
major_label_orientation='vertical'),
place='left')
# ---- grid lines
xcorr_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
xcorr_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
xcorr_source = ColumnDataSource(dict(lags=[], xcorr=[]))
xcorr_plot.add_glyph(xcorr_source,
Line(x='lags', y='xcorr', line_color='purple'))
# ---- vertical span
xcorr_center_span = Span(location=0, dimension='height')
xcorr_plot.add_layout(xcorr_center_span)
# Delays plot
pulse_delay_plot = Plot(
title=Title(text="Pulse delays"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location='right',
)
# ---- tools
pulse_delay_plot.toolbar.logo = None
pulse_delay_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
pulse_delay_plot.add_layout(LinearAxis(axis_label='Pulse number'),
place='below')
pulse_delay_plot.add_layout(
LinearAxis(axis_label='Pulse delay (uncalib), eV',
major_label_orientation='vertical'),
place='left',
)
# ---- grid lines
pulse_delay_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
pulse_delay_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
pulse_delay_source = ColumnDataSource(dict(x=[], y=[]))
pulse_delay_plot.add_glyph(pulse_delay_source,
Line(x='x', y='y', line_color='steelblue'))
# Pulse lengths plot
pulse_length_plot = Plot(
title=Title(text="Pulse lengths"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location='right',
)
# ---- tools
pulse_length_plot.toolbar.logo = None
pulse_length_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
pulse_length_plot.add_layout(LinearAxis(axis_label='Pulse number'),
place='below')
pulse_length_plot.add_layout(
LinearAxis(axis_label='Pulse length (uncalib), eV',
major_label_orientation='vertical'),
place='left',
)
# ---- grid lines
pulse_length_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
pulse_length_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
pulse_length_source = ColumnDataSource(dict(x=[], y=[]))
pulse_length_plot.add_glyph(pulse_length_source,
Line(x='x', y='y', line_color='steelblue'))
# Image buffer slider
def buffer_slider_callback(_attr, _old, new):
message = receiver.data_buffer[new]
doc.add_next_tick_callback(partial(update, message=message))
buffer_slider = Slider(
start=0,
end=59,
value=0,
step=1,
title="Buffered Image",
callback_policy='throttle',
callback_throttle=500,
)
buffer_slider.on_change('value', buffer_slider_callback)
# Connect toggle button
def connect_toggle_callback(state):
nonlocal connected
if state:
connected = True
connect_toggle.label = 'Connecting'
connect_toggle.button_type = 'default'
else:
connected = False
connect_toggle.label = 'Connect'
connect_toggle.button_type = 'default'
connect_toggle = Toggle(label="Connect", button_type='default', width=250)
connect_toggle.on_click(connect_toggle_callback)
# Intensity stream reset button
def reset_button_callback():
nonlocal stream_t
stream_t = 1 # keep the latest point in order to prevent full axis reset
reset_button = Button(label="Reset", button_type='default', width=250)
reset_button.on_click(reset_button_callback)
# Stream update coroutine
async def update(message):
nonlocal stream_t
if connected and receiver.state == 'receiving':
y_ref = message[receiver.reference].value[np.newaxis, :]
y_str = message[receiver.streaked].value[np.newaxis, :]
delay, length, debug_data = palm.process({
'0': y_ref,
'1': y_str
},
debug=True)
prep_data, lags, corr_res_uncut, _ = debug_data
waveform_source.data.update(
x_str=palm.energy_range,
y_str=prep_data['1'][0, :],
x_ref=palm.energy_range,
y_ref=prep_data['0'][0, :],
)
xcorr_source.data.update(lags=lags, xcorr=corr_res_uncut[0, :])
xcorr_center_span.location = delay[0]
pulse_delay_source.stream({
'x': [stream_t],
'y': [delay]
},
rollover=120)
pulse_length_source.stream({
'x': [stream_t],
'y': [length]
},
rollover=120)
stream_t += 1
# Periodic callback to fetch data from receiver
async def internal_periodic_callback():
nonlocal current_message
if waveform_plot.inner_width is None:
# wait for the initialization to finish, thus skip this periodic callback
return
if connected:
if receiver.state == 'polling':
connect_toggle.label = 'Polling'
connect_toggle.button_type = 'warning'
elif receiver.state == 'receiving':
connect_toggle.label = 'Receiving'
connect_toggle.button_type = 'success'
# Set slider to the right-most position
if len(receiver.data_buffer) > 1:
buffer_slider.end = len(receiver.data_buffer) - 1
buffer_slider.value = len(receiver.data_buffer) - 1
if receiver.data_buffer:
current_message = receiver.data_buffer[-1]
doc.add_next_tick_callback(partial(update, message=current_message))
doc.add_periodic_callback(internal_periodic_callback, 1000)
# assemble
tab_layout = column(
row(
column(waveform_plot, xcorr_plot),
Spacer(width=30),
column(buffer_slider, row(connect_toggle, reset_button)),
),
row(pulse_delay_plot, Spacer(width=10), pulse_length_plot),
)
return Panel(child=tab_layout, title="Stream")
def __init__(self, **kwargs):
self.source = ColumnDataSource(
data={
'time': [],
'cpu': [],
'memory_percent': [],
'network-send': [],
'network-recv': []
})
x_range = DataRange1d(follow='end',
follow_interval=30000,
range_padding=0)
resource_plot = Plot(x_range=x_range,
y_range=Range1d(start=0, end=1),
toolbar_location=None,
min_border_bottom=10,
**kwargs)
line_opts = dict(line_width=2, line_alpha=0.8)
g1 = resource_plot.add_glyph(
self.source,
Line(x='time',
y='memory_percent',
line_color="#33a02c",
**line_opts))
g2 = resource_plot.add_glyph(
self.source,
Line(x='time', y='cpu', line_color="#1f78b4", **line_opts))
resource_plot.add_layout(
LinearAxis(formatter=NumeralTickFormatter(format="0 %")), 'left')
legend_opts = dict(location='top_left',
orientation='horizontal',
padding=5,
margin=5,
label_height=5)
resource_plot.add_layout(
Legend(items=[('Memory', [g1]), ('CPU', [g2])], **legend_opts))
network_plot = Plot(x_range=x_range,
y_range=DataRange1d(start=0),
toolbar_location=None,
**kwargs)
g1 = network_plot.add_glyph(
self.source,
Line(x='time', y='network-send', line_color="#a6cee3",
**line_opts))
g2 = network_plot.add_glyph(
self.source,
Line(x='time', y='network-recv', line_color="#b2df8a",
**line_opts))
network_plot.add_layout(DatetimeAxis(axis_label="Time"), "below")
network_plot.add_layout(LinearAxis(axis_label="MB/s"), 'left')
network_plot.add_layout(
Legend(items=[('Network Send', [g1]), ('Network Recv', [g2])],
**legend_opts))
tools = [
PanTool(dimensions='width'),
WheelZoomTool(dimensions='width'),
BoxZoomTool(),
ResetTool()
]
if 'sizing_mode' in kwargs:
sizing_mode = {'sizing_mode': kwargs['sizing_mode']}
else:
sizing_mode = {}
combo_toolbar = ToolbarBox(tools=tools,
logo=None,
toolbar_location='right',
**sizing_mode)
self.root = row(column(resource_plot, network_plot, **sizing_mode),
column(combo_toolbar, **sizing_mode),
id='bk-resource-profiles-plot',
**sizing_mode)
# Required for update callback
self.resource_index = [0]
def create(palm):
energy_min = palm.energy_range.min()
energy_max = palm.energy_range.max()
energy_npoints = palm.energy_range.size
current_results = (0, 0, 0, 0)
doc = curdoc()
# Streaked and reference waveforms plot
waveform_plot = Plot(
title=Title(text="eTOF waveforms"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location="right",
)
# ---- tools
waveform_plot.toolbar.logo = None
waveform_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
waveform_plot.add_layout(LinearAxis(axis_label="Photon energy, eV"),
place="below")
waveform_plot.add_layout(LinearAxis(axis_label="Intensity",
major_label_orientation="vertical"),
place="left")
# ---- grid lines
waveform_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
waveform_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
waveform_source = ColumnDataSource(
dict(x_str=[], y_str=[], x_ref=[], y_ref=[]))
waveform_ref_line = waveform_plot.add_glyph(
waveform_source, Line(x="x_ref", y="y_ref", line_color="blue"))
waveform_str_line = waveform_plot.add_glyph(
waveform_source, Line(x="x_str", y="y_str", line_color="red"))
# ---- legend
waveform_plot.add_layout(
Legend(items=[("reference",
[waveform_ref_line]), ("streaked",
[waveform_str_line])]))
waveform_plot.legend.click_policy = "hide"
# Cross-correlation plot
xcorr_plot = Plot(
title=Title(text="Waveforms cross-correlation"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location="right",
)
# ---- tools
xcorr_plot.toolbar.logo = None
xcorr_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
xcorr_plot.add_layout(LinearAxis(axis_label="Energy shift, eV"),
place="below")
xcorr_plot.add_layout(LinearAxis(axis_label="Cross-correlation",
major_label_orientation="vertical"),
place="left")
# ---- grid lines
xcorr_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
xcorr_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
xcorr_source = ColumnDataSource(dict(lags=[], xcorr1=[], xcorr2=[]))
xcorr_plot.add_glyph(
xcorr_source,
Line(x="lags", y="xcorr1", line_color="purple", line_dash="dashed"))
xcorr_plot.add_glyph(xcorr_source,
Line(x="lags", y="xcorr2", line_color="purple"))
# ---- vertical span
xcorr_center_span = Span(location=0, dimension="height")
xcorr_plot.add_layout(xcorr_center_span)
# Delays plot
pulse_delay_plot = Plot(
title=Title(text="Pulse delays"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location="right",
)
# ---- tools
pulse_delay_plot.toolbar.logo = None
pulse_delay_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
pulse_delay_plot.add_layout(LinearAxis(axis_label="Pulse number"),
place="below")
pulse_delay_plot.add_layout(
LinearAxis(axis_label="Pulse delay (uncalib), eV",
major_label_orientation="vertical"),
place="left",
)
# ---- grid lines
pulse_delay_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
pulse_delay_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
pulse_delay_source = ColumnDataSource(dict(pulse=[], delay=[]))
pulse_delay_plot.add_glyph(
pulse_delay_source, Line(x="pulse", y="delay", line_color="steelblue"))
# ---- vertical span
pulse_delay_plot_span = Span(location=0, dimension="height")
pulse_delay_plot.add_layout(pulse_delay_plot_span)
# Pulse lengths plot
pulse_length_plot = Plot(
title=Title(text="Pulse lengths"),
x_range=DataRange1d(),
y_range=DataRange1d(),
plot_height=PLOT_CANVAS_HEIGHT,
plot_width=PLOT_CANVAS_WIDTH,
toolbar_location="right",
)
# ---- tools
pulse_length_plot.toolbar.logo = None
pulse_length_plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(),
ResetTool())
# ---- axes
pulse_length_plot.add_layout(LinearAxis(axis_label="Pulse number"),
place="below")
pulse_length_plot.add_layout(
LinearAxis(axis_label="Pulse length (uncalib), eV",
major_label_orientation="vertical"),
place="left",
)
# ---- grid lines
pulse_length_plot.add_layout(Grid(dimension=0, ticker=BasicTicker()))
pulse_length_plot.add_layout(Grid(dimension=1, ticker=BasicTicker()))
# ---- line glyphs
pulse_length_source = ColumnDataSource(dict(x=[], y=[]))
pulse_length_plot.add_glyph(pulse_length_source,
Line(x="x", y="y", line_color="steelblue"))
# ---- vertical span
pulse_length_plot_span = Span(location=0, dimension="height")
pulse_length_plot.add_layout(pulse_length_plot_span)
# Folder path text input
def path_textinput_callback(_attr, _old_value, new_value):
save_textinput.value = new_value
path_periodic_update()
path_textinput = TextInput(title="Folder Path:",
value=os.path.join(os.path.expanduser("~")),
width=510)
path_textinput.on_change("value", path_textinput_callback)
# Saved runs dropdown menu
def h5_update(pulse, delays, debug_data):
prep_data, lags, corr_res_uncut, corr_results = debug_data
waveform_source.data.update(
x_str=palm.energy_range,
y_str=prep_data["1"][pulse, :],
x_ref=palm.energy_range,
y_ref=prep_data["0"][pulse, :],
)
xcorr_source.data.update(lags=lags,
xcorr1=corr_res_uncut[pulse, :],
xcorr2=corr_results[pulse, :])
xcorr_center_span.location = delays[pulse]
pulse_delay_plot_span.location = pulse
pulse_length_plot_span.location = pulse
# this placeholder function should be reassigned in 'saved_runs_dropdown_callback'
h5_update_fun = lambda pulse: None
def saved_runs_dropdown_callback(_attr, _old_value, new_value):
if new_value != "Saved Runs":
nonlocal h5_update_fun, current_results
saved_runs_dropdown.label = new_value
filepath = os.path.join(path_textinput.value, new_value)
tags, delays, lengths, debug_data = palm.process_hdf5_file(
filepath, debug=True)
current_results = (new_value, tags, delays, lengths)
if autosave_checkbox.active:
save_button_callback()
pulse_delay_source.data.update(pulse=np.arange(len(delays)),
delay=delays)
pulse_length_source.data.update(x=np.arange(len(lengths)),
y=lengths)
h5_update_fun = partial(h5_update,
delays=delays,
debug_data=debug_data)
pulse_slider.end = len(delays) - 1
pulse_slider.value = 0
h5_update_fun(0)
saved_runs_dropdown = Dropdown(label="Saved Runs",
button_type="primary",
menu=[])
saved_runs_dropdown.on_change("value", saved_runs_dropdown_callback)
# ---- saved run periodic update
def path_periodic_update():
new_menu = []
if os.path.isdir(path_textinput.value):
for entry in os.scandir(path_textinput.value):
if entry.is_file() and entry.name.endswith((".hdf5", ".h5")):
new_menu.append((entry.name, entry.name))
saved_runs_dropdown.menu = sorted(new_menu, reverse=True)
doc.add_periodic_callback(path_periodic_update, 5000)
# Pulse number slider
def pulse_slider_callback(_attr, _old_value, new_value):
h5_update_fun(pulse=new_value)
pulse_slider = Slider(
start=0,
end=99999,
value=0,
step=1,
title="Pulse ID",
callback_policy="throttle",
callback_throttle=500,
)
pulse_slider.on_change("value", pulse_slider_callback)
# Energy maximal range value text input
def energy_max_spinner_callback(_attr, old_value, new_value):
nonlocal energy_max
if new_value > energy_min:
energy_max = new_value
palm.energy_range = np.linspace(energy_min, energy_max,
energy_npoints)
saved_runs_dropdown_callback("", "", saved_runs_dropdown.label)
else:
energy_max_spinner.value = old_value
energy_max_spinner = Spinner(title="Maximal Energy, eV:",
value=energy_max,
step=0.1)
energy_max_spinner.on_change("value", energy_max_spinner_callback)
# Energy minimal range value text input
def energy_min_spinner_callback(_attr, old_value, new_value):
nonlocal energy_min
if new_value < energy_max:
energy_min = new_value
palm.energy_range = np.linspace(energy_min, energy_max,
energy_npoints)
saved_runs_dropdown_callback("", "", saved_runs_dropdown.label)
else:
energy_min_spinner.value = old_value
energy_min_spinner = Spinner(title="Minimal Energy, eV:",
value=energy_min,
step=0.1)
energy_min_spinner.on_change("value", energy_min_spinner_callback)
# Energy number of interpolation points text input
def energy_npoints_spinner_callback(_attr, old_value, new_value):
nonlocal energy_npoints
if new_value > 1:
energy_npoints = new_value
palm.energy_range = np.linspace(energy_min, energy_max,
energy_npoints)
saved_runs_dropdown_callback("", "", saved_runs_dropdown.label)
else:
energy_npoints_spinner.value = old_value
energy_npoints_spinner = Spinner(title="Number of interpolation points:",
value=energy_npoints)
energy_npoints_spinner.on_change("value", energy_npoints_spinner_callback)
# Save location
save_textinput = TextInput(title="Save Folder Path:",
value=os.path.join(os.path.expanduser("~")))
# Autosave checkbox
autosave_checkbox = CheckboxButtonGroup(labels=["Auto Save"],
active=[],
width=250)
# Save button
def save_button_callback():
if current_results[0]:
filename, tags, delays, lengths = current_results
save_filename = os.path.splitext(filename)[0] + ".csv"
df = pd.DataFrame({
"pulse_id": tags,
"pulse_delay": delays,
"pulse_length": lengths
})
df.to_csv(os.path.join(save_textinput.value, save_filename),
index=False)
save_button = Button(label="Save Results",
button_type="default",
width=250)
save_button.on_click(save_button_callback)
# assemble
tab_layout = column(
row(
column(waveform_plot, xcorr_plot),
Spacer(width=30),
column(
path_textinput,
saved_runs_dropdown,
pulse_slider,
Spacer(height=30),
energy_min_spinner,
energy_max_spinner,
energy_npoints_spinner,
Spacer(height=30),
save_textinput,
autosave_checkbox,
save_button,
),
),
row(pulse_delay_plot, Spacer(width=10), pulse_length_plot),
)
return Panel(child=tab_layout, title="HDF5 File")
def make_line_plot(x_range, y_range, source):
with make_plot(x_range, y_range, source) as plot:
for i, energy in enumerate(['gas', 'oil', 'solar']):
glyph = Line(x='index', y=energy, line_color=Spectral3[i], line_alpha=0.5, line_width=5)
plot.add_glyph(source, glyph)
return plot
def plot_map(ulog,
config,
map_type='plain',
api_key=None,
setpoints=False,
bokeh_plot=None):
"""
Do a 2D position plot
:param map_type: one of 'osm', 'google', 'plain'
:param bokeh_plot: if None, create a new bokeh plot, otherwise use the
supplied one (only for 'plain' map_type)
:return: bokeh plot object
"""
try:
cur_dataset = ulog.get_dataset('vehicle_gps_position')
t = cur_dataset.data['timestamp']
indices = cur_dataset.data['fix_type'] > 2 # use only data with a fix
t = t[indices]
lon = cur_dataset.data['lon'][indices] / 1e7 # degrees
lat = cur_dataset.data['lat'][indices] / 1e7
altitude = cur_dataset.data['alt'][indices] / 1e3 # meters
plots_width = config['plot_width']
plots_height = config['plot_height']['large']
anchor_lat = 0
anchor_lon = 0
if len(t) == 0:
raise ValueError('No valid GPS position data')
if map_type == 'google':
data_source = ColumnDataSource(data=dict(lat=lat, lon=lon))
lon_center = (np.amin(lon) + np.amax(lon)) / 2
lat_center = (np.amin(lat) + np.amax(lat)) / 2
map_options = GMapOptions(lat=lat_center,
lng=lon_center,
map_type="hybrid",
zoom=19)
# possible map types: satellite, roadmap, terrain, hybrid
p = GMapPlot(x_range=DataRange1d(),
y_range=DataRange1d(),
map_options=map_options,
api_key=api_key,
plot_width=plots_width,
plot_height=plots_height)
pan = PanTool()
wheel_zoom = WheelZoomTool()
p.add_tools(pan, wheel_zoom)
p.toolbar.active_scroll = wheel_zoom
line = Line(x="lon",
y="lat",
line_width=2,
line_color=config['maps_line_color'])
p.add_glyph(data_source, line)
elif map_type == 'osm':
# OpenStreetMaps
# transform coordinates
lon, lat = WGS84_to_mercator(lon, lat)
data_source = ColumnDataSource(data=dict(lat=lat, lon=lon))
p = figure(tools=TOOLS, active_scroll=ACTIVE_SCROLL_TOOLS)
p.plot_width = plots_width
p.plot_height = plots_height
plot_set_equal_aspect_ratio(p, lon, lat)
p.background_fill_color = "lightgray"
p.axis.visible = False
tile_options = {}
# thunderforest
tile_options[
'url'] = 'http://b.tile.thunderforest.com/landscape/{z}/{x}/{y}.png'
tile_options[
'attribution'] = 'Maps © <a href="http://www.thunderforest.com">Thunderforest</a>, Data © <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors '
# default OpenStreetMaps
# tile_options['url'] = 'http://c.tile.openstreetmap.org/{Z}/{X}/{Y}.png'
# tile_options['attribution'] = '© <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors '
# FIXME: tiles disabled for now due to a rendering bug
# tile_source = WMTSTileSource(**tile_options)
# tile_renderer_options = {}
# p.add_tile(tile_source, **tile_renderer_options)
# stamen (black & white)
# STAMEN_TONER = WMTSTileSource(
# url='http://tile.stamen.com/toner/{Z}/{X}/{Y}.png',
# attribution=(
# 'Map tiles by <a href="http://stamen.com">Stamen Design</a>, '
# 'under <a href="http://creativecommons.org/licenses/by/3.0">CC BY 3.0</a>.'
# 'Data by <a href="http://openstreetmap.org">OpenStreetMap</a>, '
# 'under <a href="http://www.openstreetmap.org/copyright">ODbL</a>'
# )
# )
# p.add_tile(STAMEN_TONER)
p.line(x='lon',
y='lat',
source=data_source,
line_width=2,
line_color=config['maps_line_color'])
else: # plain
# transform coordinates
lat = np.deg2rad(lat)
lon = np.deg2rad(lon)
anchor_lat = lat[0]
anchor_lon = lon[0]
# try to get the anchor position from the dataset
try:
local_pos_data = ulog.get_dataset('vehicle_local_position')
indices = np.nonzero(local_pos_data.data['ref_timestamp'])
if len(indices[0]) > 0:
anchor_lat = np.deg2rad(
local_pos_data.data['ref_lat'][indices[0][0]])
anchor_lon = np.deg2rad(
local_pos_data.data['ref_lon'][indices[0][0]])
except:
pass
lat, lon = map_projection(lat, lon, anchor_lat, anchor_lon)
data_source = ColumnDataSource(data=dict(lat=lat, lon=lon))
if bokeh_plot is None:
p = figure(tools=TOOLS,
active_scroll=ACTIVE_SCROLL_TOOLS,
x_axis_label='[m]',
y_axis_label='[m]')
p.plot_width = plots_width
p.plot_height = plots_height
plot_set_equal_aspect_ratio(p, lon, lat)
else:
p = bokeh_plot
# TODO: altitude line coloring
p.line(x='lon',
y='lat',
source=data_source,
line_width=2,
line_color=config['maps_line_color'],
legend='GPS (projected)')
if setpoints:
# draw (mission) setpoint as circles
try:
cur_dataset = ulog.get_dataset('position_setpoint_triplet')
lon = cur_dataset.data['current.lon'] # degrees
lat = cur_dataset.data['current.lat']
if map_type == 'osm':
lon, lat = WGS84_to_mercator(lon, lat)
elif map_type == 'plain':
lat = np.deg2rad(lat)
lon = np.deg2rad(lon)
lat, lon = map_projection(lat, lon, anchor_lat, anchor_lon)
data_source = ColumnDataSource(data=dict(lat=lat, lon=lon))
p.circle(x='lon',
y='lat',
source=data_source,
line_width=2,
size=6,
line_color=config['mission_setpoint_color'],
fill_color=None,
legend='Position Setpoints')
except:
pass
except (KeyError, IndexError, ValueError) as error:
# log does not contain the value we are looking for
print(type(error), "(vehicle_gps_position):", error)
return None
p.toolbar.logo = None
return p
ydr = DataRange1d()
plot = Plot(
x_range=xdr,
y_range=ydr,
width=1000,
height=600,
min_border=0,
toolbar_location=None,
background_fill_color='#F0F0F0',
border_fill_color='lightgray',
)
line_glyph = Line(x="x",
y="y",
line_color="navy",
line_width=2,
line_dash="dashed")
line = plot.add_glyph(source, line_glyph)
circle = Circle(x="x",
y="y2",
size=6,
line_color="red",
fill_color="orange",
fill_alpha=0.6)
circle = plot.add_glyph(source, circle)
pan = PanTool()
wheel_zoom = WheelZoomTool()
preview_save = SaveTool()
times = [dt.time(11, 30)]*3,
texts = ["CST (UTC+1)", "CEST (UTC+2)", "CST (UTC+1)"],
))
plot = Plot(width=800, height=400)
plot.title.text = "Daylight Hours 2013 - Warsaw, Poland"
plot.toolbar_location = None
plot.x_range.range_padding = 0
patch1 = Patch(x="dates", y="times", fill_color="#282e54")
plot.add_glyph(patch1_source, patch1)
patch2 = Patch(x="dates", y="times", fill_color="#ffdd91")
plot.add_glyph(patch2_source, patch2)
sunrise_line = Line(x="dates", y="sunrises", line_color="orange", line_width=4)
sunrise_line_renderer = plot.add_glyph(source, sunrise_line)
sunset_line = Line(x="dates", y="sunsets", line_color="crimson", line_width=4)
sunset_line_renderer = plot.add_glyph(source, sunset_line)
text = Text(x="dates", y="times", text="texts", text_align="center", text_color="grey")
plot.add_glyph(text_source, text)
xformatter = DatetimeTickFormatter(months="%b %d %Y")
min_time = dt.datetime.min.time()
xticker = FixedTicker(ticks=[
mktime(dt.datetime.combine(summer_start, min_time).timetuple()) * 1000,
mktime(dt.datetime.combine(summer_end, min_time).timetuple()) * 1000
])
xaxis = DatetimeAxis(formatter=xformatter, ticker=xticker)
