def __init__(self, rl_ch=12, ud_ch=13, bus=1):
self.sg = ServoGroup(rl_ch=rl_ch, ud_ch=ud_ch, bus=bus)
self.sg.reset() #Pan and tilt go to default position
#Setup various widgets
self.panel_step_move = NineButton(
button_list=['↖', '↑', '↗', '←', 'reset', '→', '↙', '↓', '↘'])
self.panel_far_move = NineButton(
button_list=['◤', '▲', '◥', '◄', 'reset', '►', '◣', '▼', '◢'])
self.image_widget = widgets.Image(
format='jpeg', width=400, height=300) #Display resolution setting
self.snap_count = widgets.IntText(description='count:',
layout=widgets.Layout(width='140px'),
value=0)
self.rl_textbox = widgets.IntText(layout=widgets.Layout(width='140px'),
value=self.sg.read()[0],
description='rl:')
self.ud_textbox = widgets.IntText(layout=widgets.Layout(width='140px'),
value=self.sg.read()[1],
description='ud:')
self.rl_slider = widgets.FloatSlider(min=-1,
max=1,
value=0,
step=0.02,
description='rl')
self.ud_slider = widgets.FloatSlider(min=-1,
max=1,
value=0,
step=0.02,
description='ud')
self.snap_dir = 'snap' #Folder name for saving snapshot
self.camera_link = None
self.press_count = 0
def __init__(self, xlim=(-1.2, 1.2), ylim=(-1.2, 1.2), data=None):
self.xlim = xlim
self.ylim = ylim
input_x = np.arange(xlim[0], xlim[1], 0.1)
input_y = np.arange(ylim[0], ylim[1], 0.1)
self.input_x_matrix, self.input_y_matrix = np.meshgrid(
input_x, input_y)
self.inputs_xy = np.concatenate(
(self.input_x_matrix.flatten()[:, np.newaxis],
self.input_y_matrix.flatten()[:, np.newaxis]),
axis=1)
self.activation_functions_dict = {
'Linear': linear,
'Sigmoid': sigmoid,
'Hyperbolic tangent': htan,
'Gaussian': gaussian
}
self.data = data
if len(data) > 0:
self.c1_i = data[:, 2] > 0
self.c2_i = data[:, 2] < 0
self.error = []
self.ax_line = None
self.ax_im = None
weight_x_slider = widgets.FloatSlider(
value=0.5,
min=-2.0,
max=2.0,
step=0.01,
description='Weight x:',
)
weight_y_slider = widgets.FloatSlider(
value=0.5,
min=-2.0,
max=2.0,
step=0.01,
description='Weight y:',
)
bias_slider = widgets.FloatSlider(
value=0.0,
min=-2.0,
max=2.0,
step=0.01,
description='Bias:',
)
activation_function_list = widgets.Dropdown(
options={
list(self.activation_functions_dict.keys())[i]: i
for i in range(len(self.activation_functions_dict))
},
value=1,
description='Activation function:',
)
self.controls = {
'weight_x': weight_x_slider,
'weight_y': weight_y_slider,
'bias': bias_slider,
'activation_function_index': activation_function_list
}
def overlayViewer(im4d, overlay3d, zz=0, tt=0, th=0, oa=1, im_range=None, o_range=None):
tt_enable = True
if im4d.ndim == 3:
im4d = im4d[:,:,:,np.newaxis]
tt_enable = False
out = widgets.Output()
zz_slider = widgets.IntSlider(min=0, max=im4d.shape[2]-1, step=1, value=zz)
tt_slider = widgets.IntSlider(min=0, max=im4d.shape[3]-1, step=1, value=tt)
oa_slider = widgets.FloatSlider(min=0, max=1, step=0.1, value=oa)
if issubclass(overlay3d.dtype.type, np.integer) or overlay3d.dtype == np.bool:
th = 1
th_slider = widgets.IntSlider(min=np.amin(overlay3d), max=np.amax(overlay3d), step=1, value=th)
th_slider.visible = False
oa_slider.visible = True
else:
th_slider = widgets.FloatSlider(min=np.amin(overlay3d), max=np.amax(overlay3d), step=0.01, value=th)
oa_slider.visible = False
overlay_button = widgets.ToggleButton(description='Overlay', value=True)
if not tt_enable:
tt_slider.visible = False
with warnings.catch_warnings():
warnings.simplefilter('ignore')
w = widgets.interactive(overlayShow, recon=widgets.fixed(im4d), overlay3d=widgets.fixed(overlay3d),
zz=zz_slider, tt=tt_slider, th=th_slider, oa=oa_slider, oe=overlay_button,
im_range=widgets.fixed(im_range), o_range=widgets.fixed(o_range), out=widgets.fixed(out))
wo = widgets.HBox(children=(w,out))
display(wo)
def plot_interactive_riemann(plot_riemann):
ql_widget = widgets.FloatSlider(min=0.,
max=1.,
value=0.5,
description=r'$q_l$')
qr_widget = widgets.FloatSlider(min=0.,
max=1.,
value=0.0,
description=r'$q_r$')
t_widget = widgets.FloatSlider(min=0.,
max=1.,
value=0.1,
description=r'$t$')
x_range_widget = widgets.FloatSlider(min=0.1,
max=5,
value=1.,
description=r'x-axis range')
interact_gui = widgets.HBox(
[t_widget,
widgets.VBox([ql_widget, qr_widget]), x_range_widget])
burgers_widget = interact(plot_riemann,
q_l=ql_widget,
q_r=qr_widget,
t=t_widget,
x_range=x_range_widget)
burgers_widget.widget.close()
display(interact_gui)
display(burgers_widget.widget.out)
def decompose_q_interactive():
"""plots interactive decomposed eigenvectors."""
pwidget = widgets.FloatSlider(min=-1, max=1, value=1.)
uwidget = widgets.FloatSlider(min=-1, max=1, value=0.3)
rhowidget = widgets.FloatSlider(min=0.1,
max=2,
value=1.,
description=r'$\rho$')
Kwidget = widgets.FloatSlider(min=0.1, max=2, value=1.)
interact_gui = widgets.VBox(
[widgets.HBox([pwidget, rhowidget]),
widgets.HBox([uwidget, Kwidget])])
mainwidget = interact(decompose_q,
p=pwidget,
u=uwidget,
rho=rhowidget,
K=Kwidget)
try:
mainwidget.widget.close()
display(interact_gui)
display(mainwidget.widget.out)
except:
pass
def riemann_solution_interact():
rho_l_widget = widgets.FloatSlider(min=0.,
max=1.,
value=0.5,
description=r'$\rho_l$')
rho_r_widget = widgets.FloatSlider(min=0.,
max=1.,
value=0.,
description=r'$\rho_r$')
t_widget = widgets.FloatSlider(min=0., max=1., value=0.1)
x_range_widget = widgets.FloatSlider(min=0.1,
max=5,
value=1.,
description=r'x-axis range')
params = widgets.HBox(
[t_widget,
widgets.VBox([rho_l_widget, rho_r_widget]), x_range_widget])
traffic_widget = interact(plot_riemann_traffic,
rho_l=rho_l_widget,
rho_r=rho_r_widget,
t=t_widget,
xrange=x_range_widget)
if traffic_widget: # Avoid crash when using snapshot_widgets
try:
traffic_widget.widget.close()
display(params)
display(traffic_widget.widget.out)
except:
pass
def show_p():
interact(p,
bonus_ad=widgets.FloatSlider(value=0,
min=0,
max=400,
step=5,
description='Bonus AD',
continuous_update=False),
enemy_mr=widgets.FloatSlider(value=30,
min=30,
max=400,
step=5,
description='Enemy MR',
continuous_update=False),
pen_flat=widgets.FloatSlider(value=0,
min=0,
max=60,
step=1,
description='Magic Penetration',
continuous_update=False),
pen_perc=widgets.FloatSlider(value=0,
min=0,
max=100,
step=1,
description='Magic Penetration %',
continuous_update=False))
def __init__(self, units: Units, unit_index=0):
super().__init__()
self.units = units
self.trials = self.get_trials()
if self.trials is None:
self.children = [widgets.HTML('No trials present')]
return
groups = list(self.trials.colnames)
rows_controller = widgets.Dropdown(options=[None] + list(groups),
description='rows')
cols_controller = widgets.Dropdown(options=[None] + list(groups),
description='cols')
trial_event_controller = make_trial_event_controller(self.trials)
unit_controller = widgets.Dropdown(options=range(
len(units['spike_times'].data)),
value=unit_index,
description='unit')
before_slider = widgets.FloatSlider(.1,
min=0,
max=5.,
description='before (s)',
continuous_update=False)
after_slider = widgets.FloatSlider(1.,
min=0,
max=5.,
description='after (s)',
continuous_update=False)
self.controls = {
'units': fixed(units),
'time_intervals': fixed(self.trials),
'index': unit_controller,
'after': after_slider,
'before': before_slider,
'align_by': trial_event_controller,
'rows_label': rows_controller,
'cols_label': cols_controller
}
self.children = [
unit_controller,
rows_controller,
cols_controller,
trial_event_controller,
before_slider,
after_slider,
]
self.select_trials()
out_fig = interactive_output(raster_grid, self.controls,
self.process_controls)
self.children = list(self.children) + [out_fig]
def select_profile(self, roi_left=0, roi_top=0, roi_height=-1, roi_width=-1):
self.integrated_data = self.__calculate_integrated_data()
self.image_dimension = np.shape(self.integrated_data)
[self.height, self.width] = self.image_dimension
if roi_height == -1:
roi_height = self.height - 1
if roi_width == -1:
roi_width = self.width - 1
def plot_images_with_roi(x_left, y_top, width, height, contrast_min, contrast_max):
plt.figure(figsize=(5, 5))
ax_img = plt.subplot(111)
ax_img.imshow(self.integrated_data, cmap='rainbow',
interpolation=None,
vmin = contrast_min,
vmax = contrast_max)
ax_img.add_patch(patches.Rectangle((x_left, y_top), width, height, fill=False))
return [x_left, y_top, width, height]
self.profile = interact(plot_images_with_roi,
x_left=widgets.IntSlider(min=0,
max=self.width - 1,
step=1,
value=roi_left,
continuous_update=False),
y_top=widgets.IntSlider(min=0,
max=self.height - 1,
step=1,
value=roi_top,
continuous_update=False),
width=widgets.IntSlider(min=0,
max=self.width - 1,
step=1,
value=roi_width,
continuous_update=False),
height=widgets.IntSlider(min=0,
max=self.height - 1,
step=1,
value=roi_height,
continuous_update=False),
contrast_min=widgets.FloatSlider(min=0,
max=1,
step=0.1,
value=0,
continuous_update=False),
contrast_max=widgets.FloatSlider(min=0,
max=2,
value=1,
step=0.1,
continuous_update=False))
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 euler_demo1():
rhol_widget = widgets.FloatSlider(min=1.,
max=10.,
step=0.1,
value=3.,
description=r'$\rho_l$')
ul_widget = widgets.FloatSlider(min=-10.,
max=10.,
step=0.1,
value=0.,
description=r'$u_l$')
pl_widget = widgets.FloatSlider(min=1.,
max=10.,
step=0.1,
value=3.,
description=r'$p_l$')
rhor_widget = widgets.FloatSlider(min=1.,
max=10.,
step=0.1,
value=1.,
description=r'$\rho_r$')
ur_widget = widgets.FloatSlider(min=-10.,
max=10.,
step=0.1,
value=0.,
description=r'$u_r$')
pr_widget = widgets.FloatSlider(min=1.,
max=10.,
step=0.1,
value=1.,
description=r'$p_r$')
gamma_widget = widgets.FloatSlider(min=1.1,
max=2.,
step=0.1,
value=1.4,
description=r'$\gamma$')
t_widget = widgets.FloatSlider(min=0., max=1., step=0.1, value=0.5)
interact_gui = widgets.VBox(\
[widgets.HBox([rhol_widget, rhor_widget, gamma_widget]),
widgets.HBox([ul_widget, ur_widget, t_widget]),
widgets.HBox([pl_widget, pr_widget])])
mainwidget = interact(plot_with_stripes,
rho_l=rhol_widget,
u_l=ul_widget,
p_l=pl_widget,
rho_r=rhor_widget,
u_r=ur_widget,
p_r=pr_widget,
gamma=gamma_widget,
t=t_widget)
try:
mainwidget.widget.close()
display(interact_gui)
display(mainwidget.widget.out)
except:
pass
def ui_prepare(self, k):
for typ in k:
if typ in ['always_apply', 'p']:
continue
if type(k[typ]) == float:
tmp = widgets.FloatSlider(min=0,
max=1,
step=0.05,
continuous_update=False)
self.interact_wds[typ] = tmp
if type(k[typ]) == bool:
tmp = widgets.ToggleButton()
self.interact_wds[typ] = tmp
if type(k[typ]) == int:
tmp = widgets.IntSlider(min=1,
max=50,
step=1,
continuous_update=False)
self.interact_wds[typ] = tmp
if type(k[typ]) == tuple:
tmp = widgets.IntRangeSlider(value=[50, 70],
min=5,
max=200,
step=1,
continuous_update=False)
self.interact_wds[typ] = tmp
ui_lists = []
for w in self.interact_wds:
ui_tmp = widgets.VBox([widgets.Label(w), self.interact_wds[w]])
ui_lists.append(ui_tmp)
ui = widgets.HBox(ui_lists)
return ui
def main(self):
self.media_wid = widgets.ToggleButtons(options=['Lif', 'Images'],
description='Media Input',
value='Lif')
self.media_wid.observe(self.media_update, ['value'])
# self.mode_wid = widgets.ToggleButtons(options=['multi', 'single'], description='Tracking mode',tooltips=['Multiple frame tracking', 'Single frame tracking. Which singles must be specified'])
# self.mode_wid.observe(self.mode_update, ['value'])
self.fmt = widgets.Dropdown(options=['.tif', '.png', '.jpg'],
description='Frame format')
self.initial_frame = widgets.IntText(description='Initial frame')
self.nframes = widgets.IntText(description='Z Frames', value=5)
self.k = widgets.FloatSlider(min=1,
max=10,
step=0.2,
description='k (Blur)',
value=1.6)
self.edge_cutoff = widgets.FloatText(description='Edge cut')
self.plot = widgets.Checkbox(description='Show plots', value=True)
self.options.children = [self.media_wid]
def make_time_window_controller(tmin, tmax, start=0, duration=5.):
slider = widgets.FloatSlider(
value=start,
min=tmin,
max=tmax,
step=0.1,
description='window start (s):',
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.1f')
duration_widget = widgets.BoundedFloatText(
value=duration,
min=0,
max=tmax - tmin,
step=0.1,
description='duration (s):',
)
forward_button = widgets.Button(description='▶')
forward_button.on_click(lambda b: move_slider_up(slider, duration_widget.get_interact_value()))
backwards_button = widgets.Button(description='◀')
backwards_button.on_click(lambda b: move_slider_down(slider, duration_widget.get_interact_value()))
controller = widgets.VBox(
children=[
widgets.VBox(children=[slider, duration_widget]),
widgets.HBox(children=[backwards_button, forward_button])])
return controller
def FloatSlider(question):
start_time = time.time()
float_slider_widget = widgets.FloatSlider(
value=5.0,
min=0,
max=10.0,
step=0.1,
description='Slider:',
disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='.1f',
)
# Display widget
display(float_slider_widget)
def on_value_change(change):
# Appends to the dictionary answer
Answer_Dict[question].append(change["new"])
float_slider_widget.observe(on_value_change, names='value')
# Button Evaluator with arguments (desired_answer, frmt) | Fmrt is the format to evaluate like single item, list, dict, etc
button(question, start_time)
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 InteractivePlanes(planevalue="XZ", offsetvalue=0.0):
def foo(Plane, Offset, nRx):
X0, Y0, Z0 = -20, -50, -50
X2, Y2, Z2 = X0 + 100.0, Y0 + 100.0, Z0 + 100.0
return plotObj3D(
offset_plane=Offset,
X1=X0,
X2=X2,
Y1=Y0,
Y2=Y2,
Z1=Z0,
Z2=Z2,
nRx=nRx,
plane=Plane,
)
out = widgetify(
foo,
Offset=widgets.FloatSlider(min=-100,
max=100,
step=5.0,
value=offsetvalue,
continuous_update=False),
# ,X0=widgets.FloatText(value=-20) \
# ,Y0=widgets.FloatText(value=-50.) \
# ,Z0=widgets.FloatText(value=-50.) \
nRx=widgets.IntSlider(min=4,
max=200,
step=2,
value=40,
continuous_update=False),
Plane=widgets.ToggleButtons(options=["XZ", "YZ"], value=planevalue),
)
return out
def __init__(self, *, slider_min, slider_max, slide_fn=None, **kwargs):
self.slider = widgets.FloatSlider(min=slider_min, max=slider_max, step=1, readout=False,
layout=widgets.Layout(width="80%"))
self.slider.observe(slide_fn, "value")
slider_box = [widgets.HTML(value=str(slider_min)), self.slider, widgets.HTML(value=str(slider_max))]
self.slider_box = widgets.HBox(slider_box, layout=widgets.Layout(justify_content="center"))
super().__init__(**kwargs)
def riemann_plot_pplane(ql=(10.0, -5.0), qr=(40.0, 5.0), rho=2.0, bulk=1.0):
"""Plots interactive riemann solution with time dependence and phase plane plot."""
# Create plot function for interact
pp_plot = full_riemann_solution_plot_fixed(ql, qr, rho, bulk)
# Declare all widget sliders
t_widget = widgets.FloatSlider(value=0,
min=0.0,
max=1.0,
description='$t$')
which_char_widget = widgets.Dropdown(options=[None, 1, 2],
description='Characs.')
# Set up interactive GUI
interact_gui = widgets.HBox([t_widget, which_char_widget])
# Define interactive widget and run GUI
ppwidget = interact(pp_plot, t=t_widget, which_char=which_char_widget)
try:
ppwidget.widget.close()
display(interact_gui)
display(ppwidget.widget.out)
except:
pass
def plot_riemann_SW(h_l,
h_r,
u_l,
u_r,
g=1.,
force_waves=None,
extra_lines=None,
tracer=False):
stripes = not tracer
plot_function_stripes, plot_function_xt_phase = \
make_plot_functions(h_l,h_r,u_l,u_r,g,
force_waves,extra_lines,stripes=stripes)
interact(plot_function_stripes,
t=widgets.FloatSlider(value=0., min=0, max=.9),
fig=fixed(0))
if tracer:
interact(
plot_function_xt_phase,
plot_1_chars=Checkbox(description='1-characteristics',
value=False),
plot_2_chars=Checkbox(description='2-characteristics'),
plot_tracer_chars=Checkbox(description='Tracer characteristics'))
else:
interact(plot_function_xt_phase,
plot_1_chars=Checkbox(description='1-characteristics',
value=False),
plot_2_chars=Checkbox(description='2-characteristics'))
def run_enkf_widget():
start_date = dt.datetime(2011, 7, 1)
end_date = dt.datetime(2011, 10, 15)
dates = pd.date_range(start_date, end_date, freq='D')
options = [(date.strftime(' %d %b '), date) for date in dates]
index = (0, len(options) - 1)
integration_slider = widgets.SelectionRangeSlider(
options=options,
index=index,
description='Observation period',
orientation='horizontal',
layout={'width': '600px'},
)
widgets.interact_manual(
run_ensemble,
n_ensemble=widgets.IntSlider(min=2,
max=1000,
value=50,
description="Number of ensemble members"),
ens_param_inflation=widgets.FloatSlider(
min=0.1,
max=5,
value=1.,
description="Increase the ensemble dispersion/unc"),
obs_period=integration_slider,
sigma_lai=widgets.FloatSlider(
min=0.01,
max=0.5,
value=0.1,
description="Relative Uncertainty in LAI"),
sigma_sm=widgets.FloatSlider(min=0.01,
max=0.5,
value=0.25,
description="Relative Uncertainty in SM"),
n_obs=widgets.IntSlider(
min=1,
max=30,
value=10,
description="Number of observations to assimilate"),
assim_lai=widgets.Checkbox(value=False,
help="Assimilate LAI observations"),
assim_sm=widgets.Checkbox(
value=False, help="Assimilate soil moisture observations"),
)
def create_slider(slef, name):
return widgets.FloatSlider(
value=0.5,
min=-2.0,
max=2.0,
step=0.01,
description=name,
)
def plot_interact(self):
mainplot = self.plot_contour
interact(mainplot,
zcut=widgets.FloatSlider(value=0.0, min=-2.0, max=2.0),
numcontour=widgets.IntSlider(value=25, min=5, max=100),
grad=widgets.Checkbox(value=False,
description='Plot gradient'),
fill=widgets.Checkbox(value=False, description='Fill'))
def NewSl(self, name, min=0, max=1, step=0.1, value=0):
self.slBtn[name] = widgets.FloatSlider(min=min,
max=max,
step=step,
value=value,
description=name,
orientation='vertical')
self.Sl[name] = lambda: self.slBtn[name].value
def plot_riemann_solution(ql, qr, a):
c = lambda q, xi: a
soln = riemann_solution(ql, qr, a)
plot_advection = riemann_tools.make_plot_function(*soln, plot_chars=[c])
return interact(plot_advection,
t=widgets.FloatSlider(value=0.0, min=0, max=1.0),
which_char=widgets.fixed(True))
def char_solution_interactive():
"""Plots interactive characteristics solution."""
twidget = widgets.FloatSlider(min=0., max=1.2, value=0.)
rhowidget = widgets.FloatSlider(min=0.1,
max=2,
value=1.,
description=r'$\rho$')
Kwidget = widgets.FloatSlider(min=0.1, max=2, value=1.)
interact_gui = widgets.HBox(
[widgets.VBox([twidget]),
widgets.VBox([rhowidget, Kwidget])])
mainwidget = interact(char_solution, t=twidget, rho=rhowidget, K=Kwidget)
mainwidget.widget.close()
display(interact_gui)
display(mainwidget.widget.out)
def select_gamma_coefficient(self):
self.gamma_coeff_ui = widgets.HBox([
widgets.Label("Gamma Coefficient:",
layout=widgets.Layout(width="20%")),
widgets.FloatSlider(value=gamma_filtering_coefficient,
min=0,
max=1,
layout=widgets.Layout(width="50%"))
])
display(self.gamma_coeff_ui)
def __init__(self, doodle, min_t, max_t, animation_name="morph_triangles"):
self.doodle = doodle
self.name = animation_name
self.min_t = min_t
self.max_t = max_t
slider = self.slider = widgets.FloatSlider(min=min_t, max=max_t)
slider.on_trait_change(self.change_time, "value")
checkbox = self.checkbox = widgets.Checkbox(description="animate", value=True)
checkbox.on_trait_change(self.change_animation, "value")
self.assembly = widgets.VBox(children=[checkbox, doodle.w, slider])
def filter_menu():
input = widgets.Dropdown(description='Input data',
options=['Dictionary', 'Pickle', 'Text file'],
value='Dictionary')
pinfilter = widgets.FloatSlider(min=0.1,
max=11,
description='Pinned cutoff',
value=0.5)
ids = widgets.Checkbox(description='Show IDs', value=False)
return widgets.VBox([input, pinfilter, ids])
def update_plot(request):
amp = widgets.FloatSlider(min=1,
max=1000,
value=1,
description='AMPLITUDE')
phase = widgets.FloatSlider(min=0, max=5, value=0, description='PHASE')
fre = widgets.FloatSlider(min=1, max=10, value=1, description='FREQUENCY')
widgets.interactive(amp=amp, phase=phase, fre=fre)
x = np.linspace(0, 2, 1000)
fig, ax = plt.subplots(1, figsize=(10, 4))
plt.suptitle('SINE WAVE')
ax.clear()
units = 'amp={} $(psi)$\nphase={} $(s)$\nfre={} $(Hz)$'
y = amp * np.sin(2 * np.pi * (fre * x + phase))
ax.plot(x, y, label=units.format(amp, phase, fre))
ax.legend(loc=1)
ax.set_xlabel('S')
ax.set_ylabel('psi')
w = plt.show()
return render(request, 'DEMOAPP/projecT.html', {'result': w})