def cut(image): """Interactive line cuts of 2D Images. Uses ipywidgets for interactivity. Args: image: Image to take line cuts of. The type should be a Holoviews Image. """ #Defines a Holoviews Stream class for an x,y position class xy(hv.streams.Stream): x = param.Number(default=0.0, doc='An X position.') y = param.Number(default=0.0, doc='A Y position.') #Points for each axis x_axis = np.unique(image.dimension_values(0)) y_axis = np.unique(image.dimension_values(1)) #Create a slider widget to control x and y cut locations xw = widgets.SelectionSlider(options=[("%g" % i, i) for i in x_axis]) yw = widgets.SelectionSlider(options=[("%g" % i, i) for i in y_axis]) xyst = xy(x=x_axis[0], y=y_axis[0]) #Define function that creates Holoviews Layout. This Layout contains #the original 2D image, lines going through the x,y point specified, #and the line cuts themselves def marker(x, y): x_dim = {image.kdims[0].label: x} y_dim = {image.kdims[1].label: y} crosssection1 = image.sample(**x_dim).opts(norm=dict(framewise=True)) crosssection1y = image.sample(**y_dim).opts(norm=dict(framewise=True)) return hv.Layout(image * hv.VLine(x) * hv.HLine(y) + crosssection1 + crosssection1y).cols(2).opts(norm=dict(axiwise=True)) #Create DynamicMap of above Layout such that the x,y positions can be #streamed and updated dmap = hv.DynamicMap(marker, streams=[xyst]) #Function that widget can call to update DynamicMap. When this Stream object #updates the x,y position via the Slider widget and then the event method #called, the DynamicMap recomputes marker based off this and thus updates #the line cut. def plot(x, y): xyst.event(x=x, y=y) hv.ipython.display(dmap) #Return statement is the syntax for interacting widgets (see ipywidget docs). return widgets.interact( plot, x=widgets.SelectionSlider(options=[("%g" % i, i) for i in x_axis], continuous_update=False), y=widgets.SelectionSlider(options=[("%g" % i, i) for i in y_axis]))
def slider_interact(plot_function, df, options, option_column, initial_option=None, option_label=None, disabled=False, button_style='', **kwargs): if option_label is None: option_label = vh.labelfy(option_column) option_slider = widgets.SelectionSlider( options=options, value=options[0] if initial_option is None else initial_option, description=option_label, disabled=disabled, button_style=button_style) widgets.interact(plot_subset, plot_function=widgets.fixed(plot_function), df=widgets.fixed(df), option=option_slider, option_column=widgets.fixed(option_column), kwargs=widgets.fixed(kwargs))
def widget_dataset(self, dataset=None): """ Parameters ---------- dataset : str One of the keys of the instance attribute "datasets" such as "blobs", "circles", or "moons". Notes ----- Displays the chosen dataset and calls other relevant widget methods. """ if not dataset: return self.display = False self.split_data = False plt.close("all") self.fig_1, self.axs_1 = plt.subplots(1, 2, figsize=(8, 4)) self.axs_1[1].axis("off") chosen_dataset = self.datasets[dataset] # get_blobs ipywidgets.interact(chosen_dataset["widget"], **chosen_dataset["args"]) ipywidgets.interact( self.choose_classifier, classifier=ipywidgets.Dropdown( options=["decision_tree", "logistic_regression"], value="decision_tree", ), ) ipywidgets.interact( self.run_widget_dt, max_depth=ipywidgets.SelectionSlider(options=range(1, 20), value=1), )
def __init__(self, filefilter, processing=Generic2DPlotCtrl._idle, **extra_kwargs): fp = filefilter + '/*.h5' if os.path.isdir(filefilter) else filefilter self.filter, self.flist, self.processing = fp, sorted( glob.glob(fp)), processing try: self.data = processing(osh5io.read_h5(self.flist[0])) except IndexError: raise IOError('No file found matching ' + fp) items_layout = Layout(flex='1 1 auto', width='auto') self.file_slider = widgets.SelectionSlider(options=self.flist, description='filename:', value=self.flist[0], continuous_update=False, layout=items_layout) self.time_label = widgets.Label(value=osh5vis.time_format( self.data.run_attrs['TIME'][0], self.data.run_attrs['TIME UNITS']), layout=items_layout) self.file_slider.observe(self.update_slice, 'value') super(DirSlicer, self).__init__(self.data, time_in_title=False, **extra_kwargs)
def __init__ (self, top, ch, input_range = 1.0): super().__init__(ch, input_range) self.top = top self.ch = ch self.reset() # decimation rate self.decimation = 1 # trigger level [V] and edge self.level = [-0.1, +0.1] self.edge = 'pos' # control event mask self.sync_src = overlay.sync_src['osc0'] self.trig_src = overlay.trig_src['osc0'] # TODO: this default should be set in the oscilloscope application class # create widgets self.w_t_edge = ipw.ToggleButtons (value=self.edge, options=['pos', 'neg'], description='T edge') self.w_t_position = ipw.FloatRangeSlider (value=self.level, min=-1.0, max=+1.0, step=0.02, description='T position') self.w_y_position = ipw.FloatSlider (value=self.y_position, min=-1.0, max=+1.0, step=0.01, description='Y position') self.w_y_scale = ipw.SelectionSlider (value=self.y_scale, options=self.y_scales, description='Y scale') # style widgets self.w_t_position.layout = ipw.Layout(width='100%') self.w_y_scale.layout = ipw.Layout(width='100%') self.w_y_position.layout = ipw.Layout(width='100%') self.w_t_edge.observe (self.clb_t_edge , names='value') self.w_t_position.observe (self.clb_t_position, names='value') self.w_y_scale.observe (self.clb_y_scale , names='value') self.w_y_position.observe (self.clb_y_position, names='value')
def render(self): if self.low_name: self.low = getattr(self.model, str(self.low_name)) if self.high_name: self.high = getattr(self.model, str(self.high_name)) if self.n_steps_name: self.n_steps = getattr(self.model, str(self.n_steps_name)) step = (self.high - self.low) / self.n_steps round_value = self._get_round_value(self.low, self.high, self.n_steps) if not self.readout_format: self.readout_format = '.' + str(round_value) + 'f' # There's a bug in FloatSlider for very small step, see https://github.com/jupyter-widgets/ipywidgets/issues/259 # it will be fixed in ipywidgets v8.0.0, but until then, the following fix will be used # with this implementation, entering the number manually in the readout will not work values = np.linspace(self.low, self.high, int(self.n_steps)) values = np.round(values, round_value) # This is for SelectionSlider because 'value' must match exactly one of values array self.value = self._find_nearest(values, self.value) return ipw.SelectionSlider( options=values, value=self.value, tooltip=self.tooltip, continuous_update=self.continuous_update, description=self.label, disabled=self.disabled, readout=self.readout, style=style )
def user_selection(): global selected_persona, selected_percentile, selection_filter, variable_inputs selected_percentile = widgets.SelectionSlider(options=[ '0', '10%', '20%', '30%', '40%', '50%', '60%', '70%', '80%', '90%', '100%' ], value='50%', description='Percentile', layout=Layout( width='60%', margin='30px 0 30px 0')) selected_persona = widgets.ToggleButtons(options=[ 'Boy', 'Teenage Boy', 'Young Man', 'Middle Aged Man', 'Old Man', 'Girl', 'Teenage Girl', 'Young Woman', 'Middle Aged Woman', 'Old Woman' ], value='Young Woman', description='AGE:', layout=Layout(width='95%')) if (selected_persona.value == 'Boy'): selection_filter = data_dict[(data_dict.age_category.str.contains('child')) & \ (data_dict.sex.str.contains('Male'))] elif (selected_persona.value == 'Girl'): selection_filter = data_dict[(data_dict.age_category.str.contains('child')) & \ (data_dict.sex.str.contains('Female'))] elif (selected_persona.value == 'Teenage Boy'): selection_filter = data_dict[(data_dict.age_category.str.contains('teenager')) & \ (data_dict.sex.str.contains('Male'))] elif (selected_persona.value == 'Teenage Girl'): selection_filter = data_dict[(data_dict.age_category.str.contains('teenager')) & \ (data_dict.sex.str.contains('Female'))] elif (selected_persona.value == 'Young Man'): selection_filter = data_dict[(data_dict.age_category.str.contains('young')) & \ (data_dict.sex.str.contains('Male'))] elif (selected_persona.value == 'Young Woman'): selection_filter = data_dict[(data_dict.age_category.str.contains('young')) & \ (data_dict.sex.str.contains('Female'))] elif (selected_persona.value == 'Middle Aged Man'): selection_filter = data_dict[(data_dict.age_category.str.contains('middle aged')) & \ (data_dict.sex.str.contains('Male'))] elif (selected_persona.value == 'Middle Aged Woman'): selection_filter = data_dict[(data_dict.age_category.str.contains('middle aged')) & \ (data_dict.sex.str.contains('Female'))] elif (selected_persona.value == 'Old Man'): selection_filter = data_dict[(data_dict.age_category.str.contains('old')) & \ (data_dict.sex.str.contains('Male'))] elif (selected_persona.value == 'Old Woman'): selection_filter = data_dict[(data_dict.age_category.str.contains('old')) & \ (data_dict.sex.str.contains('Female'))] list_of_variable_inputs = selection_filter["variables"].values[0:] variable_inputs = ', '.join(list_of_variable_inputs).replace(" ", "") variable_inputs = variable_inputs.split(',')
def joint_player(self): # no player for static view static = True for a in self.arg: if not a.static: static = False if static: return # compute timeline timeline = [] for v in self.arg: p = v.ctrl.widgets["player"] if p.timeline is not None: timeline = timeline + p.timeline timeline = list(set(timeline)) timeline.sort() self.timeline = timeline # init widgets self.player = widgets.Play(value=0, min=0, max=len(timeline) - 1, interval=150) self.slider = widgets.SelectionSlider(value=timeline[0], options=timeline) self.speed = widgets.Dropdown( options=[("1", 250), ("2", 200), ("3", 150), ("4", 100), ("5", 50)], value=150, description="Speed:", layout=widgets.Layout( width="100px" ), style={ "description_width": "45px" } ) def on_slider_change(change): t = change.new self.player.value = self.timeline.index(t) for v in self.arg: p = v.ctrl.widgets["player"] if p.slider is not None and t in p.slider.options: p.slider.value = t self.slider.observe(on_slider_change, names="value") def on_player_change(change): t = self.timeline[change.new] self.slider.value = t for v in self.arg: p = v.ctrl.widgets["player"] if p.slider is not None and t in p.slider.options: p.slider.value = t self.player.observe(on_player_change, names="value") widgets.link((self.speed, "value"), (self.player, "interval"))
def colorwidget(img, paramlist=None): """Display info to user on colorspace if paramlist is not empty.""" if paramlist: seg = colorspace(paramlist=paramlist) else: seg = colorspace() print(f"seg.params = {seg.params}") widg = dict() widglist = [] for ppp, ind in zip(seg.paramindexes, range(len(seg.paramindexes))): thislist = seg.params.ranges[ppp] name = ppp current_value = seg.params[ppp] if current_value not in thislist: # TODO: We should find the min distance between current_value and # this list and use that instead. current_value = thislist[0] thiswidg = widgets.SelectionSlider( options=tuple(thislist), disabled=False, description=name, value=current_value, continuous_update=False, orientation="horizontal", readout=True, ) widglist.append(thiswidg) widg[ppp] = thiswidg def func(**kwargs): """Find mask and fitness for current algorithm. Show masked image.""" for k in kwargs: seg.params[k] = kwargs[k] colorspace = seg.evaluate(img) # fit = Segmentors.FitnessFunction(mask, gmask) fig = showtwo(img, colorspace) showimage( img, ax=fig.gca(), color=seg.params["colorspace"], multichannel=seg.params["multichannel"], channel=seg.params["channel"], ) # I like the idea of printing the sharepython but it should be below the figures. # print(seg.sharepython(img)) # plt.title('Fitness Value: ' + str(fit[0])) layout = widgets.Layout(grid_template_columns="1fr 1fr 1fr") u_i = widgets.GridBox(widglist, layout=layout) out = widgets.interactive_output(func, widg) display(u_i, out) return seg.params
def __init__(self, top, ch, input_range=1.0): super().__init__(ch, input_range) self.top = top self.ch = ch self.reset() # TODO: for now bypass input filter self.filter_bypass = True # decimation rate self.decimation = 1 # trigger level [V], edge and holdoff [periods] self.level = [-0.1, +0.1] self.edg = 'pos' self.holdoff = 0 # trigger source mask #sh = 6*(ch+2) sh = 6 * (0 + 2) sh_t = 6 * (0 + 2) self.mask = [(0x1 << sh), (0x2 << sh), (0x4 << sh), (0x8 << sh) | (0x10 << sh_t)] # create widgets self.w_t_edge = ipw.ToggleButtons(value=self.edge, options=['pos', 'neg'], description='T edge') self.w_t_position = ipw.FloatRangeSlider(value=self.level, min=-1.0, max=+1.0, step=0.02, description='T position') self.w_t_holdoff = ipw.FloatSlider(value=self.holdoff, min=0, max=1, step=0.1, description='T hold off') self.w_y_position = ipw.FloatSlider(value=self.y_position, min=-1.0, max=+1.0, step=0.01, description='Y position') self.w_y_scale = ipw.SelectionSlider(value=self.y_scale, options=self.y_scales, description='Y scale') # style widgets self.w_t_position.layout = ipw.Layout(width='100%') self.w_t_holdoff.layout = ipw.Layout(width='100%') self.w_y_scale.layout = ipw.Layout(width='100%') self.w_y_position.layout = ipw.Layout(width='100%') self.w_t_edge.observe(self.clb_t_edge, names='value') self.w_t_position.observe(self.clb_t_position, names='value') self.w_t_holdoff.observe(self.clb_t_holdoff, names='value') self.w_y_scale.observe(self.clb_y_scale, names='value') self.w_y_position.observe(self.clb_y_position, names='value')
def interact(self): """ Display an interactive widget for choosing the profile. """ # Setup the initial value options for the location dim = self.default_dimension dim2 = set(self.data.dims).difference({dim}).pop() options = self.data[dim2].values.tolist()[::self.profile_interval] mid = options[len(options)//2] # Make the slider for choosing the location slider_label = widgets.Label("at {} value".format(dim2)) slider = widgets.SelectionSlider(options=options, value=mid, layout=widgets.Layout(width="350px")) # Make a menu for choosing the profile direction dimension_chooser = widgets.Dropdown( options=self.data.dims.keys(), value=dim, description="Profile along") def displayer(location, dimension): "Update and display the plot with given arguments" self.plot(location, dimension) display(self.fig) def handle_dimension_change(change): "Change the location options when dimension changes" dim2 = set(self.data.dims).difference({change.new}).pop() slider_label.value = "at {} value".format(dim2) options = self.data[dim2].values.tolist()[::self.profile_interval] slider.options = options slider.value = options[len(options)//2] # Connect the dimension change to the slider dimension_chooser.observe(handle_dimension_change, names='value') # Make the output display and connect it to the callback output = widgets.interactive_output( displayer, {'location': slider, 'dimension': dimension_chooser}) # Make a title for the widget title = widgets.HTML( '<strong style="font-size: 1.5em;">Profile selector</strong>') # Layout the widgets layout = widgets.VBox( [title, widgets.HBox([dimension_chooser, slider_label, slider]), output], layout=widgets.Layout(align_items="center")) # For some reason, calling _figure_setup inserts a plot in the output # Call clear_output to get rid of it. with output: clear_output(wait=True) display(self.fig) return layout
def _create_grouping_slider(value, target): return widgets.SelectionSlider( options=[freq_to_human_readable(freq) for freq in FREQUENCIES], value=value, description=f'Group {target} by:', disabled=False, continuous_update=True, orientation='horizontal', readout=True)
def __init__(self, plots): """ Compiles non-axis coordinates into sliders, the values from which are used to reconstruct plots upon movement of slider. Args: * plot cube_browser plot instance to display with slider. """ if not isinstance(plots, Iterable): plots = [plots] self.plots = plots # Mapping of coordinate/alias name to axis. self._axis_by_name = {} # Mapping of cube-id to shared cache. self._cache_by_cube_id = {} # Mapping of plot-id to coordinate/alias name. self._names_by_plot_id = {} # Mapping of coordinate/alias name to plots. self._plots_by_name = {} self._build_mappings() self._slider_by_name = {} self._name_by_slider_id = {} if self._axis_by_name: name_len = max([len(name) for name in self._axis_by_name]) children = [] for axis in self._axis_by_name.values(): if hasattr(axis, 'coord') and axis.coord.units.is_time_reference(): pairs = [(axis.coord.units.num2date(axis.coord.points[i]), i) for i in range(axis.size)] elif hasattr(axis, 'coord'): pairs = [(axis.coord.points[i], i) for i in range(axis.size)] else: pairs = [(i, i) for i in range(axis.size)] options = OrderedDict(pairs) slider = ipywidgets.SelectionSlider(options=options) slider.observe(self.on_change, names='value') self._slider_by_name[axis.name] = slider self._name_by_slider_id[id(slider)] = axis.name # Explicitly control the slider label in order to avoid # fix width widget description label wrapping issues. # XXX: Adjust px/em scale-factor dynamically based on font-size. scale_factor = .65 width = u'{}em'.format(int(name_len * scale_factor)) label = ipywidgets.Label(axis.name, padding=u'0.3em', width=width) hbox = ipywidgets.HBox(children=[label, slider]) children.append(hbox) # Layout the sliders in a consitent order. self.form = ipywidgets.VBox() key = lambda hbox: hbox.children[0].value self.form.children = sorted(children, key=key)
def slider(values, name, default=None): if default is None: default = values[0] return widgets.SelectionSlider(options=values, value=default, description=name, disabled=False, continuous_update=False, orientation='horizontal', readout=True)
def get_widget(desc): w = widgets.SelectionSlider(options=desc['values'], value=desc['default'], description=desc['text'], disabled=False, continuous_update=False, orientation='horizontal', style={'description_width': '100px'}, readout=True) return w
def __init__(self, text="Upload Zip or Tar archive", node_class=None, **kwargs): """ Upload multiple structures and store them in AiiDA database. :param text: Text to display before upload button :type text: str :param node_class: AiiDA node class for storing the structure. Possible values: 'StructureData', 'CifData' or None (let the user decide). Note: If your workflows require a specific node class, better fix it here. """ self.file_upload = FileUploadWidget(text) self.tmp_folder = None self.archive_name = '' # define the view part of the widget self.viewer = nglview.NGLWidget() self.selection_slider = ipw.SelectionSlider( options=[ None, ], disabled=False, orientation='vertical', description='Browse structures:', readout=False, layout=Layout(width='50%'), ) view = ipw.HBox([self.viewer, self.selection_slider]) # define the action part of the widget self.btn_store_all = ipw.Button(description='Store all in AiiDA', disabled=True) self.btn_store_selected = ipw.Button(description='Store selected', disabled=True) self.structure_description = ipw.Text(placeholder="Description (optional)") self.data_format = ipw.RadioButtons(options=['StructureData', 'CifData'], description='Data type:') # if node_class is predefined, there is no need to select it afterwards if node_class is None: store = ipw.HBox( [self.btn_store_all, self.data_format, self.structure_description, self.btn_store_selected]) else: store = ipw.HBox([self.btn_store_all, self.structure_description, self.btn_store_selected]) self.data_format.value = node_class # define main data objects self.structure_ase = None # contains the selected structure in the ase format self.structure_nodes = [] # a list that contains all stored structure objects self.structure_names = [] # list of uploaded structures # put all visual parts in children list and initialize the parent Vbox widget with it children = [self.file_upload, view, store] super(MultiStructureUploadWidget, self).__init__(children=children, **kwargs) # attach actions to the buttons self.file_upload.observe(self._on_file_upload, names='data') self.selection_slider.on_trait_change(self.change_structure, 'value') self.btn_store_all.on_click(self._on_click_store_all) self.btn_store_selected.on_click(self._on_click_store_selected)
def __init__(self): self.datasets = { "blobs": { "widget": self.get_blobs, "args": { "num_classes": ipywidgets.SelectionSlider(options=[1, 2, 3, 4, 5], value=2), "cluster_std": ipywidgets.SelectionSlider( options=[0.25, 0.5, 0.75, 1.0, 1.25, 1.5], value=1.0), }, }, "circles": { "widget": self.get_circles, "args": { "noise": ipywidgets.SelectionSlider(options=np.arange(0, 1, 0.05), value=0.1), "scale_factor": ipywidgets.SelectionSlider( options=np.arange(0, 1, 0.1), value=0.5, ), }, }, "moons": { "widget": self.get_moons, "args": {}, }, } self.models_class = { "decision_tree": DecisionTreeClassifier, "logistic_regression": LogisticRegression, } self.scatter_count = 0 self.clf_class = DecisionTreeClassifier self.classifier_string = "decision_tree" self.max_depth = 1 self.display = False self.split_data = False
def getCreationPanel(self) -> ip.VBox: load: ip.Button = ip.Button(description="Create", layout=ip.Layout(flex='1 1 auto'), border='1px solid dimgrey') self._model_dims_selector: ip.SelectionSlider = ip.SelectionSlider( options=range(3, 50), description='Model Dimension:', value=self.model_dims, layout=ip.Layout(width="auto"), continuous_update=True, orientation='horizontal', readout=True, disabled=False) self._subsample_selector: ip.SelectionSlider = ip.SelectionSlider( options=range(1, 50), description='Subsample:', value=self.subsample, layout=ip.Layout(width="auto"), continuous_update=True, orientation='horizontal', readout=True, disabled=False) load.on_click(self.prepare_inputs) self._progress = ip.FloatProgress(value=0.0, min=0, max=1.0, step=0.01, description='Progress:', bar_style='info', orientation='horizontal', layout=ip.Layout(flex='1 1 auto')) button_hbox: ip.HBox = ip.HBox([load, self._progress], layout=ip.Layout(width="100%", height="auto")) creationPanel: ip.VBox = ip.VBox( [self._model_dims_selector, self._subsample_selector, button_hbox], layout=ip.Layout(width="100%", height="100%"), border='2px solid firebrick') return creationPanel
def plot_interactive_sol(self): try: getattr(self, "sol_grid") except AttributeError: self.solgrid() def plot_from_dict(ph, B): contInvest.plot_instance( self.sol_grid[ph, B]['IR'], self.sol_base['IR'], self.sol_grid[ph, B]['Istar'], self.sol_base['Istar'], self.sol_grid[ph, B]['Sol'], self.sol_base['Sol'], self.grids['A'], self.sol_grid_ylim) prob = widgets.SelectionSlider(description="Probability, $p_H$", options=self.grids['pH'], style={'description_width': 'initial'}) benefit = widgets.SelectionSlider( description="Private benefit, $B$", options=self.grids['B'], style={'description_width': 'initial'}) widgets.interact(plot_from_dict, ph=prob, B=benefit)
def plot_interactive_ds(self): try: getattr(self, "ds_grid") except AttributeError: self.dsgrid() def plot_from_dict(n, lambda_): TwoAgent_GE.plot_ds_instance(self.ds_grid[n, lambda_]['d'], self.ds_base['d'], self.ds_grid[n, lambda_]['s'], self.ds_base['s'], self.grids['R']) nslider = widgets.SelectionSlider( description="Endowment, $n$", options=self.grids['n'], style={'description_width': 'initial'}) lambda_slider = widgets.SelectionSlider( description="Borrowing constr., $\\lambda$", options=self.grids['lambda_'], style={'description_width': 'initial'}) widgets.interact(plot_from_dict, n=nslider, lambda_=lambda_slider)
def __init__(self, list_of_metrics): self.metric_dropdown = widgets.Dropdown(options=list_of_metrics, description='Metric') self.plot_toggle = widgets.ToggleButtons( options=['Count', 'Change'], value='Count', description='', disabled=False, button_style='', tooltips=['Display absolute counts', 'Display change over time']) options = [(" Q{} {} ".format(qtr, year), (qtr, year)) for year in range(2005, 2016) for qtr in range(1, 5)] self.time_slider = widgets.SelectionSlider(options=options, description='Quarter', disabled=False, continuous_update=False, layout=Layout(width='60%')) self.time_range_slider = widgets.SelectionRangeSlider( options=options, index=(0, len(options) - 1), description='Time Range', disabled=False, layout=Layout(width='60%')) self.time_range_slider.layout.visibility = 'hidden' self.generate_button = widgets.Button(description='Generate Plot', disabled=False, tooltip='Generate Plot') self.panel_items = [ HBox([self.metric_dropdown]), HBox([self.plot_toggle]), VBox([self.time_slider, self.time_range_slider]), HBox([self.generate_button]) ] self.input_panel = VBox(self.panel_items) self.output = Output() def on_value_change(change): if change['new'] == 'Count': self.time_range_slider.layout.visibility = 'hidden' self.time_slider.layout.visibility = 'visible' elif change['new'] == 'Change': self.time_slider.layout.visibility = 'hidden' self.time_range_slider.layout.visibility = 'visible' self.plot_toggle.observe(on_value_change, names='value')
def unit_player(self): # no player for static view if self.arg.static: return # compute timeline layer, legend, profile = self.arg.get() temp_path = self.arg.temp_path file_list = self.arg.file_list timeline = [t.split(".")[0] for t in self.arg.file_list] timeline = [parser.parse(t) for t in timeline] self.timeline = timeline # init widgets self.player = widgets.Play(value=0, min=0, max=len(timeline) - 1, interval=150) self.slider = widgets.SelectionSlider(value=timeline[0], options=timeline) self.speed = widgets.Dropdown( options=[("1", 250), ("2", 200), ("3", 150), ("4", 100), ("5", 50)], value=150, description="Speed:", layout=widgets.Layout( width="100px" ), style={ "description_width": "45px" } ) # slider change event def on_slider_change(change): i = self.timeline.index(change.new) self.player.value = i # regarding change on player img = os.path.join(temp_path, file_list[i]) layer.url = View.Layer.read_image(img) self.slider.observe(on_slider_change, names="value") # player change event def on_player_change(change): t = self.timeline[change.new] self.slider.value = t # regarding change on slider img = os.path.join(temp_path, file_list[change.new]) layer.url = View.Layer.read_image(img) self.player.observe(on_player_change, names="value") # speed change event widgets.link((self.speed, "value"), (self.player, "interval"))
def segmentwidget(img, gmask, params=None, alg=None): """Generate GUI. Produce slider for each parameter for the current segmentor. Show both options for the masked image. Keyword arguments: img -- original image gmask -- ground truth segmentation mask for the image params -- list of parameter options alg -- algorithm to search parameters over """ if params is None and alg is None: alg = 'FB' params = [alg, 0, 0.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,\ (1, 1), 0, 'checkerboard', 'checkerboard', 0, 0, 0, 0, 0, 0] elif params is None and alg is not None: params = [alg, 0, 0.0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,\ (1, 1), 0, 'checkerboard', 'checkerboard', 0, 0, 0, 0, 0, 0] elif params is not None and alg is not None: params[0] = alg seg = Segmentors.algoFromParams(params) widg = dict() widglist = [] for ppp in seg.paramindexes: thislist = eval(seg.params.ranges[ppp]) thiswidg = widgets.SelectionSlider(options=tuple(thislist), disabled=False, description=ppp, value=seg.params[ppp], continuous_update=False, orientation='horizontal', readout=True) widglist.append(thiswidg) widg[ppp] = thiswidg def func(img=img, mask=gmask, **kwargs): """Find mask and fitness for current algorithm. Show masked image.""" print(seg.params["algorithm"]) for k in kwargs: seg.params[k] = kwargs[k] mask = seg.evaluate(img) fit = Segmentors.FitnessFunction(mask, gmask) fig = showtwo(img, mask) plt.title('Fitness Value: ' + str(fit[0])) layout = widgets.Layout(grid_template_columns='1fr 1fr 1fr') u_i = widgets.GridBox(widglist, layout=layout) out = widgets.interactive_output(func, widg) display(u_i, out) return seg.params
def interactive_plot(pathCDF): """ Interactive plot of all the variables of a NetCDF file. :param pathCDF: Path to the NetCDF file :type pathCDF: str :return: the interactive object for interactive plots :rtype: :class:`ipywidgets.widgets.interactive` object """ resultsCDF = Dataset(pathCDF, 'r', format='NETCDF4', parallel=False) times = resultsCDF['t'][:].data times_ind = np.arange(len(times)) disp_times = [ '{}'.format(int(np.floor(times[k] // 3600))) + 'h {}min'.format(int(np.floor(times[k] % 3600 // 60))) for k in times_ind ] vars_opts = list(resultsCDF.variables) cmap_opts = [ 'magma', 'Greys', 'hot', 'viridis', 'plasma', 'inferno', 'cividis' ] time_opts = [(disp_times[k], k) for k in times_ind] resultsCDF.close() vars_widg = widgets.ToggleButtons(options=vars_opts, value=vars_opts[0], description='variable :', disabled=False) time_widg = widgets.SelectionSlider(options=time_opts, value=0, description='t = ', continuous_update=False, disabled=False) cmap_widg = widgets.Select(options=cmap_opts, value='magma', description='colormap :', disabled=False) inter = widgets.interactive(plot_data, pathCDF=widgets.fixed(pathCDF), cmap=cmap_widg, variable=vars_widg, time=time_widg) return inter
def plot_interactive_cequi(self): try: getattr(self, "c_grid") except AttributeError: self.capequigrid() def plot_from_dict(lambda_): TwoAgent_GE.plot_c_instance(self.c_grid[lambda_]['E'], self.c_base['E'], self.grids['n']) lambda_slider = widgets.SelectionSlider( description="Borrowing constr., $\\lambda$", options=self.grids['lambda_'], style={'description_width': 'initial'}) widgets.interact(plot_from_dict, lambda_=lambda_slider)
def plot_interactive_pc(self): try: getattr(self, "I_grid") except AttributeError: self.pc_grid_of_I() def plot_from_dict(I): OptDebt.plot_pc_instance(self.I_grid[I]['I'], self.I_base['I'], self.grids['I']) I_slider = widgets.SelectionSlider( description="Investment cost, $I$", options=self.grids['I'], style={'description_width': 'initial'}) widgets.interact(plot_from_dict, I=I_slider)
def get_dates_widgets(options, index): monitoring_period_chooser = widgets.interactive(g, i=widgets.SelectionRangeSlider( options=options, index=index, description='Select the monitoring date range: ', style = {'description_width': 'initial'}, orientation='horizontal', layout={'width': '800px',"height":"50px"})) history_period_chooser = widgets.interactive(g, i=widgets.SelectionSlider( description="Start history period:", options = options, style = {'description_width': 'initial'})) return monitoring_period_chooser, history_period_chooser
def bar1(): names = list(uploaded.keys()) options = list() for name in names: options.append(tuple([name.split('.')[0], name])) interact(select_bar1, Name=widgets.Dropdown( options=options, value=names[0], description='Employe:', ), Date=widgets.DatePicker(), ti=widgets.SelectionSlider(options=['Hourly', 'Quarterly'], value='Hourly', description='X-axis Interval: ', disabled=False))
def _common_control_generator(self): def unwrap_slider_val(callback): return lambda slider_val: callback(slider_val['new']) def update_nco(rf_block, nco_freq): mixer_cfg = rf_block.MixerSettings mixer_cfg['Freq'] = nco_freq rf_block.MixerSettings = mixer_cfg rf_block.UpdateEvent(xrfdc.EVENT_MIXER) def new_nco_slider(title): return ipw.FloatSlider(value=1000, min=620, max=1220, step=20, description=title, disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='.1f', style={'description_width': 'initial'}) pow_slider = ipw.SelectionSlider( options=[0.1, 0.3, 0.6, 1], value=1, description='Transmit Power:', style={'description_width': 'initial'}) pow_slider.observe(unwrap_slider_val(self.qpsk_tx.set_gain), names='value') tx_nco_slider = new_nco_slider('TX Centre Frequency (MHz)') rx_nco_slider = new_nco_slider('RX Centre Frequency (MHz)') ipw.link((rx_nco_slider, 'value'), (tx_nco_slider, 'value')) tx_nco_slider.observe( unwrap_slider_val(lambda v: update_nco(self.dac_block, v)), names='value') rx_nco_slider.observe( unwrap_slider_val(lambda v: update_nco(self.adc_block, v)), names='value') control_widgets = ipw.Accordion( children=[ipw.VBox([pow_slider, tx_nco_slider, rx_nco_slider])]) control_widgets.set_title(0, 'System Control') return control_widgets
def _create_widgets(self): """Create menu and parameter widgets""" self.widget_out = ipywidgets.Output( layout={'border': '1px solid black'}) self._menu_widgets() widgets_params = {} for name, param in self.params.items(): init_val = param[(len(param) - 1) // 2] w = ipywidgets.SelectionSlider( options=param, value=init_val, description=f'{name}:', continuous_update=self.continuous_update, readout=True) w.observe(self._update_display, names='value') widgets_params[name] = w self.widgets_params = widgets_params