def __init__(self, callback_function, default_cmap): """ Initialize a set of widgets that select a colorbar. Parameters: ----------- callback_function: callable The function to call when activating/deactivating the range, or when changing the colormap default_cmap: string The name of the colormap that will be used when the widget is initialized """ # Create the colormap widget available_cmaps = sorted(plt.colormaps()) if default_cmap not in available_cmaps: default_cmap = 'jet' self.cmap = widgets.Select(options=available_cmaps, value=default_cmap) # Create the widgets for the range self.active = widgets.Checkbox(value=False) self.low_bound = widgets.FloatText(value=-5.) self.up_bound = widgets.FloatText(value=5.) self.exponent = widgets.FloatText(value=9.) # Add the callback function self.active.observe(callback_function, 'value', 'change') self.exponent.observe(callback_function, 'value', 'change') self.cmap.observe(callback_function, 'value', 'change')
def __init__(self, *args, **kwargs): super(Heartbeat, self).__init__(*args, **kwargs) # initializes traitlets self.pulseout = widgets.FloatText(value=time.time()) #发出脉冲 self.pulsein = widgets.FloatText(value=time.time()) #读取引脚脉冲 self.link = widgets.jsdlink((self.pulseout, 'value'), (self.pulsein, 'value')) self.start()
def __init__(self, units: Units, trials: pynwb.epoch.TimeIntervals = None, unit_index=0, unit_controller=None, sigma_in_secs=.05, ntt=1000): self.units = units super().__init__() if trials is None: self.trials = self.get_trials() if self.trials is None: self.children = [widgets.HTML('No trials present')] return else: self.trials = trials if unit_controller is None: nunits = len(units['spike_times'].data) unit_controller = widgets.Dropdown(options=[x for x in range(nunits)], value=unit_index, description='unit', layout=Layout(width='200px')) trial_event_controller = make_trial_event_controller(self.trials, layout=Layout(width='200px')) before_ft = widgets.FloatText(.5, min=0, description='before (s)', layout=Layout(width='200px')) after_ft = widgets.FloatText(2., min=0, description='after (s)', layout=Layout(width='200px')) self.gas = self.make_group_and_sort(window=False, control_order=False) self.controls = dict( units=fixed(units), trials=fixed(self.trials), sigma_in_secs=fixed(sigma_in_secs), ntt=fixed(ntt), index=unit_controller, after=after_ft, before=before_ft, start_label=trial_event_controller, gas=self.gas, # progress_bar=fixed(progress_bar) ) out_fig = interactive_output(trials_psth, self.controls) self.children = [ widgets.HBox([ self.gas, widgets.VBox([ unit_controller, trial_event_controller, before_ft, after_ft, ]) ]), out_fig ]
def make_sources_tab(self): v = [] for i in range(self.source_number.value): row_inputs = [ widgets.FloatText(description="X", value=i), widgets.FloatText(description="Y", value=3), widgets.BoundedFloatText(description="Weight", min=.001, value=1) ] v.append(widgets.HBox(row_inputs)) self.source_inputs = widgets.VBox(v) return self.source_inputs
def scale_dropdown_controller(change): if change['type'] == 'change' and change['name'] == 'value': self.convert_container.children = () self.operation_data['scale'] = change['new'] i = 0 if change['new'] == 'ordinal': feature_values = self.scales_manager[ self.features_dropdown.value].aggregated_data.keys() for _ in feature_values: i += 1 ordinal_dropdown = widgets.Dropdown( value=None, description=f'{i}. ', options=feature_values) ordinal_dropdown.observe(self.get_values_controller()) self.convert_container.children += (ordinal_dropdown, ) elif change['new'] == 'interval': feature_values = self.scales_manager[ self.features_dropdown.value].aggregated_data.keys() for val in feature_values: i += 1 interval_dropdown = widgets.FloatText( value=1.0 + round(i / 10, 1), step=0.1, description=f'{val} :', disabled=False, style={'description_width': '50%'}, ) interval_dropdown.observe(self.get_values_controller()) self.convert_container.children += ( interval_dropdown, ) self.convert_button.disabled = not (self.is_data_correct())
def make_gui(self): self.signature = signature(self.process) label = f"<b>{self.name}</b>" display(widgets.HTML(value=label)) for i, arg_name in enumerate(self.signature.parameters): if i == 0: continue arg_type = self.signature.parameters[arg_name].annotation wd = dict(description=arg_name, value=self.params[arg_name]) if arg_type is str: w = widgets.Text(**wd) elif arg_type is int: w = widgets.IntText(**wd) elif arg_type is float: w = widgets.FloatText(**wd) else: return w.observe(self.set_param) display(w)
def InteractiveDipoleDecay( self, xyz_loc, Field, compvalue, sig=1e-2, Tmin=1e-5, Tmax=1e-2, Waveform="stepoff" ): ntime = 200 srcLoc = np.r_[0.0, 0.0, 0.0] # orientation = "z" def foo(Component, Sigma, Scale): # , Waveform="stepoff"): orientation = "z" # vals = [] if Field == "E": unit = " (V/m)" elif Field == "H": unit = " (A/m)" elif Field == "dHdt": unit = " (A/m-s)" elif Field == "J": unit = " (A/m $^2$)" label = Field + Component + "-field " + unit t = np.logspace(np.log10(Tmin), np.log10(Tmax), ntime) valx, valy, valz = self.dataview.eval_TD( xyz_loc, srcLoc, np.r_[Sigma], t, orientation, self.dataview.func2D ) if Component == "x" or Component == "X": val = valx.copy() elif Component == "y" or Component == "Y": val = valy.copy() elif Component == "z" or Component == "Z": val = valz.copy() plt.figure(figsize=(7, 5)) ax = plt.subplot(111) if Scale == "log": valp, valn = DisPosNegvalues(val) ax.plot(t, valp, "k-") ax.plot(t, valn, "k--") elif Scale == "linear": ax.plot(t, val, "k-") ax.set_xscale("log") ax.set_yscale(Scale) ax.set_ylabel(label) ax.set_xlabel("Time (sec)") ax.grid(True) plt.show() Q3 = widgetify( foo, Component=widgets.ToggleButtons( options=["x", "y", "z"], value=compvalue, description="Comp." ), Sigma=widgets.FloatText( value=sig, continuous_update=False, description="$\sigma$ (S/m)" ), Scale=widgets.ToggleButtons(options=["log", "linear"]) # ,Waveform=widgets.ToggleButtons(options=['stepoff','stepon','rampoff'], value='stepoff') ) return Q3
def msd_menu(): input = widgets.Dropdown(description='Input data', options=['Dictionary', 'Pickle', 'Text file'], value='Dictionary') plot = widgets.Checkbox(description='Plot', value=True) fit = widgets.Checkbox(description='Fit MSD', value=True) points = widgets.IntText(description='Points', value=100) vel = widgets.FloatText(description='$ \\upsilon$ (px $s^{-1}$)', value=100) tau = widgets.FloatText(description='$ \\tau $', value=0.5) refs = widgets.Checkbox(description='Slope reference', value=True) kind = widgets.Dropdown(options=['ABP', 'Quincke', 'Passive'], description='MSD fit type', value='ABP') save = widgets.Checkbox(description='Save', value=True) return widgets.VBox([input, plot, fit, kind, points, tau, vel, refs, save])
def get_widgets_per_param(param, value): if isinstance(value, float): return (param, widgets.FloatText( value=value, step=0.05, description=param.split('__')[1], continuous_update=False, disabled=False )) elif isinstance(value, int): return (param, widgets.IntText( value=value, step=1, description=param.split('__')[1], continuous_update=False, disabled=False )) elif isinstance(value, str): return (param, widgets.Text( value=value, description=param.split('__')[1], continuous_update=False, disabled=False )) else: return None
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 define_pixel_size(self): box = widgets.HBox([widgets.Label("Size/Pixel Ratio"), widgets.FloatText(value=1, step=0.1, layout=widgets.Layout(width='10%')), widgets.Label("mm/px")]) display(box) self.ratio_widget = box.children[1]
def __init__(self, n_rules, avail_records, refresh_ptcl): """ Initialize a set of particle selection widgets Parameters: ----------- n_rules: int The number of selection rules to display avail_records: list of strings The list of available records for the current species refresh_ptcl: callable The callback function to execute when the widget is changed """ self.n_rules = n_rules # Create widgets that determines whether the rule is used self.active = [widgets.Checkbox(value=False) for i in range(n_rules)] # Create widgets that determines the quantity on which to select # (The Dropdown menu is empty, but is later populated by the # function refresh_species) self.quantity = [ widgets.Dropdown(options=avail_records, description='Select ') for i in range(n_rules) ] # Create widgets that determines the lower bound and upper bound self.low_bound = [ widgets.FloatText(value=-1.e-1, description='from ') for i in range(n_rules) ] self.up_bound = [ widgets.FloatText(value=1.e-1, description='to ') for i in range(n_rules) ] # Add the callback function refresh_ptcl to each widget for i in range(n_rules): self.active[i].observe(refresh_ptcl, 'value', 'change') self.quantity[i].observe(refresh_ptcl, 'value', 'change') self.low_bound[i].observe(refresh_ptcl, 'value', 'change') self.up_bound[i].observe(refresh_ptcl, 'value', 'change')
def InteractivePlaneProfile(): nRx = 100 def foo(Field, Sigma, Scale, Time): plt.figure(figsize=(8, 4)) ax1 = plt.subplot(111) r = np.linspace(-1000.0, 0.0, nRx) val_ex, val_hy = PlaneEHfield(r, t=Time, sig=Sigma) if Field == "Ex": val = val_ex.flatten() label = "Ex-field (V/m)" elif Field == "Hy": val = val_hy.flatten() label = "Hy-field (A/m)" if Scale == "log": val_p, val_n = DisPosNegvalues(val) ax1.plot(r, val_p, "k-", lw=2) ax1.plot(r, val_n, "k--", lw=2) ax1.set_yscale(Scale) elif Scale == "linear": ax1.plot(r, val, "k-", lw=2) ax1.set_yscale(Scale) y = ax1.yaxis.get_majorticklocs() yticksa = np.linspace(y.min(), y.max(), 3) ax1.yaxis.set_ticks(yticksa) ax1.yaxis.set_major_formatter(ticker.FormatStrFormatter("%.1e")) ax1.set_xlim(0, -1000) ax1.set_ylabel(label, color="k") ax1.set_xlabel("Z (m)") ax1.grid(True) plt.show() Q2 = widgets.interactive( foo, Field=widgets.ToggleButtons(options=["Ex", "Hy"], value="Ex"), Sigma=widgets.FloatText(value=1, continuous_update=False, description="$\sigma$ (S/m)"), Scale=widgets.ToggleButtons(options=["log", "linear"], value="linear"), Time=widgets.FloatSlider(min=0.01, max=1.0, step=0.01, value=0.0, description="$t$ (s)"), ) return Q2
def __init__(self, n_rules, avail_ptcl_quantities, refresh_ptcl): """ Initialize a set of particle selection widgets Parameters: ----------- n_rules: int The number of selection rules to display avail_ptcl_quantities: list of string The particle quantities in the present openPMD timeseries refresh_ptcl: callable The callback function to execute when the widget is changed """ self.n_rules = n_rules # Create widgets that determines whether the rule is used self.active = [ widgets.Checkbox(value=False) \ for i in range(n_rules) ] # Create widgets that determines the quantity on which to select self.quantity = [ widgets.Dropdown(options=avail_ptcl_quantities, description='Select ') for i in range(n_rules) ] # Create widgets that determines the lower bound and upper bound self.low_bound = [ widgets.FloatText(value=-1.e-1, width=90, description='from ') for i in range(n_rules) ] self.up_bound = [ widgets.FloatText(value=1.e-1, width=90, description='to ') for i in range(n_rules) ] # Add the callback function refresh_ptcl to each widget for i in range(n_rules): self.active[i].on_trait_change(refresh_ptcl) self.quantity[i].on_trait_change(refresh_ptcl) self.low_bound[i].on_trait_change(refresh_ptcl) self.up_bound[i].on_trait_change(refresh_ptcl)
def g6r_menu(): ''' generates a menu for specific parameters to compute and fit the time correlation of the hexagonal order. See src.characterisation.g6.py for details ''' input = widgets.Dropdown(description='Input data', options=['Dictionary', 'Pickle', 'Text file'], value='Dictionary') nbins = widgets.IntText(description='Nbins', value=100) bs = widgets.FloatText(description='Binwidth', value=0.25) plot = widgets.Checkbox(description='Plot', value=True) save = widgets.Checkbox(description='Save', value=True) return widgets.VBox([input, nbins, bs, plot, save])
def ov_menu(): ''' generates a menu for specific parameters to compute and fit the overlap Q(t) functions. See src.characterisation.overlap.py for details ''' input = widgets.Dropdown(description='Input data', options=['Dictionary', 'Pickle', 'Text file'], value='Dictionary') plot = widgets.Checkbox(description='Plot', value=True) fit = widgets.Checkbox(description='Fit', value=True) points = widgets.IntText(description='No. of points', value=100) tau = widgets.FloatText(description='$ \\tau $', value=1.) save = widgets.Checkbox(description='Save', value=True) return widgets.VBox([input, plot, fit, points, tau, save])
def __init__(self, callback_function, default_cmap, default_vmin, default_vmax): """ Initialize a set of widgets that select a colorbar. Parameters: ----------- callback_function: callable The function to call when activating/deactivating the range, or when changing the colormap default_cmap: string The name of the colormap that will be used when the widget is initialized default_vmin, default_vmax: float The default value for the initial value of vmin and vmax """ # Create the colormap widget available_cmaps = sorted(plt.colormaps()) if default_cmap not in available_cmaps: default_cmap = 'jet' self.cmap = widgets.Select(options=available_cmaps, value=default_cmap) # Convert default_vmin, default vmax to scientific format max_abs = max(abs(default_vmin), abs(default_vmax)) default_exponent = math.floor(math.log10(max_abs)) default_upbound = default_vmax * 10.**(-default_exponent) default_lowbound = default_vmin * 10.**(-default_exponent) # Create the widgets for the range self.active = create_checkbox(value=False) self.low_bound = widgets.FloatText(value=default_lowbound) self.up_bound = widgets.FloatText(value=default_upbound) self.exponent = widgets.FloatText(value=default_exponent) # Add the callback function self.active.observe(callback_function, 'value', 'change') self.exponent.observe(callback_function, 'value', 'change') self.cmap.observe(callback_function, 'value', 'change')
def __init__(self, callback_function, default_value, title): """ Initialize a set of widgets that select a range of (float) values Parameters: ----------- callback_function: callable The function to call when activating/deactivating the range default_value: The default value of the upper bound of the range at initialization (The default lower bound is the opposite of this value.) title: The title that is displayed on top of the widgets """ # Register title self.title = title # Create the widgets self.active = create_checkbox(value=False) self.low_bound = widgets.FloatText(value=-default_value) self.up_bound = widgets.FloatText(value=default_value) # Add the callback function self.active.observe(callback_function, 'value', 'change')
def cl_menu(): input = widgets.Dropdown(description='Input data', options=['Dictionary', 'Pickle', 'Text file'], value='Dictionary') dc = widgets.FloatSlider(min=0.5, max=2.0, description='Dist cut', value=1.25, step=0.25) mn = widgets.IntSlider(min=3, max=7, description='Num neigh', value=5) mcs = widgets.FloatText(description='Min cluster size', value=10) ids = widgets.Checkbox(description='Cluster Id', value=False) iso = widgets.Checkbox(description='Isolated', value=False) save = widgets.Checkbox(description='Save', value=False) return widgets.VBox([input, dc, mn, mcs, ids, iso])
def _build_sed_form(self): self.sed_select = widgets.Dropdown( description="SED type: ", options=['power-law', 'blackbody', 'star', 'extragalactic'], value='power-law', layout={'width': '20rem'}, ) self.pl_index = widgets.FloatText( description="Index:", value=1.0, layout={'width': '14rem'}, ) self.bb_temp = widgets.BoundedFloatText( description="Temp (K):", min=0.0, max=99999.0, value=6500.0, layout={'width': '14rem'}, ) _hide(self.bb_temp) self.star_config = STAR_CONFIG self.stars = widgets.Dropdown( options=sorted(self.star_config.keys()), layout={'width': '18rem'}, ) _hide(self.stars) self.gal_config = GALAXIES_CONFIG self.galaxies = widgets.Dropdown( options=sorted(self.gal_config.keys()), layout={'width': '26rem'}, ) _hide(self.galaxies) self.redshift = widgets.BoundedFloatText( description="Redshift: z=", min=0.0, max=99999.0, value=0.0, layout={'width': '14rem'}, ) self.sed_select.observe(self.on_sed_select, names='value') return widgets.HBox([ self.sed_select, self.pl_index, self.bb_temp, self.stars, self.galaxies, self.redshift, ])
def __init__(self, on_interact=None, output=None, overwrite_previous_output=True, feedback=False, run=True, action_kws={}, *args, **kwargs): super().__init__(on_interact=on_interact, output=output, overwrite_previous_output=overwrite_previous_output, feedback=feedback, action_kws=action_kws) self.widget = widgets.FloatText(*args, **kwargs) if run: self.run()
def get_cluster_params_widgets(param, value): if isinstance(value, float): return (param, widgets.FloatText( value=value, step=0.1, description=param.split('__')[1], disabled=False )) elif isinstance(value, int): return (param, widgets.IntText( value=value, step=1, description=param.split('__')[1], disabled=False )) elif isinstance(value, str): return (param, widgets.Text( value=value, description=param.split('__')[1], disabled=False )) else: return None
def get_widgets_per_param(params): for key, value in params.items(): style = {'description_width': 'initial'} description = key.split("__")[1] if "__" in key else key if isinstance(value, float): yield (key, widgets.FloatText(value=value, step=0.05, description=description, continuous_update=False, disabled=False, layout=Layout(width="90%"), style=style)) elif isinstance(value, bool): yield (key, widgets.ToggleButton(value=value, description=description, disabled=False, layout=Layout(width="90%"), style=style)) elif isinstance(value, int): yield (key, widgets.IntText(value=value, step=1, description=description, continuous_update=False, disabled=False, layout=Layout(width="90%"), style=style)) elif isinstance(value, str): yield (key, widgets.Text(value=value, description=description, continuous_update=False, disabled=False, layout=Layout(width="90%"), style=style))
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])
def _plot_settings_axes(self, axes_content, key): # vmin = -1e100 # vmax = 1e100 a = axes_content['a'] def on_change(change, set_lim, vmin, vmax): if self.controller.initiation_in_progress: return # self.tester = change param = change['owner'].description self.controller.database.set_plot_settings(key, param, change['new']) set_lim(vmin.value, vmax.value) step = 1 xlim_min = widgets.FloatText( value=7.5, # min=vmin, # max=vmax, step=step, description='x_min', disabled=False) xlim_max = widgets.FloatText( value=7.5, # min=vmin, # max=vmax, step=step, description='x_max', disabled=False) # xlim_min.observe(lambda x: on_change(x, a.set_xlim(), xlim_min, xlim_max), names='value') # ylim_max.observe(lambda x: on_change(x, set_lim_z, xlim_min, xlim_max), names='value') xhbox = widgets.HBox([xlim_min, xlim_max]) # display(xhbox) ylim_min = widgets.FloatText( value=7.5, # min=vmin, # max=vmax, step=step, description='y_min', disabled=False) ylim_max = widgets.FloatText( value=7.5, # min=vmin, # max=vmax, step=step, description='y_max', disabled=False) ylim_min.observe( lambda x: on_change(x, a.set_ylim, ylim_min, ylim_max), names='value') ylim_max.observe( lambda x: on_change(x, a.set_ylim, ylim_min, ylim_max), names='value') yhbox = widgets.HBox([ylim_min, ylim_max]) # display(hbox) zlim_min = widgets.FloatText( # value=7.5, # min=vmin, # max=vmax, step=step, description='z_min', disabled=False) def set_lim_z(vmin, vmax): # for zo in axes_content['zobjects']: for zo in a.zobjects: zo.set_clim(vmin, vmax) zlim_max = widgets.FloatText( # value=7.5, # min=vmin, # max=vmax, step=step, description='z_max', disabled=False) zlim_min.observe(lambda x: on_change(x, set_lim_z, zlim_min, zlim_max), names='value') zlim_max.observe(lambda x: on_change(x, set_lim_z, zlim_min, zlim_max), names='value') zhbox = widgets.HBox([zlim_min, zlim_max]) vbox = widgets.VBox([xhbox, yhbox, zhbox]) return vbox, { 'x': (xlim_min, xlim_max), 'y': (ylim_min, ylim_max), 'z': (zlim_min, zlim_max) }
def __init__( self, time_series: TimeSeries, trials: TimeIntervals = None, trace_index=0, trace_controller=None, trace_controller_kwargs=None, sem=True, ): self.time_series = time_series self.time_series_data = time_series.data[()] self.time_series_timestamps = None if time_series.rate is None: self.time_series_timestamps = time_series.timestamps[()] super().__init__() if trials is None: self.trials = self.get_trials() if self.trials is None: self.children = [widgets.HTML("No trials present")] return else: self.trials = trials if trace_controller is None: ntraces = self.time_series.data.shape[1] input_trace_controller_kwargs = dict( options=[x for x in range(ntraces)], value=trace_index, description="trace", layout=Layout(width="200px"), ) if trace_controller_kwargs is not None: input_trace_controller_kwargs.update(trace_controller_kwargs) self.trace_controller = widgets.Dropdown( **input_trace_controller_kwargs) else: self.trace_controller = trace_controller self.trial_event_controller = make_trial_event_controller( self.trials, layout=Layout(width="200px")) self.before_ft = widgets.FloatText(0.5, min=0, description="before (s)", layout=Layout(width="200px")) self.after_ft = widgets.FloatText(2.0, min=0, description="after (s)", layout=Layout(width="200px")) self.gas = self.make_group_and_sort(window=False, control_order=False) self.align_to_zero_cb = widgets.Checkbox(description="align to zero") self.controls = dict( index=self.trace_controller, after=self.after_ft, before=self.before_ft, start_label=self.trial_event_controller, gas=self.gas, align_to_zero=self.align_to_zero_cb, ) vbox_cols = [ [self.gas, self.align_to_zero_cb], [ self.trace_controller, self.trial_event_controller, self.before_ft, self.after_ft, ], ] if sem: self.sem_cb = widgets.Checkbox(description="show SEM") self.controls.update(sem=self.sem_cb) vbox_cols[0].append(self.sem_cb) out_fig = set_plotly_callbacks(self.update, self.controls) self.children = [ widgets.HBox([widgets.VBox(i) for i in vbox_cols]), out_fig ]
def make_sink_tab(self): self.sink_input = widgets.HBox([widgets.FloatText(description="X", \ value = (self.source_number.value - 1)/2),\ widgets.FloatText(description="Y", value = 0)]) return self.sink_input
def InteractivePlane_Sphere(self, scale="log", fieldvalue="B", compvalue="z"): def foo( Field, AmpDir, Component, ComplexNumber, Sigma0, Sigmab, Sigma1, Sigma2, Sus, d1, h, d2, R, Scale, rxOffset, z, ifreq, Geometry=True, ): Frequency = 10**((ifreq - 1.0) / 3.0 - 2.0) if ComplexNumber == "Re": ComplexNumber = "real" elif ComplexNumber == "Im": ComplexNumber = "imag" elif ComplexNumber == "Amp": ComplexNumber = "amplitude" elif ComplexNumber == "Phase": ComplexNumber = "phase" if AmpDir == "Direction (B or Bsec)": # ComplexNumber = "real" Component = "vec" if Field == "Bsec": bType = "bSecondary" Field = "B" else: bType = "b" self.setLayerSphereParam( d1=d1, h=h, d2=d2, R=R, sig0=Sigma0, sigb=Sigmab, sig1=Sigma1, sig2=Sigma2, chi=Sus, ) srcLoc = np.array([0.0, 0.0, z]) rxLoc = np.array([[rxOffset, 0.0, z]]) self.simulate(srcLoc, rxLoc, np.r_[Frequency]) if Field != "Model": self.getFields(bType=bType) return self.plotField( Field=Field, ComplexNumber=ComplexNumber, Frequency=Frequency, view=Component, scale=Scale, Geometry=Geometry, Scenario="Sphere", ) out = widgetify( foo, Field=widgets.ToggleButtons( options=["E", "B", "Bsec", "J", "Model"], value="E"), AmpDir=widgets.ToggleButtons( options=["None", "Direction (B or Bsec)"], value="None"), Component=widgets.ToggleButtons(options=["x", "y", "z"], value="y", description="Comp."), ComplexNumber=widgets.ToggleButtons( options=["Re", "Im", "Amp", "Phase"], value="Re", description="Re/Im"), Sigma0=widgets.FloatText(value=1e-8, continuous_update=False, description="$\sigma_0$ (S/m)"), Sigmab=widgets.FloatText(value=0.01, continuous_update=False, description="$\sigma_b$ (S/m)"), Sigma1=widgets.FloatText(value=0.01, continuous_update=False, description="$\sigma_1$ (S/m)"), Sigma2=widgets.FloatText(value=0.01, continuous_update=False, description="$\sigma_2$ (S/m)"), Sus=widgets.FloatText(value=0.0, continuous_update=False, description="$\chi$"), d1=widgets.FloatSlider( min=0.0, max=50.0, step=2.0, value=0.0, continuous_update=False, description="$d_1$ (m)", ), h=widgets.FloatSlider( min=2.0, max=20.0, step=2.0, value=10.0, continuous_update=False, description="$h$ (m)", ), d2=widgets.FloatSlider( min=10.0, max=50.0, step=2.0, value=30.0, continuous_update=False, description="$d_2$ (m)", ), R=widgets.FloatSlider( min=2.0, max=20.0, step=2.0, value=10.0, continuous_update=False, description="$R$ (m)", ), Scale=widgets.ToggleButtons(options=["log", "linear"], value="linear"), rxOffset=widgets.FloatSlider( min=0.0, max=50.0, step=2.0, value=10.0, continuous_update=False, description="$\Delta x$(m)", ), z=widgets.FloatSlider( min=0.0, max=50.0, step=2.0, value=0.0, continuous_update=False, description="$\Delta z$ (m)", ), ifreq=widgets.IntSlider( min=1, max=31, step=1, value=16, continuous_update=False, description="f index", ), ) return out
def __init__(self, ncgridlasso, overplot_func=gridLassoOverplotDefault): """ The user may pass a function to overplot_func in order to add additional features to the plot. That function is passed the lasso widget instance which called it, as well as the matplotlib axes on which the grid's data was just plotted. The default function does nothing. """ self.ncgridlasso = ncgridlasso self.overplot_func = overplot_func self.value_range_for_field = { 'flash_extent': (1, 1000.0), 'flash_initiation': (1, 100.0), 'flash_footprint': (1, 100000.0), 'default': (1, 1000.0), } self.value_colors_for_field = { 'flash_extent': ct.NWSRef, 'flash_initiation': ct.NWSRef, 'flash_footprint': 'cubehelix', } field_type = widgets.Dropdown(description='Field:', options=[self.ncgridlasso.field]) field_type.observe(self.change_field, 'value') initial_vmin, initial_vmax = self.value_range_for_field[ ncgridlasso.field] toggle = widgets.Checkbox(description='Log Lasso?', value=False) toggle_log_scale = widgets.Checkbox(description='Logarithmic', value=True) toggle_log_scale.observe(self.redraw, 'value') draw = widgets.Button(description='Draw Lasso') draw.on_click(self.lasso_draw) N_frames = len(self.ncgridlasso.NCs.times) frame_selection = widgets.IntSlider(description="Frame", min=0, max=N_frames - 1) frame_selection.value = 0 frame_selection.observe(self.change_frame, 'value') v_min = widgets.FloatText(description='Min') v_min.value = initial_vmin v_min.observe(self.v_min_set, 'value') v_max = widgets.FloatText(description='Max') v_max.value = initial_vmax v_max.observe(self.v_max_set, 'value') # view_mask = widgets.Button(description='View Masked Region', value=False) # view_mask.on_click(self.view_mask) # revert_plot = widgets.Button(description='Redraw', value=False) revert_plot.on_click(self.redraw) # # filtered = widgets.Button(description='View Filtered Data', value=False) # filtered.on_click(self.view_filter) contain = widgets.VBox(description='NetCDF grid tools') contain.children = [ draw, toggle, v_min, v_max, frame_selection, # filtered, view_mask, revert_plot, toggle_log_scale ] self.draw = draw self.toggle = toggle self.field_type = field_type self.frame_selection = frame_selection self.v_min = v_min self.v_max = v_max self.revert_plot = revert_plot self.toggle_log_scale = toggle_log_scale # self.view_mask = view_mask # self.filtered = filtered self.container = contain self.plot_update()