def create_GUI(self) -> Tuple[widgets.VBox, widgets.interactive_output]:
"""Creates the two main components of the GUI: the qubit and plot option
buttons and the interactive_output that connects the buttons with
the main qubit plot.
Returns
-------
Tuple[ widgets.VBox, widgets.interactive_output ]
"""
qubit_choice_hbox = widgets.HBox([
self.qubit_and_plot_choice_widgets["qubit_buttons"],
self.qubit_and_plot_choice_widgets["show_qubitinfo_checkbox"],
])
plot_choice_hbox = widgets.HBox(
[self.qubit_and_plot_choice_widgets["plot_buttons"]])
qubit_and_plot_choice_widgets = widgets.VBox(
[qubit_choice_hbox, plot_choice_hbox])
qubit_and_plot_choice_interactive = widgets.interactive_output(
self.qubit_plot,
{
"qubit_value":
self.qubit_and_plot_choice_widgets["qubit_buttons"],
"qubit_info":
self.qubit_and_plot_choice_widgets["show_qubitinfo_checkbox"],
"plot_value":
self.qubit_and_plot_choice_widgets["plot_buttons"],
},
)
qubit_and_plot_choice_interactive.layout.width = "975px"
return qubit_and_plot_choice_widgets, qubit_and_plot_choice_interactive
def EvenOdd():
funcs = {
"cos(x)": np.cos,
"cos(2x)": cos2,
"cos(2x)": cos2,
"sin(x)": np.sin,
"x^2": quad,
"Odd Square": oddSquare,
"Even Square": evenSquare
}
f1_drop = widgets.Dropdown(options=funcs)
f2_drop = widgets.Dropdown(options=funcs)
sym_check = widgets.Checkbox(value=False, description="Check Symmetry")
area_check = widgets.Checkbox(value=False,
description="Integration Region")
display(
widgets.VBox([
widgets.HBox([f1_drop, f2_drop, sym_check, area_check]),
widgets.interactive_output(
symmetryCheck, {
'f1': f1_drop,
'f2': f2_drop,
"showSym": sym_check,
"showArea": area_check
})
]))
def show_image_series(image_series: ImageSeries, neurodata_vis_spec: dict):
if len(image_series.data.shape) == 3:
return show_grayscale_image_series(image_series, neurodata_vis_spec)
def show_image(index=0, mode='rgb'):
fig, ax = plt.subplots(subplot_kw={'xticks': [], 'yticks': []})
image = image_series.data[index]
if mode == 'bgr':
image = image[:, :, ::-1]
ax.imshow(image, cmap='gray', aspect='auto')
fig.show()
return fig2widget(fig)
slider = widgets.IntSlider(value=0,
min=0,
max=image_series.data.shape[0] - 1,
orientation='horizontal',
continuous_update=False,
description='index')
mode = widgets.Dropdown(options=('rgb', 'bgr'),
layout=Layout(width='200px'),
description='mode')
controls = {'index': slider, 'mode': mode}
out_fig = widgets.interactive_output(show_image, controls)
vbox = widgets.VBox(children=[out_fig, slider, mode])
return vbox
def i_get_job_script():
from ipywidgets import widgets, Layout, interact_manual
from IPython.display import display, clear_output
from os.path import isfile
inodes = widgets.BoundedIntText(value=1,
min=1,
max=4394,
step=1,
description='nodes',
disabled=False)
iranks_per_node = widgets.BoundedIntText(value=1,
min=1,
max=64,
step=1,
description='ranks/node',
disabled=False)
iaffinity = widgets.Text(value='-d 1 -j 1 --cc depth',
description='affinity')
icommand = widgets.Text(value='', description='executable and args')
out = widgets.interactive_output(
get_job_script, {
'nodes': inodes,
'ranks_per_node': iranks_per_node,
'affinity': iaffinity,
'command': icommand
})
box = widgets.VBox(
[widgets.VBox([inodes, iranks_per_node, iaffinity, icommand]), out])
display(box)
return
def show_image_series(image_series: ImageSeries, neurodata_vis_spec: dict):
if len(image_series.data.shape) == 3:
return show_grayscale_image_series(image_series, neurodata_vis_spec)
def show_image(index=0, mode="rgb"):
fig, ax = plt.subplots(subplot_kw={"xticks": [], "yticks": []})
image = image_series.data[index]
if mode == "bgr":
image = image[:, :, ::-1]
ax.imshow(image.transpose([1, 0, 2]), cmap="gray", aspect="auto")
fig.show()
return fig2widget(fig)
slider = widgets.IntSlider(
value=0,
min=0,
max=image_series.data.shape[0] - 1,
orientation="horizontal",
continuous_update=False,
description="index",
)
mode = widgets.Dropdown(options=("rgb", "bgr"),
layout=Layout(width="200px"),
description="mode")
controls = {"index": slider, "mode": mode}
out_fig = widgets.interactive_output(show_image, controls)
vbox = widgets.VBox(children=[out_fig, slider, mode])
return vbox
def sdof_interact():
"""Create interactive plots of characteristics of SDOF system."""
m_slide = widgets.FloatSlider(min=1e-5, max=20, step=.1, value=5,
continuous_update=False)
k_slide = FloatSlider(min=1e-5, max=1000, step=1., value=100,
continuous_update=False)
c_slide = FloatSlider(min=-1, max=200, step=.1, value=2,
continuous_update=False)
m_label = widgets.Label('Mass')
c_label = Label('Damping')
k_label = Label('Stiffness')
m_slider = widgets.VBox([m_label, m_slide])
c_slider = widgets.VBox([c_label, c_slide])
k_slider = widgets.VBox([k_label, k_slide])
ui = widgets.HBox([m_slider, c_slider, k_slider])
out = widgets.interactive_output(plot_sdof_resp,
{'m': m_slide,
'c': c_slide, 'k': k_slide})
sdof_responses = widgets.VBox([ui, out])
return sdof_responses
def show_decomposition_traces(node: DecompositionSeries):
# Produce figure
def control_plot(x0, x1, ch0, ch1):
fig, ax = plt.subplots(nrows=nBands,
ncols=1,
sharex=True,
figsize=(14, 7))
for bd in range(nBands):
data = node.data[x0:x1, ch0:ch1 + 1, bd]
xx = np.arange(x0, x1)
mu_array = np.mean(data, 0)
sd_array = np.std(data, 0)
offset = np.mean(sd_array) * 5
yticks = [i * offset for i in range(ch1 + 1 - ch0)]
for i in range(ch1 + 1 - ch0):
ax[bd].plot(xx, data[:, i] - mu_array[i] + yticks[i])
ax[bd].set_ylabel('Ch #', fontsize=20)
ax[bd].set_yticks(yticks)
ax[bd].set_yticklabels([str(i) for i in range(ch0, ch1 + 1)])
ax[bd].tick_params(axis='both', which='major', labelsize=16)
ax[bd].set_xlabel('Time [ms]', fontsize=20)
return fig
nSamples = node.data.shape[0]
nChannels = node.data.shape[1]
nBands = node.data.shape[2]
fs = node.rate
# Controls
field_lay = widgets.Layout(max_height='40px',
max_width='100px',
min_height='30px',
min_width='70px')
x0 = widgets.BoundedIntText(value=0,
min=0,
max=int(1000 * nSamples / fs - 100),
layout=field_lay)
x1 = widgets.BoundedIntText(value=nSamples,
min=100,
max=int(1000 * nSamples / fs),
layout=field_lay)
ch0 = widgets.BoundedIntText(value=0,
min=0,
max=int(nChannels - 1),
layout=field_lay)
ch1 = widgets.BoundedIntText(value=10,
min=0,
max=int(nChannels - 1),
layout=field_lay)
controls = {'x0': x0, 'x1': x1, 'ch0': ch0, 'ch1': ch1}
out_fig = widgets.interactive_output(control_plot, controls)
# Assemble layout box
lbl_x = widgets.Label('Time [ms]:', layout=field_lay)
lbl_ch = widgets.Label('Ch #:', layout=field_lay)
lbl_blank = widgets.Label(' ', layout=field_lay)
hbox0 = widgets.HBox(children=[lbl_x, x0, x1, lbl_blank, lbl_ch, ch0, ch1])
vbox = widgets.VBox(children=[hbox0, out_fig])
return vbox
def raster_grid_widget(units: Units):
trials = units.get_ancestor('NWBFile').trials
if trials is None:
return widgets.HTML('No trials present')
groups = infer_categorical_columns(trials)
control_widgets = widgets.VBox(children=[])
rows_controller = widgets.Dropdown(options=[None] + list(groups),
description='rows: ',
layout=Layout(width='95%'))
cols_controller = widgets.Dropdown(options=[None] + list(groups),
description='cols: ',
layout=Layout(width='95%'))
control_widgets.children = list(
control_widgets.children) + [rows_controller, cols_controller]
trial_event_controller = make_trial_event_controller(trials)
control_widgets.children = list(
control_widgets.children) + [trial_event_controller]
unit_controller = int_controller(len(units['spike_times'].data) - 1)
control_widgets.children = list(
control_widgets.children) + [unit_controller]
before_slider = widgets.FloatSlider(.5,
min=0,
max=5.,
description='before (s)',
continuous_update=False)
control_widgets.children = list(control_widgets.children) + [before_slider]
after_slider = widgets.FloatSlider(2.,
min=0,
max=5.,
description='after (s)',
continuous_update=False)
control_widgets.children = list(control_widgets.children) + [after_slider]
controls = {
'units': fixed(units),
'trials': fixed(trials),
'index': unit_controller.children[0],
'after': after_slider,
'before': before_slider,
'align_by': trial_event_controller,
'rows_label': rows_controller,
'cols_label': cols_controller
}
out_fig = widgets.interactive_output(raster_grid, controls)
vbox = widgets.VBox(children=[control_widgets, out_fig])
return vbox
def __init__(self, tfms=Blur, debug=False, image=coffee()):
self.image = image
self.debug = debug
self.tfms = tfms
self.interact_wds = {}
k = get_default_args(tfms)
if self.debug:
print(k)
ui = self.ui_prepare(k)
out = widgets.interactive_output(self.f, self.interact_wds)
display(ui, out)
def start(self):
button = widgets.Button(description="Reset")
button.on_click(self.on_button_clicked)
main = widgets.HBox([self.text, button])
u1 = widgets.HBox([self.sliders[str(i)] for i in range(0, 4)])
u2 = widgets.HBox([self.sliders[str(i)] for i in range(4, 8)])
u3 = widgets.HBox([self.sliders[str(i)] for i in range(8, 12)])
u4 = widgets.HBox([self.sliders[str(i)] for i in range(12, 16)])
out = widgets.interactive_output(self.affineTransform, self.sliders)
display(main, u1, u2, u3, u4, out)
def show_spike_event_series(ses: SpikeEventSeries, **kwargs):
def control_plot(spk_ind):
fig, ax = plt.subplots(figsize=(9, 5))
data = ses.data[spk_ind]
if nChannels > 1:
for ch in range(nChannels):
ax.plot(data[:, ch], color="#d9d9d9")
else:
ax.plot(data[:], color="#d9d9d9")
ax.plot(np.mean(data, axis=1), color="k")
ax.set_xlabel("Time")
ax.set_ylabel("Amplitude")
fig.show()
return fig2widget(fig)
if len(ses.data.shape) == 3:
nChannels = ses.data.shape[2]
else:
nChannels = ses.data.shape[1]
nSpikes = ses.data.shape[0]
# Controls
field_lay = widgets.Layout(max_height="40px",
max_width="100px",
min_height="30px",
min_width="70px")
spk_ind = widgets.BoundedIntText(value=0,
min=0,
max=nSpikes - 1,
layout=field_lay)
controls = {"spk_ind": spk_ind}
out_fig = widgets.interactive_output(control_plot, controls)
# Assemble layout box
lbl_spk = widgets.Label("Spike ID:", layout=field_lay)
lbl_nspks0 = widgets.Label("N° spikes:", layout=field_lay)
lbl_nspks1 = widgets.Label(str(nSpikes), layout=field_lay)
lbl_nch0 = widgets.Label("N° channels:", layout=field_lay)
lbl_nch1 = widgets.Label(str(nChannels), layout=field_lay)
hbox0 = widgets.HBox(children=[lbl_spk, spk_ind])
vbox0 = widgets.VBox(children=[
widgets.HBox(children=[lbl_nspks0, lbl_nspks1]),
widgets.HBox(children=[lbl_nch0, lbl_nch1]),
hbox0,
])
hbox1 = widgets.HBox(children=[vbox0, out_fig])
return hbox1
def preview_dataset(dataset,
preview_index=0,
show_hist=False,
use_transform=False):
data, label = dataset.get_raw_item_with_label_filter(
preview_index) # equivalent dataset[preview_index]
if use_transform:
transform = get_dataset_transform()
data, label = transform_input(data, label, transform)
max_channels = label.shape[0]
max_slices = label.shape[1]
print(f'data max {data.max()}, min {data.min()}')
print(f'label max {label.max()}, min {label.min()}')
def f(slice_index, label_channel):
plt.figure(figsize=(20, 10))
plt.subplot(1, 2, 1)
plt.imshow(data[0, slice_index], cmap="gray")
plt.subplot(1, 2, 2)
plt.imshow(label[label_channel, slice_index])
plt.show()
if show_hist:
plt.figure(figsize=(20, 10))
plt.subplot(1, 2, 1)
plt.hist(data.flatten(), 128)
plt.subplot(1, 2, 2)
plt.hist(label.flatten(), 128)
plt.show()
sliceSlider = widgets.IntSlider(min=0,
max=max_slices - 1,
step=1,
value=(max_slices - 1) / 2)
labelChannelSlider = widgets.IntSlider(min=0,
max=max_channels - 1,
step=1,
value=(max_channels - 1) / 2)
ui = widgets.VBox([widgets.HBox([sliceSlider, labelChannelSlider])])
out = widgets.interactive_output(f, {
'slice_index': sliceSlider,
'label_channel': labelChannelSlider
})
# noinspection PyTypeChecker
display(ui, out)
def FilterFreqs(audioData, freqDom, freqs):
"""
Produces UI componants for user. Drives plotting of filtered signal (FilterFreqs)
----------
Parameters
----------
audioData: array_like
raw audio data
freqDom: array_like
transformed frequnecy domain data
freqs: array_like
frequencies
"""
filter_sldr = widgets.IntRangeSlider(value=[0, 0],
min=0,
max=23e3,
step=1000,
continuous_update=False,
description='Freq Band')
xlim_sldr = widgets.IntRangeSlider(value=[0, 22.5e3],
min=0,
max=22.5e3,
step=1000,
continuous_update=False,
description='Ax. lim')
export_btn = widgets.ToggleButton(value=False,
description='Export to .wav')
display(
widgets.VBox([
widgets.interactive_output(
FilterBand, {
'audioData': widgets.fixed(audioData),
'freqDom': widgets.fixed(freqDom),
'freqs': widgets.fixed(freqs),
'filtFreq': filter_sldr,
'FALim': xlim_sldr,
'export': export_btn
}),
widgets.HBox([xlim_sldr, filter_sldr, export_btn])
]))
def raster_widget(units: Units,
unit_controller=None,
time_window_controller=None):
if time_window_controller is None:
tmin = get_min_spike_time(units)
tmax = get_max_spike_time(units)
time_window_controller = float_range_controller(tmin, tmax)
if unit_controller is None:
unit_controller = int_range_controller(len(units['spike_times'].data) -
1,
start_range=(0, 100))
candidate_cols = [
x for x in units.colnames if not isinstance(units[x][0], Iterable)
or isinstance(units[x][0], str)
]
groups = infer_categorical_columns(units)
group_controller = widgets.Dropdown(options=[None] + list(groups),
description='color by',
layout=Layout(width='90%'))
features = [
x for x in candidate_cols if len(robust_unique(units[x][:])) > 1
]
order_by_controller = widgets.Dropdown(options=[None] + features,
description='order by',
layout=Layout(width='90%'))
controls = {
'units': fixed(units),
'time_window': time_window_controller.children[0],
'units_window': unit_controller.children[0],
'group_by': group_controller,
'order_by': order_by_controller,
}
out_fig = widgets.interactive_output(show_session_raster, controls)
color_and_order_box = widgets.VBox(children=(group_controller,
order_by_controller),
layout=Layout(width='250px'))
control_widgets = widgets.HBox(children=(time_window_controller,
unit_controller,
color_and_order_box))
vbox = widgets.VBox(children=[control_widgets, out_fig])
return vbox
def show_grayscale_image_series(image_series: ImageSeries,
neurodata_vis_spec: dict):
def show_image(index=0):
fig, ax = plt.subplots(subplot_kw={'xticks': [], 'yticks': []})
ax.imshow(image_series.data[index], cmap='gray', aspect='auto')
return fig
slider = widgets.IntSlider(value=0,
min=0,
max=image_series.data.shape[0] - 1,
orientation='horizontal',
continuous_update=False,
description='index')
controls = {'index': slider}
out_fig = widgets.interactive_output(show_image, controls)
vbox = widgets.VBox(children=[out_fig, slider])
return vbox
def single_trace_widget(timeseries: TimeSeries, time_window_controller=None):
controls = dict(timeseries=fixed(timeseries))
gen_time_window_controller = False
if time_window_controller is None:
gen_time_window_controller = True
tmin = get_timeseries_mint(timeseries)
tmax = get_timeseries_maxt(timeseries)
time_window_controller = RangeController(tmin, tmax, start_value=[tmin, min(tmin+30, tmax)])
controls.update(time_window=time_window_controller.slider)
out_fig = widgets.interactive_output(show_trace, controls)
if gen_time_window_controller:
return widgets.VBox(children=[time_window_controller, out_fig])
else:
return widgets.VBox(children=[out_fig])
def show_spike_event_series(ses, **kwargs):
def control_plot(spk_ind):
fig, ax = plt.subplots(figsize=(9, 5))
data = ses.data[spk_ind, :, :]
for ch in range(nChannels):
ax.plot(data[:, ch], color='#d9d9d9')
ax.plot(np.mean(data, axis=1), color='k')
ax.set_xlabel('Time')
ax.set_ylabel('Amplitude')
plt.show()
return fig2widget(fig)
nChannels = ses.data.shape[2]
nSpikes = ses.data.shape[0]
# Controls
field_lay = widgets.Layout(max_height='40px',
max_width='100px',
min_height='30px',
min_width='70px')
spk_ind = widgets.BoundedIntText(value=0,
min=0,
max=nSpikes - 1,
layout=field_lay)
controls = {'spk_ind': spk_ind}
out_fig = widgets.interactive_output(control_plot, controls)
# Assemble layout box
lbl_spk = widgets.Label('Spike ID:', layout=field_lay)
lbl_nspks0 = widgets.Label('N° spikes:', layout=field_lay)
lbl_nspks1 = widgets.Label(str(nSpikes), layout=field_lay)
lbl_nch0 = widgets.Label('N° channels:', layout=field_lay)
lbl_nch1 = widgets.Label(str(nChannels), layout=field_lay)
hbox0 = widgets.HBox(children=[lbl_spk, spk_ind])
vbox0 = widgets.VBox(children=[
widgets.HBox(children=[lbl_nspks0, lbl_nspks1]),
widgets.HBox(children=[lbl_nch0, lbl_nch1]), hbox0
])
hbox1 = widgets.HBox(children=[vbox0, out_fig])
return hbox1
def traces_widget(node: TimeSeries,
neurodata_vis_spec: dict = None,
time_window_controller=None,
start=None,
dur=None,
trace_controller=None,
trace_starting_range=None,
**kwargs):
if time_window_controller is None:
tmax = get_timeseries_maxt(node)
tmin = get_timeseries_mint(node)
if start is None:
start = tmin
if dur is None:
dur = min(tmax - tmin, 5)
time_window_controller = make_time_window_controller(tmin,
tmax,
start=start,
duration=dur)
if trace_controller is None:
if trace_starting_range is None:
trace_starting_range = (0, min(30, node.data.shape[1]))
trace_controller = int_range_controller(
node.data.shape[1], start_range=trace_starting_range)
controls = {
'time_series': widgets.fixed(node),
'time_start': time_window_controller.children[0].children[0],
'time_duration': time_window_controller.children[0].children[1],
'trace_window': trace_controller.children[0],
}
controls.update({key: widgets.fixed(val) for key, val in kwargs.items()})
out_fig = widgets.interactive_output(plot_traces, controls)
control_widgets = widgets.HBox(children=(time_window_controller,
trace_controller))
vbox = widgets.VBox(children=[control_widgets, out_fig])
return vbox
def traces_widget(node: TimeSeries, neurodata_vis_spec: dict = None,
time_window_controller=None, start=None, dur=None,
trace_controller=None, trace_starting_range=None,
**kwargs):
if time_window_controller is None:
tmax = get_timeseries_maxt(node)
tmin = get_timeseries_mint(node)
if start is None:
start = tmin
if dur is None:
dur = min(tmax-tmin, 5)
time_window_controller = StartAndDurationController(tmax, tmin, start=start, duration=dur)
if trace_controller is None:
if trace_starting_range is None:
trace_starting_range = (0, min(30, node.data.shape[1]))
trace_controller = RangeController(0, node.data.shape[1], start_range=trace_starting_range,
description='channels', dtype='int', orientation='vertical')
controls = {
'time_series': widgets.fixed(node),
'time_window': time_window_controller,
'trace_window': trace_controller.slider,
}
controls.update({key: widgets.fixed(val) for key, val in kwargs.items()})
out_fig = widgets.interactive_output(plot_traces, controls)
lower = widgets.HBox(children=[
trace_controller,
out_fig
])
out = widgets.VBox(children=[
time_window_controller,
lower
])
return out
def debug_preview_model_output(low_res_data_img, low_res_label_img, model_output_img):
# preview of 32x32 segmentation and his expanded 512x512 version
def f(slice_index):
plt.figure(figsize=(18, 12))
plt.subplot(1, 3, 1).set_title('low res data')
plt.imshow(low_res_data_img[0, slice_index], cmap="gray")
plt.subplot(1, 3, 2).set_title('low res label')
plt.imshow(low_res_label_img[slice_index], cmap="gray")
plt.subplot(1, 3, 3).set_title('low res model output')
plt.imshow(model_output_img[0, 0, slice_index], cmap="gray", vmin=0, vmax=1)
plt.show()
slices_count = model_output_img[0, 0].shape[0] - 1
sliceSlider = widgets.IntSlider(min=0, max=slices_count, step=1, value=slices_count // 2)
ui = widgets.VBox([widgets.HBox([sliceSlider])])
out = widgets.interactive_output(f, {'slice_index': sliceSlider})
# noinspection PyTypeChecker
display(ui, out)
def symmetryCheck(f1, f2, showSym, showArea):
a_slider = widgets.FloatSlider(value=1,
min=0,
max=np.pi,
step=0.1,
continuous_update=False)
if not showSym:
displayEvenOdd(f1, f2, showArea)
else:
display(
widgets.VBox([
a_slider,
widgets.interactive_output(
displayEvenOdd, {
"f1": widgets.fixed(f1),
"f2": widgets.fixed(f2),
"showArea": widgets.fixed(showArea),
"a": a_slider
})
]))
def interact():
from ipywidgets import interactive, fixed, widgets, interact_manual
from IPython.display import display
from ipywidgets import AppLayout, Button, Layout
target_values_options = list(df["{}"].unique())
features_options = list(df.columns.values)
features_options.remove("{}")
w1 = widgets.SelectMultiple(
options=target_values_options,
value=target_values_options,
rows=len(target_values_options),
description="Target Values (column: {})",
style={{
"description_width": "initial"
}},
disabled=False,
)
w2 = widgets.SelectMultiple(
options=features_options,
value=features_options[0:min(len(features_options), 2)],
rows=len(features_options),
description="Features",
disabled=False,
)
ui = widgets.HBox([w1, w2])
out = widgets.interactive_output(
pairwise_scatter_plots,
{{
"df": fixed(df),
"target_values": w1,
"features": w2
}},
)
display(ui, out)
def FourierSeries():
"""
Main function called by notebook
"""
terms_sldr = widgets.IntSlider(value=3,
description='Terms',
min=2,
max=100,
display=False,
continuous_update=False)
func_drp = widgets.Dropdown(options=['Linear', 'Square Wave', 'Cubic'],
description='Function')
prevTerm_check = widgets.Checkbox(value=False,
description='Show most recent term')
return widgets.VBox([
widgets.HBox([terms_sldr, func_drp, prevTerm_check]),
widgets.interactive_output(
fourierMain, {
'function': func_drp,
'nMax': terms_sldr,
'showPrevTerm': prevTerm_check
})
])
def RandomWave():
""" Main function called by notebook
"""
noWaves_sldr = widgets.IntSlider(value=10,
min=2,
max=20,
step=1,
description='No. Waves',
continuous_update=False)
seed_Text = widgets.IntText(123, description='Seed')
filter_sldr = widgets.FloatRangeSlider(value=[minf, minf],
min=minf,
max=maxf,
description="Filter Range",
continuous_update=False)
return widgets.VBox([
widgets.HBox([noWaves_sldr, filter_sldr, seed_Text]),
widgets.interactive_output(runWaves, {
'noWaves': noWaves_sldr,
'seed': seed_Text,
'filterRange': filter_sldr
})
])
def preview_3d_image(img,
figsize=(16, 16),
show_slice=None,
show_unique=False,
minmax=False):
if type(img) is sitk.SimpleITK.Image:
img = sitk.GetArrayFromImage(img)
max_slices = img.shape[0]
def f(slice_index):
plt.figure(figsize=figsize)
if minmax:
plt.imshow(img[slice_index], vmin=np.min(img), vmax=np.max(img))
else:
plt.imshow(img[slice_index])
plt.show()
if show_unique:
print(f"debug: {img.min()}, {img.max()}")
print(f"debug: unique {np.unique(img[slice_index])}")
if show_slice:
sliceSlider = widgets.IntSlider(min=0,
max=max_slices - 1,
step=1,
value=show_slice)
else:
sliceSlider = widgets.IntSlider(min=0,
max=max_slices - 1,
step=1,
value=(max_slices - 1) / 2)
ui = widgets.VBox([widgets.HBox([sliceSlider])])
out = widgets.interactive_output(f, {'slice_index': sliceSlider})
# noinspection PyTypeChecker
display(ui, out)
def show_email_draft_area():
field_map = {
r['prop']: make_text_input(r)
for r in TakedownStore.input_fields
}
inputs = list(field_map.values())
def make_email_draft(**kwargs):
letter_date = datetime.date.isoformat(datetime.date.today())
# doc_urls = make_html_url_list(TakedownStore.data_store.infringing_docs)
doc_urls = make_infringing_lists(
TakedownStore.data_store.infringing_doc_tuples)
with open('{}/takedown_request.html'.format(env.TEMPLATE_FOLDER),
'r') as o:
template = o.read()
formatted = template.format(letter_date=letter_date,
doc_urls=doc_urls,
**kwargs)
return display(widgets.HTML(value=formatted))
# Show the email draft and fields to fill it in
email_out = widgets.interactive_output(make_email_draft, field_map)
return display(widgets.VBox([widgets.VBox(inputs), email_out]))
def MusicNote(audioData, freqDom, freqs):
"""
Produces UI componants for user. Drives plotting of PlotFourierAnalysis
----------
Parameters
----------
audioData: array_like
raw audio data
freqDom: array_like
transformed frequency domain data
freqs: array_like
frequencies
"""
xlim_sldr = widgets.IntRangeSlider(value=[0, 22.5e3],
min=0,
max=22.5e3,
step=1000,
continuous_update=False,
description='Ax. lim')
return widgets.VBox([
widgets.interactive_output(
PlotSignal, {
'signal': widgets.fixed(audioData),
'amps': widgets.fixed(freqDom),
'freqs': widgets.fixed(freqs),
'FALim': xlim_sldr
}),
widgets.HBox([xlim_sldr])
])
def debug_preview_cuts(exp_model_output_img, new_bounding_box, data_cut, label_cut):
def f(slice_index):
tmp_cut = exp_model_output_img[0, 0, new_bounding_box[0]:new_bounding_box[1] + 1,
new_bounding_box[2]:new_bounding_box[3] + 1, new_bounding_box[4]:new_bounding_box[5] + 1]
plt.figure(figsize=(18, 12))
plt.subplot(1, 3, 1).set_title('low res model output')
plt.imshow(tmp_cut[slice_index], cmap="gray", vmin=0, vmax=1)
plt.subplot(1, 3, 2).set_title('data cut')
plt.imshow(data_cut[0, slice_index], cmap="gray")
plt.subplot(1, 3, 3).set_title('label cut')
plt.imshow(label_cut[slice_index])
plt.show()
slices_count = label_cut.shape[0] - 1
sliceSlider = widgets.IntSlider(min=0, max=slices_count, step=1, value=slices_count // 2)
ui = widgets.VBox([widgets.HBox([sliceSlider])])
out = widgets.interactive_output(f, {'slice_index': sliceSlider})
# noinspection PyTypeChecker
display(ui, out)
def interact_plot_model_prism(self):
plot = widgets.RadioButtons(
options=["field", "model"],
value="field",
description="plot",
disabled=False,
)
component = widgets.RadioButtons(
options=["Bt", "Bx", "By", "Bz"],
value="Bt",
description="field",
disabled=False,
)
inclination = widgets.FloatSlider(description="I",
continuous_update=False,
min=-90,
max=90,
step=1,
value=90)
declination = widgets.FloatSlider(description="D",
continuous_update=False,
min=-180,
max=180,
step=1,
value=0)
length = widgets.FloatSlider(
description="length",
continuous_update=False,
min=2,
max=200,
step=1,
value=72,
)
dx = widgets.FloatSlider(
description="data spacing",
continuous_update=False,
min=0.1,
max=15,
step=0.1,
value=2,
)
kappa = widgets.FloatText(description="$\kappa$", value=0.1)
B0 = widgets.FloatText(description="B$_0$", value=56000)
depth = widgets.FloatSlider(
description="depth",
continuous_update=False,
min=0,
max=50,
step=1,
value=10,
)
profile = widgets.RadioButtons(
options=["East", "North", "None"],
value="East",
description="profile",
disabled=False,
)
fixed_scale = widgets.Checkbox(value=False,
description="fixed scale",
disabled=False)
show_halfwidth = widgets.Checkbox(value=False,
description="half width",
disabled=False)
prism_dx = widgets.FloatText(description="$\\triangle x$", value=1)
prism_dy = widgets.FloatText(description="$\\triangle y$", value=1)
prism_dz = widgets.FloatText(description="$\\triangle z$", value=1)
prism_inclination = widgets.FloatSlider(
description="I$_{prism}$",
continuous_update=False,
min=-90,
max=90,
step=1,
value=0,
)
prism_declination = widgets.FloatSlider(
description="D$_{prism}$",
continuous_update=False,
min=0,
max=180,
step=1,
value=0,
)
out = widgets.interactive_output(
self.magnetic_prism_applet,
{
"plot": plot,
"component": component,
"inclination": inclination,
"declination": declination,
"length": length,
"dx": dx,
"kappa": kappa,
"B0": B0,
"depth": depth,
"profile": profile,
"fixed_scale": fixed_scale,
"show_halfwidth": show_halfwidth,
"prism_dx": prism_dx,
"prism_dy": prism_dy,
"prism_dz": prism_dz,
"prism_inclination": prism_inclination,
"prism_declination": prism_declination,
},
)
left = widgets.VBox(
[plot, component, profile],
layout=Layout(width="20%",
height="400px",
margin="60px 0px 0px 0px"),
)
right = widgets.VBox(
[
inclination,
declination,
length,
dx,
B0,
kappa,
depth,
prism_dx,
prism_dy,
prism_dz,
prism_inclination,
prism_declination,
fixed_scale,
show_halfwidth,
],
layout=Layout(width="50%",
height="400px",
margin="20px 0px 0px 0px"),
)
widgets.VBox([out],
layout=Layout(width="70%",
height="400px",
margin="0px 0px 0px 0px"))
return widgets.HBox([left, out, right])
def interact_plot_model_two_monopole(self):
component = widgets.RadioButtons(
options=["Bt", "Bx", "By", "Bz", "Bg"],
value="Bt",
description="field",
disabled=False,
)
inclination = widgets.FloatSlider(description="I",
continuous_update=False,
min=-90,
max=90,
step=1,
value=90)
declination = widgets.FloatSlider(description="D",
continuous_update=False,
min=-180,
max=180,
step=1,
value=0)
length = widgets.FloatSlider(
description="length",
continuous_update=False,
min=2,
max=200,
step=1,
value=10,
)
dx = widgets.FloatSlider(
description="data spacing",
continuous_update=False,
min=0.1,
max=15,
step=0.1,
value=0.1,
)
moment = widgets.FloatText(description="M", value=30)
depth_n = widgets.FloatSlider(
description="depth$_{-Q}$",
continuous_update=False,
min=0,
max=200,
step=1,
value=0,
)
depth_p = widgets.FloatSlider(
description="depth$_{+Q}$",
continuous_update=False,
min=0,
max=200,
step=1,
value=1,
)
profile = widgets.RadioButtons(
options=["East", "North", "None"],
value="East",
description="profile",
disabled=False,
)
fixed_scale = widgets.Checkbox(value=False,
description="fixed scale",
disabled=False)
show_halfwidth = widgets.Checkbox(value=False,
description="half width",
disabled=False)
out = widgets.interactive_output(
self.magnetic_two_monopole_applet,
{
"component": component,
"inclination": inclination,
"declination": declination,
"length": length,
"dx": dx,
"moment": moment,
"depth_n": depth_n,
"depth_p": depth_p,
"profile": profile,
"fixed_scale": fixed_scale,
"show_halfwidth": show_halfwidth,
},
)
left = widgets.VBox(
[component, profile],
layout=Layout(width="20%",
height="400px",
margin="60px 0px 0px 0px"),
)
right = widgets.VBox(
[
inclination,
declination,
length,
dx,
moment,
depth_n,
depth_p,
fixed_scale,
show_halfwidth,
],
layout=Layout(width="50%",
height="400px",
margin="20px 0px 0px 0px"),
)
widgets.VBox([out],
layout=Layout(width="70%",
height="400px",
margin="0px 0px 0px 0px"))
return widgets.HBox([left, out, right])