def create_figures(stats: List[Stat], name: str) -> List[go.FigureWidget]:
if name == "Categories":
data = Result.build_stack_bar_data(stats)
layout = Result.get_layout("Category fields", len(stats))
layout.barmode = "stack"
return [go.FigureWidget(data, layout)]
figures = []
for stat in stats:
y = stat.index.values.astype(str)
if isinstance(stat, pd.Series):
data = [
go.Bar(x=stat.values, y=y, orientation="h", opacity=0.7)
]
else:
data = [
go.Bar(x=stat[c].values,
y=y,
orientation="h",
opacity=0.7,
name=c) for c in stat.columns
]
layout = Result.get_layout(stat.name, len(stat))
layout.xaxis = go.layout.XAxis(
range=[0, max(stat.values.max(), 1) * 1.05])
if stat.name.startswith("Coverage"):
layout.xaxis.tickformat = ".2p"
if stat.name == "Coverage for boolean fields":
layout.barmode = "stack"
if stat.name.startswith("Fields coverage"):
layout.annotations = Result.make_annotations(stat)
figures.append(go.FigureWidget(data, layout))
return figures
def prediction():
input1 = st.text_input("Enter Tweet", "Type here")
if st.button("Predict"):
process1 = url(input1)
process2 = smiley(process1)
process3 = lower(process2)
process4 = decontracted(process3)
process5 = digit(process4)
process6 = punct(process5)
process7 = odd(process6)
process8 = space(process7)
process9 = stop(process8)
process10 = space(process9)
process11 = [process10]
vect_pro = vectorizer.transform(process11)
result1 = vect_pro.reshape(1, -1)
result = model.predict(result1)
if result == 1:
st.success('The tweet is Positive')
graph = model.predict_proba(result1)[:, 1]
a = graph.tolist()
b = (a[0])
c = (1 - a[0])
value = [b, c]
labels = ['Positive', 'Negative']
values = [c, b]
colors = ['rgb(26,152,80)', 'rgb(120,14,40)']
trace = go.Pie(labels=labels,
values=value,
textfont=dict(size=20),
marker=dict(colors=colors))
fig = go.FigureWidget(data=[trace])
st.plotly_chart(fig)
if result == 0:
st.error('The tweet is Negative')
graph = model.predict_proba(result1)[:, 1]
a = graph.tolist()
b = (a[0])
c = (1 - a[0])
values = [b, c]
labels = ['Negative', 'Positive']
values = [c, b]
colors = ['rgb(120,14,40)', 'rgb(26,152,80)']
trace = go.Pie(labels=labels,
values=values,
textfont=dict(size=20),
marker=dict(colors=colors))
fig = go.FigureWidget(data=[trace])
st.plotly_chart(fig)
def ipy_plot_interactive(df, opacity=.3):
'''Interactive plotly widget for a cryoDRGN pandas dataframe'''
import plotly.graph_objs as go
from ipywidgets import interactive
if 'labels' in df.columns:
text = [f'Class {k}: index {i}' for i,k in zip(df.index, df.labels)] # hovertext
else:
text = [f'index {i}' for i in df.index] # hovertext
xaxis, yaxis = df.columns[0], df.columns[1]
f = go.FigureWidget([go.Scattergl(x=df[xaxis],
y=df[yaxis],
mode='markers',
text=text,
marker=dict(size=2,
opacity=opacity,
color=np.arange(len(df)),
colorscale='hsv'
))])
scatter = f.data[0]
N = len(df)
f.update_layout(xaxis_title=xaxis, yaxis_title=yaxis)
f.layout.dragmode = 'lasso'
def update_axes(xaxis, yaxis, color_by, colorscale):
scatter = f.data[0]
scatter.x = df[xaxis]
scatter.y = df[yaxis]
scatter.marker.colorscale = colorscale
if colorscale is None:
scatter.marker.color = None
else:
scatter.marker.color = df[color_by] if color_by != 'index' else df.index
with f.batch_update(): # what is this for??
f.layout.xaxis.title = xaxis
f.layout.yaxis.title = yaxis
widget = interactive(update_axes,
yaxis=df.select_dtypes('number').columns,
xaxis=df.select_dtypes('number').columns,
color_by = df.columns,
colorscale = [None,'hsv','plotly3','deep','portland','picnic','armyrose'])
t = go.FigureWidget([go.Table(
header=dict(values=['index']),
cells=dict(values=[df.index]),
)])
def selection_fn(trace, points, selector):
t.data[0].cells.values = [df.loc[points.point_inds].index]
scatter.on_selection(selection_fn)
return widget, f, t
def create_figure(self):
self.filter_data()
data = []
title = self.generate_title()
xaxis_name = self.options.get('xaxis_name',
'Probability of Compliance (%)')
yaxis_name = self.options.get('yaxis_name',
'Difference in EC (micromhos/cm)')
layout = go.Layout(template='seaborn',
title=dict(text=title),
yaxis=dict(zeroline=True,
zerolinecolor='#000000',
title=yaxis_name,
rangemode='tozero'),
xaxis=dict(title=xaxis_name)
)
results = {'Scenario': [],
'# of Days Standards are Applicable': [],
'# of Days Violated': [],
r'% of Days Violated': []}
for case in self.cases:
mask = (self.df_to_plot[self.colname_case] == case)
yval = self.df_to_plot[mask][self.colname_y].sort_values(
ascending=True)
n = yval.count()
xval = np.arange(1, n + 1) / n * 100.
name = case
data.append(go.Scatter(x=xval,
y=yval.values,
name=case))
results['Scenario'].append(case)
results['# of Days Standards are Applicable'].append(n)
n_violated = yval[yval > 0.].count()
results['# of Days Violated'].append(n_violated)
results[r'% of Days Violated'].append(
f'{n_violated / n * 100.:.2f}')
self.fig = go.FigureWidget(data=data, layout=layout)
self.df_results = pd.DataFrame(data=results)
self.results = go.FigureWidget(data=[go.Table(
header=dict(values=[[v] for v in self.df_results.columns]),
cells=dict(values=[self.df_results[k] for k in self.df_results.columns],
height=30))],
layout=go.Layout(
template='seaborn',
height=(self.df_results.shape[0] + 2) * 20 + 100,
margin=dict(t=30, b=10),
font=dict(size=14)
))
def slider_histo(data):
import plotly.graph_objs as go
import plotly.figure_factory as ff
# data = [30.2049, 51.3693, 51.8094, 30.5573, 56.8151, 45.9166, 56.2858, 55.4125, 72.8778,
# 39.7996, 34.8203, 36.8362, 39.9959, 54.7995, 52.5158, 40.6841, 61.3939, 48.5818,
# 41.4944, 71.5607, 49.0913, 57.7985, 70.2787, 45.2226, 55.7449, 69.0475, 33.9624,
# 51.3384, 53.1948, 46.1682, 66.5202, 37.0265, 48.0182, 44.2164, 56.9336, 69.7961,
# 48.6728, 44.5923, 33.2164, 41.8337,56.7741, 35.6030, 33.9237, 41.5178, 50.4453,
# 29.0570, 33.0124, 58.6281, 39.2005, 42.9119]
hist_data = [data]
group_labels = ['distplot']
f = ff.create_distplot(hist_data,
group_labels,
bin_size=1,
show_rug=True,
show_curve=False)
fig = go.FigureWidget(f)
fig.data[0].marker.line = dict(color='black', width=2)
fig.data[1].line.color = 'red'
fig.layout.sliders = [
dict(active=0,
currentvalue={"prefix": "bin size: "},
pad={"t": 20},
steps=[
dict(label=i, method='restyle', args=['xbins.size', i])
for i in range(1, 100)
])
]
fig.show()
def build_graph(self):
xrange = [min(self.nodes.x) - 50, max(self.nodes.x) + 50]
yrange = [min(self.nodes.y) - 30, max(self.nodes.y) + 30]
self.graph = go.FigureWidget(
data=[self.edges, self.nodes, self.node_select, self.node_status],
layout=dict(
width=500,
height=350,
margin=dict(b=20, l=5, r=5, t=40),
xaxis=dict(range=xrange,
showgrid=False,
zeroline=False,
showticklabels=False),
yaxis=dict(range=yrange,
showgrid=False,
zeroline=False,
showticklabels=False),
showlegend=False,
plot_bgcolor='white',
),
)
# need to reassign pointers because FigureWidget makes a copy...
self.edges = self.graph.data[0]
self.nodes = self.graph.data[1]
self.node_select = self.graph.data[2]
self.node_status = self.graph.data[3]
def get_ratiometric_reading_plot():
""" Quick plot of a spatial ratiometric optical reading over a range of temperatures and DO values. """
temperatures_to_plot = TEMPERATURE_DOMAIN[::5]
return go.FigureWidget(
[
go.Scatter(
x=DO_DOMAIN,
y=simulate_spatial_ratiometric_reading(DO_DOMAIN, temperature),
mode="lines",
line={
"color": color_from_temperature(temperature),
"width": 1
},
name=f"T={temperature}",
) for temperature in temperatures_to_plot
],
layout={
"title": "spatial ratiometric reading over DO and temperature",
"xaxis": {
"title": "DO (mmHg)"
},
"yaxis": {
"title": "Spatial Ratiometric Reading (unitless)"
},
},
)
def build_summary(self,Fit1DWidgets):
y = []
yerr = []
for i,wavelength in enumerate(self.wavelengths):
y.append(Fit1DWidgets[wavelength].get_fit_param('center').value)
yerr.append(Fit1DWidgets[wavelength].get_fit_param('center').stderr)
self.summary = go.FigureWidget()
self.summary.add_scatter(y=y,error_y={'array':yerr})
yval = 0.1076
self.summary.add_shape(
xref='paper', x0=0, x1=1, y0=yval, y1=yval, line=dict(dash='dash'))
for pct in [0.5,1]:
for sign in [1.0,-1.0]:
yval = 0.1076*(1.00+sign*pct/100)
self.summary.add_shape(
xref='paper', x0=0, x1=1, y0=yval, y1=yval, line=dict(dash='dot',color='red')
)
self.summary.add_annotation(x=0.5,y=0.1076*(1.00-0.5/100),text='0.5% Error')
self.summary.update_layout(
xaxis_title = 'Wavelength',
yaxis_title = 'AgBeh Peak q',
xaxis=dict(
tickmode='array',
tickvals=[i for i,_ in enumerate(self.wavelengths)],
ticktext=self.wavelengths,
)
)
def calibration_error_plot(predicted_do, actual_do, temperature, fit_title):
""" Plot showing the error in predicted DO as distributed over DO and temperature """
return go.FigureWidget(
data=[
go.Scatter(
x=actual_do,
y=predicted_do - actual_do,
mode="markers",
text=[f"T={T}" for T in temperature],
marker=dict(
color=temperature,
symbol="circle-open",
colorscale="Bluered",
cmin=TEMPERATURE_STANDARD_OPERATING_MIN,
cmax=TEMPERATURE_STANDARD_OPERATING_MAX,
),
)
],
layout=go.Layout(
title=f"DO error in {fit_title}",
xaxis={
"title": "Dissolved Oxygen (mmHg)",
"range": [0, DO_MAX_MMHG]
},
yaxis={"title": "DO error (predicted - actual)<br>(mmHg)"},
hovermode="closest",
shapes=DO_AXIS_ERROR_BOUNDS_LINES,
),
)
def overlay_dr_spectrum(
dataframe, progressions, freq_col="Frequency", int_col="Intensity", **kwargs
):
layout = define_layout("Frequency (MHz)", "Intensity")
fig = go.FigureWidget(layout=layout)
fig.add_scattergl(
x=dataframe[freq_col], y=dataframe[int_col], name="Observation", opacity=0.4
)
colors = generate_colors(len(progressions), cmap=plt.cm.tab10)
level = 2.0
for index, (progression, color) in enumerate(zip(progressions, colors)):
mask = np.where(progression <= np.max(dataframe[freq_col]))
progression = progression[mask]
indices = np.array(
[routines.find_nearest(dataframe[freq_col], freq) for freq in progression]
)
indices = indices[:, 1]
y = dataframe[int_col].iloc[indices] * 1.2
fig.add_scattergl(
x=progression,
y=y,
marker={"color": color},
mode="markers+lines",
hoverinfo="name+x",
name="Progression {}".format(index),
)
return fig
def create_display(c: Union[pd.DataFrame, Dict[str, pd.DataFrame], go.Figure]):
""" different kinds of display in jupyter notebook """
if isinstance(c, pd.DataFrame):
return display_table(c)
if isinstance(c, go.Figure):
return display(go.FigureWidget(c))
return display(c)
def __init__(self,
title_str=None,
ch_names=None,
shot_noise=False,
legend_orientation=None):
""" MultiTraceFig constructor
:param title_str: string to display for plot title
:param ch_names: list of channel name strings for multi
-channel plot
:param shot_noise: boolean of whether or not to plot
shot noise on individual traces
"""
self._fig = go.FigureWidget(data=[])
self._shot_noise = shot_noise
self._ch_names = ch_names
if self._ch_names is not None:
# Initialize all channels if given
self._num_ch = 0
self._allocate_arrays()
else:
self._num_ch = 0
if title_str is not None:
self._fig.layout.update(title=title_str)
if legend_orientation is not None:
self._fig.update_layout(legend=dict(x=0, y=1.1),
legend_orientation=legend_orientation)
def __init__(self,
x,
y,
u,
v,
scale=0.1,
arrow_scale=0.3,
angle=math.pi / 9,
scaleratio=None,
**kwargs):
super(Quiver, self).__init__()
if scaleratio is None:
self.quiver_obj = _Quiver(x, y, u, v, scale, arrow_scale, angle)
else:
self.quiver_obj = _Quiver(x, y, u, v, scale, arrow_scale, angle,
scaleratio)
barb_x, barb_y = self.quiver_obj.get_barbs()
arrow_x, arrow_y = self.quiver_obj.get_quiver_arrows()
plt = go.Scatter(x=barb_x + arrow_x,
y=barb_y + arrow_y,
mode="lines",
**kwargs)
self.fig = go.FigureWidget(
go.Figure(data=[plt], layout=vis_plot.layout_default()))
def create_figure(self, number_traces):
self.traces = []
self.fig = go.FigureWidget(
tools.make_subplots(rows=number_traces, cols=1, print_grid=False))
for i in range(1, number_traces + 1):
self.traces.append([])
for _ in range(len(self.scan_names)):
trace = go.Scatter(
x=[],
y=[], # Data
mode='lines+markers',
name='f' + str(i),
showlegend=True)
diff_trace = go.Scatter(
x=[],
y=[], # Data
mode='lines+markers',
name='df' + str(i),
showlegend=True)
diff_diff_trace = go.Scatter(
x=[],
y=[], # Data
mode='lines+markers',
name='ddf' + str(i),
showlegend=True)
self.traces[i - 1].append(trace)
self.fig.append_trace(
trace, i, 1) # using i + 1 because plot index starts at 1
self.fig.append_trace(
diff_trace, i,
1) # using i + 1 because plot index starts at 1
self.fig.append_trace(
diff_diff_trace, i,
1) # using i + 1 because plot index starts at 1
self.fig['data'][3 * (i - 1) + 1].update(
yaxis="y" + str(number_traces + i * 2))
self.fig['data'][3 * (i - 1) + 2].update(
yaxis="y" + str(number_traces + i * 2 + 1))
self.fig['layout']['yaxis' +
str(number_traces + i * 2)] = dict(
overlaying="y" + str(i),
anchor="x" + str(i),
side="right")
self.fig['layout']['yaxis' +
str(number_traces + i * 2 + 1)] = dict(
overlaying="y" + str(i),
anchor="x" + str(i),
side="right")
self.fig['layout'].update(title='Scan',
plot_bgcolor='rgb(230, 230, 230)')
self.fig_box.children = (self.fig, )
def adj_plot_hist(pred,
initial_bin_width=3): # missing the mean simple line plot
pop_mean = [pred.mean()] * len(pred)
figure_widget = go.FigureWidget(data=[
go.Histogram(x=pred, xbins={"size": initial_bin_width}, name='Bin'),
go.Scatter(x=pred[0:], y=pop_mean, mode='lines', name='Predictor Mean')
])
bin_slider = widgets.FloatSlider(
value=initial_bin_width,
min=0,
max=pred.max(),
step=pred.max() / 20,
description="Bin width:",
readout_format=".1f", # display as integer
)
histogram_object = figure_widget.data[0]
def set_bin_size(change):
histogram_object.xbins = {"size": change["new"]}
bin_slider.observe(set_bin_size, names="value")
output_widget = widgets.VBox([figure_widget, bin_slider])
return output_widget
def _create_kde_figure(self, col, bw_method=None, *, selection=None):
if col in self._figures_kde:
self._update_kde_figure(col, selection=selection)
else:
if selection is None:
selection = self.box.inside(self.data)
x_points, y_base, y_select = self._compute_kde(
col, selection, bw_method)
fig = go.FigureWidget(
data=[
go.Scatter(
x=x_points,
y=y_base,
name='Overall',
fill='tozeroy',
marker_color=colors.DEFAULT_BASE_COLOR,
),
go.Scatter(
x=x_points,
y=y_select,
name='Inside',
fill='tozeroy', #fill='tonexty',
marker_color=colors.DEFAULT_HIGHLIGHT_COLOR,
),
],
layout=dict(
showlegend=False,
margin=dict(l=10, r=10, t=10, b=10),
yaxis_showticklabels=False,
**styles.figure_dims,
),
)
fig._figure_kind = 'kde'
self._figures_kde[col] = fig
def apply(x,y,fig_type,l_op,t_op,color='#fff',flip=False):
f=go.FigureWidget()
fig=call_function(x,y,fig_type,color='rgb(255,255,255)',z='def')
f.add_trace(fig['data'][0])
f.layout=fig['layout']
x = pd.Series(np.array(x))
y = pd.Series(np.array(y))
df = pd.concat([x, y],axis=1)
if flip==True:
df, f = flip_axes(x, y)
for l,op in zip(l_op,t_op):
if l=='agg':
if op=='mean':
f.plotly_restyle({'x':[list(df.groupby([0]).mean().index)],'y':[list(df.groupby([0]).mean()[1])]})
if op=='max':
f.plotly_restyle({'x':[list(df.groupby([0]).max().index)],'y':[list(df.groupby([0]).max()[1])]})
if op=='mode':
f.plotly_restyle({'x':[list(df.groupby([0]).mode().index)],'y':[list(df.groupby([0]).mode()[1])]})
if op=='sum':
f.plotly_restyle({'x':[list(df.groupby([0]).sum().index)],'y':[list(df.groupby([0]).sum()[1])]})
if op=='min':
f.plotly_restyle({'x':[list(df.groupby([0]).min().index)],'y':[list(df.groupby([0]).min()[1])]})
if op=='stddev':
f.plotly_restyle({'x':[list(df.groupby([0]).std().index)],'y':[list(df.groupby([0]).std()[1])]})
if op=='count':
f.plotly_restyle({'x':[list(df.groupby([0]).count().index)],'y':[list(df.groupby([0]).count()[1])]})
elif l=='rng':
f.plotly_relayout({'yaxis.range':[op[0],op[1]]})
po.plot(f,auto_open=False,filename='dash10/templates/dash10/plots/plot1.html')
return 'plot1.html'
def plot(self, phase=None, pos=None, name=None):
""" On ajoute à l'affichage de l'Opset une sélection d'instants."""
f = make_subplots(rows=1, cols=1, specs=[[{"type": "scatter"}]])
f = go.FigureWidget(f)
e = self.make_figure(f, phase, pos, name)
out = widgets.interactive(e['update_function'],
colname=e['variable_dropdown'],
sigpos=e['signal_slider'])
bxplot = widgets.VBox([
widgets.HBox([
e['variable_dropdown'], e['previous_button'], e['next_button']
]),
widgets.HBox([f, e['signal_slider']])
])
# Pour info :
# f = tabs.children[0].children[1].children[0]
bxlearn = widgets.VBox([
e['progress_bar'],
widgets.HBox([
widgets.VBox([e['variable_selection'], e['learn_button']]),
widgets.VBox([e['factor_selection'], e['message_label']])
])
])
bxparam = self.param()
tabs = widgets.Tab(children=[bxplot, bxparam, bxlearn])
tabs.set_title(0, "Plot")
tabs.set_title(1, "Param")
tabs.set_title(2, "Learn")
return tabs
def plotlyIsosurface(self, isomin, isomax, title):
'''Return a plotly FigureWidget containing an isosurface representation of the 3D histogram
Args:
isomin (int): minimum value of isosurface colorscale
isomax (int): max value of isosurface colorscale
title (string): title of the plot
'''
# generate X, Y, Z, Values arrays. Plotly needs these as inputs to the Isosurface function. We are storing these as properties
# so that the user could access them to plot more involved isosurface representations from the Jupyter notebook.
self.histo3D_unrolled = np.reshape(self.histo3D[0], [-1])
self.histo3D_unrolled_coords = [[x, y, z]
for z in self.histo3D[1][2][:-1]
for y in self.histo3D[1][1][:-1]
for x in self.histo3D[1][0][:-1]]
data = [
go.Isosurface(x=np.array(self.histo3D_unrolled_coords)[:, 0],
y=np.array(self.histo3D_unrolled_coords)[:, 1],
z=np.array(self.histo3D_unrolled_coords)[:, 2],
value=self.histo3D_unrolled,
isomin=isomin,
isomax=isomax,
colorscale='Blues')
]
layout = go.Layout(title=title)
return go.FigureWidget(data, layout)
def show_plot(coord_x=field_list[0], coord_y=field_list[1], coord_z=field_list[2], coord_color=field_list[3]):
fig = build_plotly_scatter3d(data, field_list, coord_x, coord_y, coord_z, coord_color, None, None)
fig.update_layout(height=500)
widget = go.FigureWidget(fig)
out = Output()
@out.capture(clear_output=True)
def handle_click(trace, points, state):
try:
selected_number = points.point_inds[0]
point = data[selected_number]
res = tabulate.tabulate([i for i in point.items()], floatfmt=".2f")
print("Selected:\n" + res)
size = [15]*len(data)
symbol = ['circle']*len(data)
if selected_number is not None:
size[selected_number] = 25
symbol[selected_number] = 'diamond'
with widget.batch_update():
widget.data[0].marker.size = size
widget.data[0].marker.symbol = symbol
except:
pass
widget.data[0].on_click(handle_click)
display(HBox([widget, out]))
def selection_feature_scores(self):
try:
scores = self._compute_selection_feature_scores().data.iloc[0]
except KeyboardInterrupt:
raise
except:
scores = {}
y = self.scope.get_parameter_names(False)
x = [scores.get(yi, numpy.nan) for yi in y]
fmt = lambda x: x if isinstance(x, str) else "{:.3f}".format(x)
t = [fmt(scores.get(yi, "N/A")) for yi in y]
fig = go.FigureWidget(go.Bar(
x=x,
y=y,
text=t,
orientation='h',
textposition='outside',
texttemplate='%{text}',
marker_color=colors.DEFAULT_HIGHLIGHT_COLOR,
),
layout=dict(
margin=dict(t=0, b=0, l=0, r=0),
height=len(x) * 22,
yaxis_autorange="reversed",
))
self._selection_feature_score_fig = fig
return fig
def _plot_chord_diagram_for_raw_bugs(project_name: str,
project_repo: pygit2.Repository,
bug_set: tp.FrozenSet[PygitBug],
szz_tool: str) -> gob.FigureWidget:
"""Creates a chord diagram representing relations between introducing/fixing
commits for a given set of RawBugs."""
# maps commit hex -> node id
map_commit_to_id: tp.Dict[pygit2.Commit,
int] = _map_commits_to_nodes(project_repo)
commit_type: tp.Dict[pygit2.Commit, NodeType] = {}
commit_count = len(map_commit_to_id.keys())
edge_colors = ['#d4daff', '#84a9dd', '#5588c8', '#6d8acf']
for commit in project_repo.walk(project_repo.head.target.id,
pygit2.GIT_SORT_TIME):
commit_type[commit] = NodeType.DEFAULT
# if less than 2 commits, no graph can be drawn!
if commit_count < 2:
raise PlotDataEmpty
commit_coordinates = _compute_node_placement(commit_count)
# draw relations and preprocess commit types
lines = _generate_line_data(bug_set, commit_coordinates, map_commit_to_id,
commit_type, edge_colors)
nodes = _generate_node_data(project_repo, commit_coordinates,
map_commit_to_id, commit_type)
data = nodes + lines
layout = _create_layout(f'{szz_tool} {project_name}')
return gob.FigureWidget(data=data, layout=layout)
def __init__(self, sample_frequency, number_samples, centre_frequency,
title, height, width):
"""SpectrumPlot constructor
"""
self._centre_frequency = centre_frequency
self._sample_frequency = sample_frequency
self._number_samples = number_samples
self._data = go.Scatter(
x=np.arange(-self._sample_frequency / 2, self._sample_frequency /
2, self._sample_frequency / self._number_samples) +
self._centre_frequency,
y=np.zeros(self._number_samples),
name='Spectrum')
self._plot = go.FigureWidget(data=self._data,
layout={
'title': title,
'height': height,
'width': width,
'xaxis': {
'title': 'Frequency (Hz)'
},
'yaxis': {
'title':
''.join(['Amplitude (dB)']),
'range': [-200, -60]
}
})
def get_optical_reading_plot():
"""Quick plot of a single-patch optical reading over a range of temperatures and DO values, using
a precalculated, hardcoded fit.
"""
temperatures_to_plot = TEMPERATURE_DOMAIN[::5]
return go.FigureWidget(
[
go.Scatter(
x=DO_DOMAIN,
y=get_optical_reading_normalized(DO_DOMAIN, temperature),
mode="lines",
line={
"color": color_from_temperature(temperature),
"width": 1
},
name=f"T={temperature}",
) for temperature in temperatures_to_plot
],
layout={
"title": "Normalized optical reading from a patch",
"xaxis": {
"title": "DO (mmHg)"
},
"yaxis": {
"title": "Optical reading (normalized max=1/min=0)"
},
},
)
def __init__(self, width="col-md-2", height="small"):
self.fig = go.FigureWidget()
self.fig.add_pie(
hole=1,
values=[100],
hoverinfo="none",
textinfo="none",
)
self.fig.layout = go.Layout(
showlegend=False,
autosize=False,
height=self.MODE_CELL_HEIGHT[height],
width=self.MODE_CELL_WIDTH[width],
margin={
"l": 0,
"r": 0,
"t": 0,
"b": 0
},
paper_bgcolor="rgba(0,0,0,0)",
plot_bgcolor="rgba(0,0,0,0)",
annotations=[],
)
def make_scatter(products_df, xcol, ycol, hovercol, tickprefix=''):
f_scatter = go.FigureWidget([
go.Scatter(x=products_df[xcol],
y=products_df[ycol],
mode='markers',
text=[x[:30] for x in products_df[hovercol]],
selected_marker_size=5,
marker_size=3,
selected_marker_color='red',
opacity=.8)
])
scatter = f_scatter.data[0]
N = len(products_df)
scatter.x = scatter.x + np.random.rand(N) / 100 * (
products_df[xcol].max() - products_df[xcol].min())
scatter.y = scatter.y + np.random.rand(N) / 100 * (
products_df[ycol].max() - products_df[ycol].min())
scatter.selectedpoints = list(range(N))
f_scatter.update_layout(xaxis_title=xcol,
yaxis_title=ycol,
xaxis_tickprefix=tickprefix,
plot_bgcolor="#FFFFFF",
xaxis_linecolor="#BCCCDC",
yaxis_linecolor="#BCCCDC",
xaxis_fixedrange=True,
yaxis_fixedrange=True,
dragmode="select",
clickmode="select")
return f_scatter
def display_gantt_chart(G, begin=None, colors=None, reverse_colors=False, index_col='Type',
show_colorbar=True, title=None, bar_width=0.2, showgrid_x=True,
showgrid_y=True, group_tasks=True):
"""
This function displays a Gantt chart representation
of the dependency network
"""
# If a begin date is not provided, use the begin date of G
if begin is None:
begin = G.graph['Begin']
# Convert date string into datetime format
begin = datetime.strptime(begin, '%Y-%m-%d').date()
# If a title is not provided, use the title of G
if title is None:
title = G.graph['Title']
# Convert graph G into a dataframe format that ff.create_gantt() can read
df = to_dataframe(G, begin, index_col)
# Create Gantt chart
fig = ff.create_gantt(df, colors=colors, reverse_colors=reverse_colors, index_col=index_col,
show_colorbar=show_colorbar, title=title, bar_width=bar_width,
showgrid_x=showgrid_x, showgrid_y=showgrid_y, group_tasks=group_tasks)
# Convert Gantt chart into a figure widget and display it
f = go.FigureWidget(fig)
display(f)
def score_table(quality_estimation, field_accuracy) -> go.FigureWidget:
cells = [
["<b>Field Accuracy Score</b>", "<b>Overall Quality Score</b>"],
[
"<b>" + str(field_accuracy) + "<b>",
"<b>" + str(quality_estimation) + "</b>"
],
]
font = dict(color="black", size=20)
trace = go.Table(
header=dict(values=[cells[0][0], cells[1][0]],
fill=dict(color="gray"),
font=font),
cells=dict(
values=[cells[0][1:], cells[1][1:]],
fill=dict(color=[[get_color(quality_estimation)]]),
font=font,
),
)
layout = go.Layout(autosize=True,
margin=dict(l=0, t=25, b=25, r=0),
height=150)
return go.FigureWidget(data=[trace], layout=layout)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._thedata = self._vizapp.get_data('mean-spatial-flux')
self._theoverlay = None
# Slice slider
self._slice_slider = IntSlider(description='Slice #:', max=10)
self._slice_slider.observe(self._slice_slider_on_value_change)
# TODO: refactor this
self._slice_slider.max = self._thedata.shape[0]
# Data selector
self._data_dropdown = Dropdown(description='Data:', options=self._vizapp._1d_data.keys(), multi=True)
self._data_dropdown.observe(self._data_dropdown_on_change)
# Overlay selector
self._overlay_dropdown = Dropdown(description='Overlay:', options=['None'] + list(self._vizapp._1d_data.keys()))
self._overlay_dropdown.observe(self._overlay_dropdown_on_change)
# Processing selector
self._processing_dropdown = Dropdown(description='Processing:', options=['Select...'] + list(self._vizapp.get_1d_processing()))
self._processing_dropdown.observe(self._processing_dropdown_on_change)
self._processing_vbox = VBox([])
self._show_plot()
self._fig = go.FigureWidget(self._gofig)
self._line1 = HBox([self._data_dropdown, self._overlay_dropdown])
def plot_line(df,
y,
fig=None,
color='#FF5949',
domain=dict(x=[0, 1]),
name=None):
fig = go.FigureWidget() if fig is None else fig
fig.layout.template = 'plotly_dark'
if type(df) == list:
for i, d in enumerate(df):
fig.add_trace(
go.Scatter(x=d.index,
y=d[y],
marker=dict(color=color[i]),
name=name[i],
hoverinfo='y'))
# fig.add_trace(go.Scatter(x=d.index, y=d[y], marker=dict(color=color[i]), domain=domain, name=name[i], hoverinfo='y'))
else:
fig.add_trace(
go.Scatter(x=df.index,
y=df[y],
marker=dict(color=color),
name=name))
# fig.add_trace(go.Scatter(x=df.index, y=df[y], marker=dict(color=color), domain=domain, name=name))
return fig
