def __init__(self, eem_stack_cw, datlist_cw, range1, range2, em_range_cw, ex_range_cw, timestamps_cw): self.eem_stack_cw = eem_stack_cw self.datlist_cw = datlist_cw self.range1 = range1 self.range2 = range2 self.em_range_cw = em_range_cw self.ex_range_cw = ex_range_cw self.timestamps_cw = timestamps_cw self.property_pixel = ipywidgets.Dropdown( options=['Timeseries analysis', 'Correlation analysis'], description='Property') self.em_pixel = ipywidgets.FloatText(value=400, description='Em [nm]') self.ex_pixel = ipywidgets.FloatText(value=300, description='Ex [nm]') self.caption_pixel_statistics = ipywidgets.Label( value='For correlation analysis, please specify the reference ' 'data with either a file path or a manual input') self.checkbox_reference_filepath_pixel = ipywidgets.Checkbox( value=False) self.reference_filepath_pixel = ipywidgets.Text( value='reference_example.txt', description='File path of input reference data', style={'description_width': 'initial'}, layout=Layout(width='400%')) self.checkbox_reference_mannual_input_pixel = ipywidgets.Checkbox( value=True) self.reference_mannual_input_pixel = ipywidgets.Text( description='Type input reference data manually', style={'description_width': 'initial'}, layout=Layout(width='400%')) self.button_pixel_statistics = ipywidgets.Button( description='Calculate')
def __init__(self, net_widget, interactions=None): self.key = "PPI" self.net = net_widget self.interactions = interactions self.is_on = w.ToggleButton(description="PPI", value=False, layout=w.Layout(width="15%", height="40px")) self.s1 = w.Dropdown(description="Species 1", options={ "S{}".format(key): key for key in self.net.types["Complexable"] }) self.s2 = w.Dropdown(description="Species 2", options={ "S{}".format(key): key for key in self.net.types["Complexable"] }) self.custom_p = w.Checkbox(description="custom parameters", value=False, layout=w.Layout(width="23%", height="40px")) self.kp = w.FloatText(description="k+", value=1, step=0.0001, layout=w.Layout(width="15%", height="40px")) self.km = w.FloatText(description="k-", value=1, step=0.0001, layout=w.Layout(width="15%", height="40px")) self.update_param_state(False) self.update_inter_state(False) w.interactive(self.update_inter_state, button=self.is_on) w.interactive(self.update_param_state, button=self.custom_p)
def __drawWidgets(self): nv = self.nv vars = self.vars steps = self.steps self.layout = ipywidgets.GridspecLayout(nv + 1, 3) for i, (pname, pstep) in enumerate(zip(vars, steps)): self.layout[i, 0] = ipywidgets.FloatText( description=pname, value=self.parameterobj.parameters.get(pname), step=pstep) self.layout[i, 0].observe(self.__parCallBack, names='value') self.layout[i, 1] = ipywidgets.ToggleButton( description="Vary " + pname, value=pname in self.getvars()) self.layout[i, 1].observe(self.__fixVaryCallBack, names='value') self.layout[nv, 0] = ipywidgets.FloatText( description='fit_tolerance', value=self.parameterobj.parameters.get("fit_tolerance"), step=0, ) self.layout[nv, 0].observe(self.__parCallBack, names='value') self.layout[nv, 1] = ipywidgets.Button(description="Run Fit (blocks)") self.layout[nv, 1].on_click(self.__fitCallBack) self.layout[0, 2] = ipywidgets.Button(description="Load parameters") self.layout[0, 2].on_click(self.__loadCallBack) self.layout[1, 2] = ipywidgets.Button(description="Save to a file") self.layout[1, 2].on_click(self.__saveCallBack)
def __init__(self, data): self.data = data self.res = [data.axis1.calibA, data.axis1.calibB, data.axis1.calibC] self.A = widgets.FloatText(value=data.axis1.calibA, description="A") self.B = widgets.FloatText(value=data.axis1.calibB, description="B") self.C = widgets.FloatText(value=data.axis1.calibC, description="C") self.bupdate = widgets.Button( description="Update", button_style= 'success', # 'success', 'info', 'warning', 'danger' or '' tooltip='set current data-sets to displayed values') self.bupdate.on_click(self.update) self.bback = widgets.Button( description="Restore", button_style= 'success', # 'success', 'info', 'warning', 'danger' or '' tooltip='restore dataset to initial values') self.bback.on_click(self.back) display( VBox([ HBox([self.A, widgets.Label('Hz/Th')]), HBox([self.B, widgets.Label('Hz')]), HBox([self.C, widgets.Label('Hz/Th^2')]), HBox([self.bupdate, self.bback]) ]))
def _set_tab(self): ## set titles style = {'description_width': 'initial'} self.set_title(0,'Field setting') self.set_title(1,'Particle setting') self.set_title(2,'Simulation setting') self.set_title(3,'Output setting') self.set_title(4,'Word setting') ## set widgets self._field_setting = widgets.Select(options=['random','vortex','self-defined'],description='Select a field setting: ',\ disabled=False,value='random',style=style) self._particle_num = widgets.IntText(description='Number of particles initially: ',disabled=False,value=100,style=style) self._particle_mode = widgets.Select(options=['random','middle','self-defined'],description=\ 'How particles are distributed initially: ',disables=False,value='random',style=style) self._particle_setting = widgets.Accordion(children=[self._particle_num,self._particle_mode]) self._particle_setting.set_title(0,'Num of particles') self._particle_setting.set_title(1,'Distribution mode of particles') self._time_length = widgets.IntText(description='Simulation time length: ',disabled=False,value=200,style=style) self._time_period = widgets.IntText(description='Simulation time period: ',disabled=False,value=5,style=style) self._collision_threshold = widgets.FloatText(description='Particles collision threshold: ',disabled=False,value=0.0001,\ style=style) self._simulation_setting = widgets.Accordion(children=[self._time_length,self._time_period,self._collision_threshold]) self._simulation_setting.set_title(0,'Time length') self._simulation_setting.set_title(1,'Time period') self._simulation_setting.set_title(2,'Collision threshold') self._output_setting = widgets.Text(description='Save output file to: ',disabled=False,style=style,\ layout=widgets.Layout(width='50%'),value='C:\Users\User\Downloads\example') self._decay_rate = widgets.FloatText(description='Decay rate of transformation probability:',\ disabled=False,value=0.001,style=style,layout=widgets.Layout(width='40%')) self._mutation_period = widgets.IntText(description='Mutation period of meanings: ',disabled=False,value=5,style=style) self._word_setting = widgets.Accordion(children=[self._decay_rate,self._mutation_period]) self._word_setting.set_title(0,'State transformation probability decay rate') self._word_setting.set_title(1,'Mutation period of meanings')
def __init__(self, state, **kwargs): super(Size, self).__init__(**kwargs) self.state = state self.widget_size = widgets.FloatSlider(description='size', min=0, max=10, value=self.state.size) link((self.state, 'size'), (self.widget_size, 'value')) self.widget_scaling = widgets.FloatSlider(description='scale', min=0, max=2, value=self.state.size_scaling) link((self.state, 'size_scaling'), (self.widget_scaling, 'value')) options = type(self.state).size_mode.get_choice_labels(self.state) self.widget_size_mode = widgets.RadioButtons(options=options, description='size mode') link((self.state, 'size_mode'), (self.widget_size_mode, 'value')) self.widget_size_att = LinkedDropdown(self.state, 'size_att', ui_name='size attribute', label='size attribute') self.widget_size_vmin = widgets.FloatText(description='size min') self.widget_size_vmax = widgets.FloatText(description='size min') self.widget_size_v = widgets.VBox([self.widget_size_vmin, self.widget_size_vmax]) link((self.state, 'size_vmin'), (self.widget_size_vmin, 'value'), lambda value: value or 0) link((self.state, 'size_vmax'), (self.widget_size_vmax, 'value'), lambda value: value or 1) dlink((self.widget_size_mode, 'value'), (self.widget_size.layout, 'display'), lambda value: None if value == options[0] else 'none') dlink((self.widget_size_mode, 'value'), (self.widget_size_att.layout, 'display'), lambda value: None if value == options[1] else 'none') dlink((self.widget_size_mode, 'value'), (self.widget_size_v.layout, 'display'), lambda value: None if value == options[1] else 'none') self.children = (self.widget_size_mode, self.widget_size, self.widget_scaling, self.widget_size_att, self.widget_size_v)
def __init__(self, eem_stack, datlist_all, em_range, ex_range, eem_preview_parameters): self.datlist_all = datlist_all self.datlist_filtered = datlist_all.copy() self.idx2remove = [] self.filelist_preview = ipywidgets.Dropdown( options=self.datlist_all, style={'description_width': 'initial'}, layout={'width': 'max-content'}) self.preview_parameter_dict = eem_preview_parameters # from Widgets2and3 self.eem_stack = eem_stack self.em_range = em_range self.ex_range = ex_range self.auto_detection_method = ipywidgets.Dropdown( options=['Isolation forest', 'One-class-SVM', 'Mixed'], description='Artefact detection algorithm') self.tf_normalization = ipywidgets.Checkbox( value=True, description='Normalize EEM with total fluorescence') self.grid_size = ipywidgets.FloatText( value=10, description='The length and width of each pixel after down-sampling' ) self.contamination = ipywidgets.FloatText( value=0.02, description='The proportion of samples with artefacts') self.auto_detection_labels = []
def __init__(self, *args, **kwargs): """Parameters ---------- *args, **kwargs Passed to the :py:class:`HBox` constructor after the list of children """ self._block_size_sel = ipywidgets.IntText(value=65, description="block size") self._c_sel = ipywidgets.FloatText(value=-5, description="const offset") self._smoothing_sel = ipywidgets.FloatText(value=1.5, description="smooth", step=0.1) self._method_sel = ipywidgets.Dropdown(options=["mean", "gaussian"], description="adaptive method") self._update_lock = threading.Lock() super().__init__([ self._block_size_sel, self._c_sel, self._smoothing_sel, self._method_sel ], layout=ipywidgets.Layout( grid_template_columns="repeat(2, max-content)"), *args, **kwargs) for w in (self._block_size_sel, self._c_sel, self._smoothing_sel, self._method_sel): w.observe(self._options_from_ui, "value") self._options_from_ui()
def __init__(self, state, **kwargs): super(Color, self).__init__(**kwargs) self.state = state self.widget_color = widgets.ColorPicker(description='color') link((self.state, 'color'), (self.widget_color, 'value'), color2hex) cmap_mode_options = type(self.state).cmap_mode.get_choice_labels(self.state) self.widget_cmap_mode = widgets.RadioButtons(options=cmap_mode_options, description='cmap mode') link((self.state, 'cmap_mode'), (self.widget_cmap_mode, 'value')) self.widget_cmap_att = LinkedDropdown(self.state, 'cmap_att', ui_name='color attribute', label='color attribute') self.widget_cmap_vmin = widgets.FloatText(description='color min') self.widget_cmap_vmax = widgets.FloatText(description='color max') self.widget_cmap_v = widgets.VBox([self.widget_cmap_vmin, self.widget_cmap_vmax]) link((self.state, 'cmap_vmin'), (self.widget_cmap_vmin, 'value'), lambda value: value or 0) link((self.state, 'cmap_vmax'), (self.widget_cmap_vmax, 'value'), lambda value: value or 1) self.widget_cmap = widgets.Dropdown(options=colormaps, description='colormap') link((self.state, 'cmap'), (self.widget_cmap, 'label'), lambda cmap: colormaps.name_from_cmap(cmap), lambda name: colormaps[name]) dlink((self.widget_cmap_mode, 'value'), (self.widget_color.layout, 'display'), lambda value: None if value == cmap_mode_options[0] else 'none') dlink((self.widget_cmap_mode, 'value'), (self.widget_cmap.layout, 'display'), lambda value: None if value == cmap_mode_options[1] else 'none') dlink((self.widget_cmap_mode, 'value'), (self.widget_cmap_att.layout, 'display'), lambda value: None if value == cmap_mode_options[1] else 'none') dlink((self.widget_cmap_mode, 'value'), (self.widget_cmap_v.layout, 'display'), lambda value: None if value == cmap_mode_options[1] else 'none') self.children = (self.widget_cmap_mode, self.widget_color, self.widget_cmap_att, self.widget_cmap_v, self.widget_cmap)
def makesliders(D): slider_list = [] # ax_list = [] for label in D.keys(): slider_list.append( ipywidgets.VBox([ ipywidgets.Label(label), # ipywidgets.Dropdown(options=list(cbayes.distributions.supported_distributions().keys())) # ipywidgets.FloatSlider(value=0, min=0, max=10, description='loc'), # ipywidgets.FloatSlider(value=1, min=0, max=10, description='scale'), ipywidgets.FloatText(value=0.0, description='loc'), ipywidgets.FloatText(value=1.0, description='scale'), ipywidgets.FloatSlider(value=1.0, min=0, max=20, description='a'), ipywidgets.FloatSlider(value=1.0, min=0, max=20, description='b'), ipywidgets.Dropdown(options=['normal', 'beta', 'uniform'], value='beta'), ipywidgets.widgets.Output(), ipywidgets.Button(description='Preview') ])) return slider_list
def __init__(self, net_widget, interactions=None): self.key = "TFHill" self.net = net_widget self.interactions = interactions self.is_on = w.ToggleButton(description="TFHill", value=False, layout=w.Layout(width="15%", height="40px")) self.s1 = w.Dropdown( description="TF", options={"S{}".format(key): key for key in self.net.types["TF"]}) self.s2 = w.Dropdown(description="Gene", options={ "S{}".format(key): key for key in self.net.types["Genes"] }) self.custom_p = w.Checkbox(description="custom parameters", value=False) self.n = w.FloatText(description="n", value=1, step=0.0001) self.h = w.FloatText(description="h", value=1, step=0.0001) self.activity = w.Dropdown(description="Type", options={ "activation": 1, "repression": 0 }) self.update_param_state(False) self.update_inter_state(False) w.interactive(self.update_inter_state, button=self.is_on) w.interactive(self.update_param_state, button=self.custom_p)
def add_notch_filter(notch_filters, gap_filler): """Add a button for a simple square notch filter""" new_filter = widgets.HBox([widgets.FloatText(description='Begin', width='150px'), widgets.FloatText(description='End', width='150px'), gap_filler, widgets.Checkbox(description='Use filter', value=True)]) notch_filters.children += (new_filter,)
def buneman_widget(): style = {'description_width': '350px'} layout = Layout(width='55%') a = ipywidgets.Text(value='buneman.txt', description='Template Input File:', style=style, layout=layout) b = ipywidgets.Text(value='case1.txt', description='New Output File:', style=style, layout=layout) c = ipywidgets.BoundedFloatText(value=3, min=0.0, max=10.0, description='Electron Drift Velocity:', style=style, layout=layout) d = ipywidgets.FloatText(value=100.0, description='Mass Ratio (M/m):', style=style, layout=layout) e = ipywidgets.FloatText(value=200.0, description='TEND or the Total Simulation Time:', style=style, layout=layout) im = interact_calc(buneman_deck_maker, iname=a, oname=b, VX0=c, RMASS=d, tend=e) im.widget.manual_button.layout.width = '250px'
def srs_widget(): style = {'description_width': '350px'} layout = Layout(width='55%') a = widgets.Text(value='forslund-sbs.txt', description='Template Input File:', style=style, layout=layout) b = widgets.Text(value='case1.txt', description='New Output File:', style=style, layout=layout) c = widgets.FloatText(value=0.1, description='a0:', style=style, layout=layout) d = widgets.FloatText(value=0.035, description='uth/c:', style=style, layout=layout) e = widgets.FloatText(value=0.1, description='n/n_c:', style=style, layout=layout) f = widgets.FloatText(value=1800.0, description='tmax:', style=style, layout=layout) im = interact_calc(newifile, iname=a, oname=b, a0=c, uth=d, n0=e, tmax=f) im.widget.manual_button.layout.width = '250px'
def Requerimientos(): Req = widgets.Accordion(children=[ widgets.FloatText(value=2, disabled=False), widgets.FloatText(value=1) ]) Req.set_title(0, 'W') Req.set_title(1, 'H') return Req
def __init__(self, parent, model): self.parent = parent self.model = model cell_layout = wg.Layout(width='auto') self.Mu = wg.FloatText(value=model.Mu, description=r'$M_{u}$   <i>[lb*in]</i>', layout=cell_layout) self.Vu = wg.FloatText(value=model.Vu, description=r'$V_{u}$   <i>[lb]</i>', layout=cell_layout)
def create_gif(): """This function allows the user to select all the parameters to create their own GIFs. It saves them directly on their /work directory """ lonmax = widgets.FloatText(value=1.5153795, description='Long max:', disabled=False, step=0.001) latmax = widgets.FloatText(value=43.668708, description='Lat max:', disabled=False, step=0.001) lonmin = widgets.FloatText(value=1.3503956, description='Long min:', disabled=False, step=0.001) latmin = widgets.FloatText(value=43.532654, description='Lat min:', disabled=False, step=0.001) bbox_menu = widgets.VBox([lonmax, latmax, lonmin, latmin]) raw_bbox_menu = widgets.Textarea( value='1.5153795,43.668708,1.3503956,43.532654', placeholder='BBOX', disabled=False, layout=widgets.Layout(width='50%') ) cities_menu = widgets.Text(placeholder='Ex: Toulouse, Paris, New-York...') children = [bbox_menu, widgets.VBox([ widgets.Label(value="Enter a city:"), cities_menu ]), widgets.VBox([ widgets.Label(value="Enter a raw BBOX:"), raw_bbox_menu ])] tab = widgets.Tab() tab.children = children tab.set_title(0, 'Bounding Box') tab.set_title(1, 'Cities') tab.set_title(2, 'Raw Bounding Box') global_output = widgets.Output() out = widgets.Output() button = widgets.Button(description='Validate') display(tab) display(button) display(out) display(global_output) bbox = [1.5153795, 43.668708, 1.3503956, 43.532654] # default bbox on Toulouse # Defines the action when the button is clicked. # Here the button validates the bbox, and call the next widget (collection_widget) def click_bbox(b): global bbox bbox = get_bbox(tab, out, lonmax, latmax, lonmin, latmin, cities_menu, raw_bbox_menu) with global_output: clear_output(wait=True) get_collection(bbox) button.on_click(click_bbox)
def init_gui(self): stretches = ['linear', 'sqrt', 'log'] slider_layout = {'min_width': '50%'} minmax_layout = {'width': '100px'} stretch_layout = {'width': '80px'} text_range = ipywidgets.Label(value='', layout={'min_width': '50%'}) text_min = ipywidgets.Label(value='min.', layout=minmax_layout) text_max = ipywidgets.Label(value='max.', layout=minmax_layout) text_stretch = ipywidgets.Label(value='stretch', layout=stretch_layout) self.box_text = ipywidgets.HBox( [text_range, text_min, text_max, text_stretch]) self.slider_r = ipywidgets.FloatRangeSlider( description='<b style="color:#cc3737">Red:</b>', min=-9e99, max=9e99, step=1e98, value=(-9e99, 9e99), layout=slider_layout) self.min_r = ipywidgets.FloatText(value=-9e99, layout=minmax_layout) self.max_r = ipywidgets.FloatText(value=9e99, layout=minmax_layout) self.stretch_r = ipywidgets.Dropdown(options=stretches, value='linear', layout=stretch_layout) self.box_r = ipywidgets.HBox( [self.slider_r, self.min_r, self.max_r, self.stretch_r]) self.slider_r.observe(self.scale_red, names='value') self.stretch_r.observe(self.scale_red, names='value') self.min_r.observe(self.refresh_slider, names='value') self.max_r.observe(self.refresh_slider, names='value') self.slider_b = ipywidgets.FloatRangeSlider( description='<b style="color:#496bd8">Blue:</b>', min=-9e99, max=9e99, step=1e98, value=(-9e99, 9e99), layout=slider_layout) self.min_b = ipywidgets.FloatText(value=-9e99, layout=minmax_layout) self.max_b = ipywidgets.FloatText(value=9e99, layout=minmax_layout) self.stretch_b = ipywidgets.Dropdown(options=stretches, value='linear', layout=stretch_layout) self.box_b = ipywidgets.HBox( [self.slider_b, self.min_b, self.max_b, self.stretch_b]) self.slider_b.observe(self.scale_blue, names='value') self.stretch_b.observe(self.scale_blue, names='value') self.min_b.observe(self.refresh_slider, names='value') self.max_b.observe(self.refresh_slider, names='value') qlook_shape = self.ctrl.get_qlook_shape() self.img = ipywidgets.Image(height=qlook_shape[0], width=qlook_shape[1], format='bmp') return
def setup(self): self.var_dropdown = widgets.Dropdown( value=self.dataset._widgets.elevation_var, options=list(self.color_vars), ) self.var_dropdown.observe(lambda change: self._set_color_var(change['new']), names='value') self.colormaps_dropdown = widgets.Dropdown( options=self.colormaps, value=self.default_colormap ) da = self.dataset._widgets.color self.min_input = widgets.FloatText( value=da.min(), layout=widgets.Layout(height='auto', width='auto') ) self.max_input = widgets.FloatText( value=da.max(), layout=widgets.Layout(height='auto', width='auto') ) self.rescale_button = widgets.Button( description='Rescale', tooltip='Rescale to actual data range', layout=widgets.Layout(height='auto', width='auto'), ) self.rescale_button.on_click(lambda _: self.reset_color_limits()) self.rescale_step_button = widgets.Button( description='Rescale Step', tooltip='Rescale to actual data range (current step)', layout=widgets.Layout(height='auto', width='auto'), ) self.rescale_step_button.on_click(lambda _: self.reset_color_limits(step=True)) self.log_scale_checkbox = widgets.Checkbox( value=False, indent=False, layout=widgets.Layout(width='100px'), description='log scale' ) self.log_scale_checkbox.observe( lambda change: self._set_color_scale(log=change['new']), names='value' ) range_grid = widgets.GridspecLayout(3, 2) range_grid[0, 0] = self.min_input range_grid[0, 1] = self.max_input range_grid[1, 0] = self.rescale_button if self.dataset._widgets.time_dim is not None: range_grid[1, 1] = self.rescale_step_button range_grid[2, 0] = self.log_scale_checkbox return widgets.VBox( [ widgets.Label('Coloring:'), self.var_dropdown, widgets.Label('Colormap:'), self.colormaps_dropdown, widgets.Label('Color range / scale:'), range_grid, ] )
def _get_axis_widgets(obj): widgets = [] wd = {} name = ipywidgets.Text() widgets.append(labelme(ipywidgets.Label("Name"), name)) link((obj, "name"), (name, "value")) wd["name"] = name size = ipywidgets.IntText(disabled=True) widgets.append(labelme("Size", size)) link((obj, "size"), (size, "value")) wd["size"] = size index_in_array = ipywidgets.IntText(disabled=True) widgets.append(labelme("Index in array", index_in_array)) link((obj, "index_in_array"), (index_in_array, "value")) wd["index_in_array"] = index_in_array if obj.navigate: index = ipywidgets.IntSlider(min=0, max=obj.size - 1) widgets.append(labelme("Index", index)) link((obj, "index"), (index, "value")) wd["index"] = index value = ipywidgets.FloatSlider( min=obj.low_value, max=obj.high_value, ) wd["value"] = value widgets.append(labelme("Value", value)) link((obj, "value"), (value, "value")) link((obj, "high_value"), (value, "max")) link((obj, "low_value"), (value, "min")) link((obj, "scale"), (value, "step")) units = ipywidgets.Text() widgets.append(labelme("Units", units)) link((obj, "units"), (units, "value")) wd["units"] = units if hasattr(obj, "scale"): scale = ipywidgets.FloatText() widgets.append(labelme("Scale", scale)) link((obj, "scale"), (scale, "value")) wd["scale"] = scale if hasattr(obj, "offset"): offset = ipywidgets.FloatText() widgets.append(labelme("Offset", offset)) link((obj, "offset"), (offset, "value")) wd["offset"] = offset if "_expression" in obj.__dict__.keys(): expression = ipywidgets.Text(disabled=True) widgets.append(labelme("Expression", expression)) link((obj, "_expression"), (expression, "value")) wd["expression"] = expression return {"widget": ipywidgets.VBox(widgets), "wdict": wd}
def __init__(self, *args, **kwd): super(ToggleMinMax, self).__init__(*args, **kwd) style = {'description_width': 'initial'} self._min_box = widgets.FloatText(description="Low threshold", style=style) self._max_box = widgets.FloatText(description="High threshold", style=style) self.add_child(self._min_box) self.add_child(self._max_box)
def __init__(self, parent, model): self.parent = parent self.model = model cell_layout = wg.Layout(width='auto') self.fc_prime = wg.FloatText(value=model.fc_prime, description=r'$f^{\prime}_{c}$   <i>[psi]</i>', layout=cell_layout) self.strain_ult = wg.FloatText(value=model.strain_ult, description=r'$\epsilon_{u}$   <i>[in/in]</i>', layout=cell_layout) self.Ec = wg.FloatText(value=model.Ec, description=r'$E_c$   <i>[psi]</i>', layout=cell_layout)
def createControlRow(row_index, parameter_options): parameter_dropdown = widgets.Dropdown(options=parameter_options, value=no_selection) parameter_dropdown.rowIndex = row_index ft_LB = widgets.FloatText(disabled=True) ft_UB = widgets.FloatText(disabled=True) return [parameter_dropdown, ft_LB, ft_UB]
def image_constast_editor_ipy(obj, **kwargs): wdict = {} left = ipywidgets.FloatText(disabled=True) right = ipywidgets.FloatText(disabled=True) help = ipywidgets.HTML( "Click on the histogram figure and drag to the right to select a" "range. Press `Apply` to set the new contrast limits, `Reset` to reset " "them or `Close` to cancel.", ) wdict["help"] = help help = ipywidgets.Accordion(children=[help]) help.set_title(0, "Help") close = ipywidgets.Button( description="Close", tooltip="Close widget and remove span selector from the signal figure." ) apply = ipywidgets.Button( description="Apply", tooltip="Perform the operation using the selected range.") reset = ipywidgets.Button( description="Reset", tooltip="Reset the contrast to the previous value.") wdict["left"] = left wdict["right"] = right wdict["close_button"] = close wdict["apply_button"] = apply wdict["reset_button"] = reset # Connect link((obj, "ss_left_value"), (left, "value")) link((obj, "ss_right_value"), (right, "value")) def on_apply_clicked(b): obj.apply() apply.on_click(on_apply_clicked) def on_reset_clicked(b): obj.reset() reset.on_click(on_reset_clicked) box = ipywidgets.VBox([ labelme("vmin", left), labelme("vmax", right), help, ipywidgets.HBox((apply, reset, close)) ]) def on_close_clicked(b): obj.close() box.close() close.on_click(on_close_clicked) return { "widget": box, "wdict": wdict, }
def interactive_range_ipy(obj, **kwargs): # Define widgets wdict = {} axis = obj.axis left = ipywidgets.FloatText(disabled=True) right = ipywidgets.FloatText(disabled=True) units = ipywidgets.Label() help_text = ipywidgets.HTML( "Click on the signal figure and drag to the right to select a signal " "range. Press `Apply` to perform the operation or `Close` to cancel.", ) help = ipywidgets.Accordion(children=[help_text], selected_index=None) set_title_container(help, ["Help"]) close = ipywidgets.Button( description="Close", tooltip="Close widget and remove span selector from the signal figure." ) apply = ipywidgets.Button( description="Apply", tooltip="Perform the operation using the selected range.") wdict["left"] = left wdict["right"] = right wdict["units"] = units wdict["help_text"] = help_text wdict["close_button"] = close wdict["apply_button"] = apply # Connect link((obj, "ss_left_value"), (left, "value")) link((obj, "ss_right_value"), (right, "value")) link((axis, "units"), (units, "value")) def on_apply_clicked(b): if obj.ss_left_value != obj.ss_right_value: obj.span_selector_switch(False) for method, cls in obj.on_close: method(cls, obj.ss_left_value, obj.ss_right_value) obj.span_selector_switch(True) apply.on_click(on_apply_clicked) box = ipywidgets.VBox([ ipywidgets.HBox([left, units, ipywidgets.Label("-"), right, units]), help, ipywidgets.HBox((apply, close)) ]) def on_close_clicked(b): obj.span_selector_switch(False) box.close() close.on_click(on_close_clicked) return { "widget": box, "wdict": wdict, }
def create_settings(box): "Creates a widget Container for settings and info of a particular slider." _, slider, sl_units = box.children enable = widgets.Checkbox(value=box.visible, width="3ex") link((box, 'visible'), (enable, 'value')) def slider_link(obj, attr): "Function to link one object to an attr of the slider." # pylint: disable=unused-argument def link_fn(name, new_value): "How to update the object's value given min/max on the slider. " if new_value >= slider.max: slider.max = new_value # if any value is greater than the max, the max slides up # however, this is not held true for the minimum, because # during typing the max or value will grow, and we don't want # to permanently anchor the minimum to unfinished typing if attr == "max" and new_value <= slider.value: if slider.max >= slider.min: slider.value = new_value else: pass # bounds nonsensical, probably because we picked up # a small value during user typing. elif attr == "min" and new_value >= slider.value: slider.value = new_value setattr(slider, attr, new_value) slider.step = (slider.max - slider.min) / 24.0 obj.on_trait_change(link_fn, "value") link((slider, attr), (obj, "value")) text_html = "<span class='form-control' style='width: auto;'>" setvalue = widgets.FloatText(value=slider.value, description=slider.description) slider_link(setvalue, "value") fromlabel = widgets.HTML(text_html + "from") setmin = widgets.FloatText(value=slider.min, width="10ex") slider_link(setmin, "min") tolabel = widgets.HTML(text_html + "to") setmax = widgets.FloatText(value=slider.max, width="10ex") slider_link(setmax, "max") units = widgets.Label() units.width = "6ex" units.font_size = "1.165em" link((sl_units, 'value'), (units, 'value')) descr = widgets.HTML(text_html + slider.varkey.descr.get("label", "")) descr.width = "40ex" return widgets.HBox(children=[ enable, setvalue, units, descr, fromlabel, setmin, tolabel, setmax ], width="105ex")
def __init__(self, show_header=True): def el_ly(w): return dict(width='{}px'.format(w), margin='0px') # minimum block self.nomin = ipyw.Checkbox(value=True, layout=el_ly(125)) self.min = ipyw.FloatText(value=-float('inf'), layout=el_ly(165)) box_ly = dict(border='1px solid black', display='flex', margin='0px', flex_flow='row', width='290px') self.minbox = ipyw.Box([self.nomin, self.min], layout=box_ly) # value element self.value = ipyw.FloatText(value=0, layout=el_ly(170)) # maximum block self.nomax = ipyw.Checkbox(value=True, layout=el_ly(125)) self.max = ipyw.FloatText(value=float('inf'), layout=el_ly(165)) self.maxbox = ipyw.Box([self.nomax, self.max], layout=box_ly) # constraints block self.vary = ipyw.Checkbox(value=True, layout=el_ly(125)) self.expr = ipyw.Text(value='', continuous_update=False, layout=el_ly(275)) # array elements in an horizontal block self.elements = [ self.minbox, self.value, self.maxbox, self.vary, self.expr ] # Header labels self.header = None if show_header is True: d_lbs = (('-inf', 125), ('min', 165), ('value', 170), ('inf', 125), ('max', 165), ('vary', 125), ('expression', 275)) l_lbs = [ipyw.Label(k, layout=el_ly(v)) for (k, v) in d_lbs] box_ly = dict(display='flex', margin='0px', border='solid') self.header = ipyw.HBox(l_lbs, layout=box_ly) # Layout if self.header is None: box_ly = dict(display='flex', margin='0px', border='solid', flex_flow='row') super(ParameterWidget, self).__init__(self.elements, layout=box_ly) else: box_ly = dict(display='flex', margin='0px', border='solid') b_els = ipyw.HBox(self.elements, layout=box_ly) box_ly.update({'flex_flow': 'column'}) super(ParameterWidget, self).__init__([self.header, b_els], layout=box_ly)
def circle_and_the_line(): m, b = get_m_b_sliders() out = widgets.interactive_output( lambda m, b: plot_proba(class_inner, class_outer, linear, m, b), { 'm': m, 'b': b }) loss_plot(None, None, reset=True) loss_display = widgets.interactive_output( lambda m, b: loss_plot(np.mean([ binary_crossentropy( 0, linear_sigmoid(class_inner_x, class_inner_y, m, b)), binary_crossentropy( 1, linear_sigmoid(class_outer_x, class_outer_y, m, b)) ]), loss_name='b. c. e.'), { 'm': m, 'b': b }) acc_text = widgets.interactive_output( lambda m, b: display( widgets.FloatText(value=round( np.mean([ 1 - accuracy(class_inner[1], linear(class_inner[0], m, b)), accuracy(class_outer[1], linear(class_outer[0], m, b)) ]), 3), description='accuracy:', disabled=False, layout={'width': '100%'})), { 'm': m, 'b': b }) bce_text = widgets.interactive_output( lambda m, b: display( widgets.FloatText(value=round( np.mean([ binary_crossentropy( 0, linear_sigmoid(class_inner_x, class_inner_y, m, b)), binary_crossentropy( 1, linear_sigmoid(class_outer_x, class_outer_y, m, b)) ]), 3), description='b. c. e. loss:', disabled=False, layout={'width': '100%'})), { 'm': m, 'b': b }) display( widgets.VBox([ widgets.HBox([out, loss_display]), widgets.VBox([m, b, acc_text, bce_text]) ], layout=widgets.Layout(align_items='center')))
def options(X): style = {'description_width': 'initial'} #general style settings ### Define sample properties ### fn = X['fn'] prop_title = widgets.HTML(value='<h3>Sample preprocessing options</h3>') mass_title = widgets.HTML(value='To disable mass normalization use a value of -1') sample, unit, mass = ut.sample_details(X) sample_widge = widgets.Text(value=sample,description='Sample name:',style=style) if mass == "N/A": mass_widge = widgets.FloatText(value=-1, description = 'Sample mass (g):',style=style) else: mass_widge = widgets.FloatText(value=mass, description = 'Sample mass (g):',style=style) mass_widge1 = HBox([mass_widge,mass_title]) ### Define measurement corrections ### correct_title = widgets.HTML(value='<h3>Select preprocessing options:</h3>') slope_widge = widgets.FloatSlider( value=70, min=1, max=100.0, step=1, description='Slope correction [%]:', style=style, readout_format='.0f', ) slope_title = widgets.HTML(value='To disable high-field slope correction use a value of 100%') slope_widge1 = HBox([slope_widge,slope_title]) drift_widge = widgets.Checkbox(value=False, description='Measurement drift correction') fpa_widge = widgets.Checkbox(value=False, description='Remove first point artifact') lpa_widge = widgets.Checkbox(value=False, description='Remove last point artifact') correct_widge = VBox([correct_title,sample_widge,mass_widge1,slope_widge1,drift_widge,fpa_widge,lpa_widge]) preprocess_nest = widgets.Tab() preprocess_nest.children = [correct_widge] preprocess_nest.set_title(0, 'PREPROCESSING') display(preprocess_nest) X["sample"] = sample_widge X["mass"] = mass_widge X["unit"] = unit X["drift"] = drift_widge X["slope"] = slope_widge X["fpa"] = fpa_widge X["lpa"] = lpa_widge return X
def data_input(mode): if mode == 'чтение из файла': display_file_input(lambda path: load_file(path), description='Загрузить:', placeholder='Путь к файлу с a, b, Δ, разделенными пробелом', button_text="Открыть") else: int_start = widgets.FloatText(description='a', value=0.0, step=0.1) int_end = widgets.FloatText(description='b', value=0.0, step=0.1) delta = widgets.FloatText(description='Δ', value=0.01, step=0.000001) widgets.interact(find_root, int_start=int_start, int_end=int_end, delta=delta)