def direct(): tab_box = Tab(children=[direct_conn(), direct_settings()]) tab_box.set_title(0, 'Connection') tab_box.set_title(1, 'db Configuration') return tab_box
def _build_tabs(self, resources: dict, options_box: Box, instance_creation: Optional[Box] = None) -> Tab: """ Build tabs of widgets to display in Jupyter notebook :param resources: Dictionary description: html link from which the values are put into HTML and presented as description and link :param options_box: Box with method parameters/options (displayed under 'Method parameters' tab) :param instance_creation: Box with instance creation widget (displayed under 'Explained instance' tab) if provided. If None, no 'Explained instance' tab will be created. :return: Tabs to be displayed """ tabs = Tab() if instance_creation is not None: tabs.children = [ instance_creation, options_box, self._build_resources_widgets(resources) ] tabs.set_title(0, 'Explained instance') tabs.set_title(1, 'Method parameters') tabs.set_title(2, 'Resources') else: tabs.children = [ options_box, self._build_resources_widgets(resources) ] tabs.set_title(0, 'Method parameters') tabs.set_title(1, 'Resources') return tabs
class WWTJupyterViewer(WWTDataViewerBase, IPyWidgetView): _layer_style_widget_cls = { WWTImageLayerArtist: JupyterImageLayerOptions, WWTTableLayerArtist: JupyterTableLayerOptions, } def __init__(self, session, state=None): IPyWidgetView.__init__(self, session, state=state) WWTDataViewerBase.__init__(self) # In Glue+Jupyter Notebook, we need to explicitly specify this to get # the widget to fill up the horizontal space. self._wwt.layout.width = '100%' self._layout_viewer_options = JupterViewerOptions( self.state, self.state.imagery_layers) self._layout_tab = Tab( [self._layout_viewer_options, self._layout_layer_options]) self._layout_tab.set_title(0, "General") self._layout_tab.set_title(1, "Layers") self._layout = HBox([self.figure_widget, self._layout_tab]) def _initialize_wwt(self): self._wwt = WWTJupyterWidget() def redraw(self): self._update_wwt() @property def figure_widget(self): return self._wwt
class NanoTab(object): def __init__(self, xml_root): # uep = xml_root.find('.//nanoparticle') # find unique entry point into XML for (1st) nanoparticle self.type1 = NanoType1(xml_root) # for np in xml_root.iter('nanoparticle'): # hacky: iterate thru all (2) NPs to land on last/2nd # uep = np self.type2 = NanoType2(xml_root) self.xform = NanoTransform() tab_height = '500px' tab_layout = Layout( width='800px', # border='2px solid black', height=tab_height, overflow_y='scroll') # self.tab = Tab(children=[self.type1.tab, self.type2.tab, self.xform.tab]) # self.tab.set_title(0, 'Type 1') # self.tab.set_title(1, 'Type 2') # self.tab.set_title(2, 'Transformations') self.tab = Tab(children=[self.type1.tab]) self.tab.set_title(0, 'Type 1') def fill_gui(self, xml_root): # uep = xml_root.find('.//cell_definition') # find unique entry point into XML self.type1.fill_gui() # self.type2.fill_gui() # self.xform.fill_gui(xml_root) def fill_xml(self, xml_root): self.type1.fill_xml(xml_root)
def main(): tab_box = Tab(children=[data_source(), general()]) tab_box.set_title(0, 'DataSource') tab_box.set_title(1, 'General') return tab_box
def compose_panel(self, widgets_dict): # compose navigation_bar navigation_bar = self.navigation_bar.panel track_config = compose_track_config_panel(widgets_dict['track_config']) panel = Tab() panel.children = [navigation_bar, track_config] panel.set_title(0, "Navigation") panel.set_title(1, "Tracks") return panel
def get_final_plots(self, quad_funcs=[np.abs, np.angle]): from ipywidgets import Tab tab = Tab() plots = [] for i, p in enumerate(self.plotters): tab.set_title(i, p.filter_name) plots.append(p.get_final_plot(quad_funcs=quad_funcs)) tab.children = plots return tab
class JDAVizStandardLayout(VBox): def __init__(self, viewer): self.viewer = viewer self._layout_tab = Tab( [self.viewer.viewer_options, self.viewer.layer_options]) self._layout_tab.set_title(0, "General") self._layout_tab.set_title(1, "Layers") self._advanced_button = Button(description='Show advanced') self._advanced_button.on_click(self._toggle_basic_advanced) self._layout_toolbar = HBox([], layout={'justify_content': 'center'}) self._layout_top = HBox([], layout={'justify_content': 'center'}) self._layout_middle = HBox([], layout={'justify_content': 'center'}) self._layout_bottom = HBox([self._advanced_button], layout={'justify_content': 'center'}) # Default to basic mode self.advanced = False super().__init__([ self._layout_toolbar, self._layout_top, self._layout_middle, self._layout_bottom, self.viewer.output_widget ]) self._update_layout() def _toggle_basic_advanced(self, *args): # Switch between basic and advanced mode self.advanced = not self.advanced self._update_layout() def _update_layout(self, *args): # Show/hide widgets dependending on whether we are in basic or advanced mode if self.advanced: self._layout_middle.children = (self.viewer.figure_widget, self._layout_tab) self._layout_toolbar.children = ( self.viewer.toolbar_selection_tools, self.viewer.toolbar_active_subset, self.viewer.toolbar_selection_mode) self._advanced_button.description = 'Hide advanced' else: self._layout_middle.children = (self.viewer.figure_widget, ) self._layout_toolbar.children = ( self.viewer.toolbar_selection_tools, self.viewer.toolbar_active_subset) self._advanced_button.description = 'Show advanced'
def create_tab(do_display: bool = True) -> Tab: """Creates a `ipywidgets.Tab` which can display outputs in its tabs.""" tab = Tab(children=(Output(), )) tab.set_title(0, "Info") if do_display: display(tab) with tab.children[-1]: print("Plots and snapshots will show up here!") return tab
def direct(): # try: tab_box = Tab(children=[settings.direct_conn(), direct_settings()]) tab_box.set_title(0, 'Connection') tab_box.set_title(1, 'db Configuration') # except: # tab_box = Tab(children=[direct_conn()]) # tab_box.set_title(0, 'Connection') # print("!WARNING! Can not load direct configuration settings.") return tab_box
def create_tab(do_display: bool = True) -> Tab: """Creates a `ipywidgets.Tab` which can display outputs in its tabs.""" output = Output() tab = Tab(children=(output, )) tab.set_title(0, "Info") if do_display: display(tab) with output: # Prints it in the Output inside the tab. print("Plots and snapshots will show up here!") return tab
def plot_iteration(line: str): """call a registered plotter function for the given repetition and iteration""" args = parse_argstring(plot_iteration, line) items = [] from ipywidgets.widgets.interaction import show_inline_matplotlib_plots global __instances, __instantiated_experiments for exp_instance, exp_config in zip(__instances, __instantiated_experiments): out = Output() items.append(out) with out: # clear_output(wait=True) figures = __iteration_plot_functions[args.plotter_name](exp_instance, args.args) show_inline_matplotlib_plots() if args.save_figures: if args.format is None: args.format = plt.rcParams['savefig.format'] os.makedirs('plots/{}'.format(exp_config['name']), exist_ok=True) for i, f in enumerate(figures): filename = 'plots/{}/{}figure_{}.{}'.format(exp_config['name'], args.prefix, i, args.format) if args.format == 'tikz': try: from matplotlib2tikz import save as tikz_save with Output(): tikz_save(filename, figureheight='\\figureheight', figurewidth='\\figurewidth') except ModuleNotFoundError: warnings.warn('Saving figure as tikz requires the module matplotlib2tikz.') else: f.savefig(filename, format=args.format) if len(items) > 1: tabs = Tab(children=items) for i, exp in enumerate(__instantiated_experiments): if args.tab_title: if (args.tab_title[0] == args.tab_title[-1]) and args.tab_title.startswith(("'", '"')): selectors = args.tab_title[1:-1] else: selectors = args.tab_title selectors = selectors.split(' ') values = [reduce(lambda a, b: a[b], [exp['params'], *selector.split('.')]) for selector in selectors] tabs.set_title(i, ' '.join(map(str, values))) else: tabs.set_title(i, '...' + exp['name'][-15:]) display(tabs) elif len(items) == 1: return items[0] else: warnings.warn('No plots available for {} with args {}'.format(args.plotter_name, args.args))
def build_widget(self): widget = [] # dropdown for system selection # checkbox for showing/hiding unmodified data self.select = Dropdown(options=self.df_all.index.values,description='System:') # slider array for trimming datapoints vbox1 = [HBox([Label('Trim-Lo')],layout={'justify_content':'center'}) ] vbox2 = [HBox([Label('Trim-Hi')],layout={'justify_content':'center'}) ] self.apply_bg = Checkbox(value=False,description='Subtract BG?') vbox3 = [HBox([self.apply_bg],layout={'justify_content':'center'}) ] for config in self.df_all.columns: sl1 = IntSlider(min=0,max=25,value=7,description='{}'.format(config)) sl1.style.handle_color = self.df_colors.loc[config] vbox1.append(sl1) sl2 = IntSlider(min=0,max=100,value=15,description='{}'.format(config)) sl2.style.handle_color = self.df_colors.loc[config] vbox2.append(sl2) # sl3 = FloatSlider(min=0.001,max=1,value=0.5,description='{}'.format(config)) sl3 = FloatLogSlider(min=-3,max=0,value=0.5,description='{}'.format(config)) sl3.style.handle_color = self.df_colors.loc[config] vbox3.append(sl3) widget.append(HBox([VBox(vbox1), VBox(vbox2)])) ## store slider objects in dataframe self.df_slider = pd.DataFrame(np.transpose([vbox1[1:],vbox2[1:],vbox3[1:]]),index=self.df_all.columns,columns=['Lo','Hi','bgLoc']) # self.df_bgslider = pd.DataFrame(np.transpose(vbox3[1:]),index=self.df_all.columns,columns=['Lo','Hi']) # dropdown for shift-configuration selection ops = ['None'] ops += [str(i) for i in self.df_all.columns.values] self.shift_config = Dropdown(options=ops,description='Shift-To:') self.shift_factors_out = Output() self.show_original = Checkbox(value=True,description='Show Original Data') vbox4 = [VBox([self.shift_config,self.show_original]),self.shift_factors_out] # widget.append(HBox([VBox(vbox3),VBox(vbox4)])) self.bg_out = Output() widget.append(HBox([VBox(vbox3),self.bg_out])) widget.append(HBox(vbox4)) tabs = Tab(widget) tabs.set_title(0,'Data Trimming') tabs.set_title(1,'Subtract BG') tabs.set_title(2,'Curve Shift') self.debug_out = Output() return VBox([self.select,tabs,self.debug_out])
def _make_delay_tab(box_factory, selected_index=0): """ Parameters ---------- box_factory : list of (func, tab_name) Example of box_factory: [(_make_gen_box, 'General'), (_make_repr_box, 'Representation')] """ tab = Tab([Box() for box, _ in box_factory]) [tab.set_title(i, title) for i, (_, title) in enumerate(box_factory)] # trick if not tab.children[selected_index].children: tab.selected_index = -1 def on_update_selected_index(change): index = change['new'] if not tab.children[index].children: # make widget on demand tab.children[index].children = [box_factory[index][0](),] tab.observe(on_update_selected_index, names='selected_index') # trigger tab.selected_index = selected_index return tab
def _make_delay_tab(box_factory, selected_index=0): """ Parameters ---------- box_factory : list of (func, tab_name) Example of box_factory: [(_make_gen_box, 'General'), (_make_repr_box, 'Representation')] """ tab = Tab([Box() for box, _ in box_factory]) [tab.set_title(i, title) for i, (_, title) in enumerate(box_factory)] # trick if not tab.children[selected_index].children: tab.selected_index = 1 def on_update_selected_index(change): index = change['new'] if not tab.children[index].children: # make widget on demand tab.children[index].children = [ box_factory[index][0](), ] tab.observe(on_update_selected_index, names='selected_index') # trigger tab.selected_index = selected_index return tab
class MatplotlibJupyterViewer(MatplotlibViewerMixin, IPyWidgetView): _state_cls = MatplotlibDataViewerState large_data_size = None def __init__(self, session, parent=None, wcs=None, state=None): self.figure = Figure() self.canvas = FigureCanvasNbAgg(self.figure) self.canvas.manager = FigureManagerNbAgg(self.canvas, 0) self.figure, self.axes = init_mpl(self.figure, wcs=wcs) # FIXME: The following is required for now for the tools to work self.central_widget = self.figure self._axes = self.axes super(MatplotlibJupyterViewer, self).__init__(session, state=state) MatplotlibViewerMixin.setup_callbacks(self) self.create_tab() self.output_widget = Output() self.css_widget = HTML(REMOVE_TITLE_CSS) self.main_widget = VBox([ self.css_widget, self.widget_toolbar, HBox([self.canvas, self.tab]), self.output_widget ]) def show(self): display(self.main_widget) def get_layer_artist(self, cls, layer=None, layer_state=None): # TODO: this method should be defined on the base viewer class layer = super().get_layer_artist(cls, layer=layer, layer_state=layer_state) self._add_layer_tab(layer) return layer def create_tab(self): self.tab = Tab([self._options_cls(self.state)]) self.tab.set_title(0, "General")
def data_column_dropdown_multiple_tabs(data, t=['x', 'y', 'y2', 'z']): """ Helper function for putting together multiple data column dropdowns in tab format """ from ipywidgets import Tab if t is None: t = ['x', 'y', 'y2', 'z'] tab_contents = t children = [data_column_dropdown(data) for name in tab_contents] tab = Tab() tab.children = children tab_dict = {} for i, var in enumerate(tab_contents): tab.set_title(i, var) tab_dict[var] = tab.children[i] return tab_dict, tab
def get_widget_box(): try: tab_box = Tab(children=[get_panel.get(), help_docs.widget_box(), settings.main()]) tab_box.set_title(0, 'Get Data') tab_box.set_title(1, 'Help') tab_box.set_title(2, 'Settings') except Exception as err: tab_box = Tab(children=[help_docs.widget_box(), settings.main()]) tab_box.set_title(0, 'Help') tab_box.set_title(1, 'Settings') print("Could not show 'Get panel'.", err) return tab_box
def view_widget_box(): try: tab_box = Tab(children=[ view_panel.view(), help_docs.widget_box(), settings.main() ]) tab_box.set_title(0, 'View single parcel') tab_box.set_title(1, 'Help') tab_box.set_title(2, 'Settings') except Exception as err: tab_box = Tab(children=[help_docs.widget_box(), settings.main()]) tab_box.set_title(1, 'Help') tab_box.set_title(2, 'Settings') print("Could not show 'View panel'.", err) return tab_box
def ipywidgets_layout_factory(viewer): # Take all the different widgets and construct a standard layout # for the viewers, based on ipywidgets HBox and VBox. This can be # overriden in sub-classes to create alternate layouts. layout_toolbar = HBox([ viewer.toolbar_selection_tools, viewer.toolbar_active_subset, viewer.toolbar_selection_mode ]) layout_tab = Tab([viewer.viewer_options, viewer.layer_options]) layout_tab.set_title(0, "General") layout_tab.set_title(1, "Layers") layout = VBox([ layout_toolbar, HBox([viewer.figure_widget, layout_tab]), viewer.output_widget ]) return layout
def display_html(vals): ''' Convert objects into three AXON forms for output in IPython notebook. :param vals: List of objects or ordered dict. :returns: IPython TabbedView widget. ''' try: from ipywidgets import Tab, HTML except: from IPython.html.widgets import Tab, HTML # Compact form p1 = dumps(vals, crossref=1) # Formatted form without braces p2 = dumps(vals, pretty=1, crossref=1) # Formatted form with braces p3 = dumps(vals, pretty=1, braces=1, crossref=1) wg = Tab( ( HTML("<pre>%s</pre>" % p1), HTML("<pre>%s</pre>" % p2), HTML("<pre>%s</pre>" % p3)) ) wg.set_title(0, "Compact") wg.set_title(1, "Formatted") wg.set_title(2, "Formatted with {}") wg.selected_index = 1 return wg
def provide_files(line: str): args = parse_argstring(provide_files, line) items = [] ipy = get_ipython() url_prefix = os.path.relpath(os.getcwd(), ipy.starting_dir) + os.path.sep print(url_prefix) global __file_provider_functions global __instances, __instantiated_experiments for exp_instance, exp_config in zip(__instances, __instantiated_experiments): dfs = __file_provider_functions[args.file_provider](exp_instance, exp_config, args.args) if isinstance(dfs, DownloadFile): items.append(Output()) with items[-1]: display(DownloadFileLink(dfs.path, file_name=dfs.file_name, link_text=dfs.link_text, url_prefix=url_prefix)) else: items.append(VBox([DownloadFileLink(df.path, file_name=df.file_name, link_text=df.link_text, url_prefix=url_prefix) for df in dfs])) if len(items) > 1: tabs = Tab(children=items) for i, exp in enumerate(__instantiated_experiments): if args.tab_title: if (args.tab_title[0] == args.tab_title[-1]) and args.tab_title.startswith(("'", '"')): selectors = args.tab_title[1:-1] else: selectors = args.tab_title selectors = selectors.split(' ') values = [reduce(lambda a, b: a[b], [exp['params'], *selector.split('.')]) for selector in selectors] tabs.set_title(i, ' '.join(map(str, values))) else: tabs.set_title(i, '...' + exp['name'][-15:]) display(tabs) elif len(items) == 1: return items[0] else: warnings.warn('No files loaded')
def foi_widget_box(): tab_box = Tab(children=[foi_panel.foi(), foi_panel.foi_v2(), foi_help.widget_box_foi(), foi_settings.widget_box()]) tab_box.set_title(0, 'FOI Assessment V1') tab_box.set_title(1, 'FOI Assessment V2') tab_box.set_title(2, 'Help') tab_box.set_title(3, 'Settings') return tab_box
def qa_widget_box(): tab_box = Tab( children=[qa_panel.qa(), help_docs.widget_box(), settings.main()]) tab_box.set_title(0, 'Quality assessment') tab_box.set_title(1, 'Help') tab_box.set_title(2, 'Settings') return tab_box
def ext_widget_box(): tab_box = Tab(children=[ ext_panel.extract(), help_docs.widget_box(), settings.main() ]) tab_box.set_title(0, 'Extract Data') tab_box.set_title(1, 'Help') tab_box.set_title(2, 'Settings') return tab_box
def proc_widget_box(): tab_box = Tab(children=[ proc_panel.proc(), help_docs.widget_box(), proc_settings.widget_box() ]) tab_box.set_title(0, 'Process Data') tab_box.set_title(1, 'Help') tab_box.set_title(2, 'Settings') return tab_box
def cbm_widget_box(): tab_box = Tab(children=[ cbm_panel.cbm(), help_docs.widget_box(), cbm_settings.widget_box() ]) tab_box.set_title(0, 'Checks by Monitoring') tab_box.set_title(1, 'Help') tab_box.set_title(2, 'Settings') return tab_box
def gen_figure(msids, group_name): def select_next_msid(junk): current_msid = msid_select.value options = msid_select.options i = options.index(current_msid) if i < len(options) - 1: msid_select.value=options[i + 1] dummyfig = plt.figure(facecolor=[1,1,1],figsize=(14,8)) msid_select = Select(description='MSID:',options=msids, visible=True, padding=4) button_next_msid = Button(description='Next', padding=4) button_next_msid.on_click(select_next_msid) msid_select_group = HBox(children=[msid_select, button_next_msid]) latest = DateTime().date t1 = Text(description='Start Date:', value='2000:001:00:00:00.000', visible=True, padding=4) t2 = Text(description='Stop Date:', value=latest, visible=True, padding=4) time_select = Box(children=[t1, t2]) page1 = HBox(children=[msid_select_group, time_select]) wL = Checkbox(description='Plot Warning Low', value=False, visible=True, padding=4) cL = Checkbox(description='Plot Caution Low', value=False, visible=True, padding=4) cH = Checkbox(description='Plot Caution High', value=True, visible=True, padding=4) wH = Checkbox(description='Plot Warning High', value=True, visible=True, padding=4) low_select = Box(children=[wL, cL]) high_select = Box(children=[wH, cH]) page2 = HBox(children=[high_select, low_select]) stat_select = Select(description='Stat:',options=('daily', '5min', 'None'), visible=True, padding=4) filter_bads = Checkbox(description='Filter Bad Times:', value=True, visible=True, padding=4) group_select = Select(description='Group Name:',options=['sc', 'tel', 'isim'], visible=True, value=group_name, padding=4) left_select = Box(children=[stat_select, filter_bads]) page3 = HBox(children=[left_select, group_select], description='Misc.') q = interactive(plot_msid_interactive, msid=msid_select, group=group_select, tstart=t1, tstop=t2, stat=stat_select, plot_warning_low=wL, plot_caution_low=cL, plot_caution_high=cH, plot_warning_high=wH, remove_bads=filter_bads) tabs = Tab(children=[page1, page2, page3]) tabs.set_title(0, 'MSID, Dates') tabs.set_title(1, 'Limits') tabs.set_title(2, 'Misc.') display(tabs)
class TrajectoryPlayer(HasTraits): # should set default values here different from desired defaults # so `observe` can be triggered step = Int(0) sync_frame = Bool(True) interpolate = Bool(False) delay = Float(0.0) parameters = Dict() iparams = Dict() _interpolation_t = Float() _iterpolation_type = CaselessStrEnum(['linear', 'spline']) spin = Bool(False) _spin_x = Int(1) _spin_y = Int(0) _spin_z = Int(0) _spin_speed = Float(0.005) camera = CaselessStrEnum( ['perspective', 'orthographic'], default_value='perspective') _render_params = Dict() _real_time_update = Bool(False) widget_tab = Any(None) widget_repr = Any(None) widget_repr_parameters = Any(None) widget_quick_repr = Any(None) widget_general = Any(None) widget_picked = Any(None) widget_preference = Any(None) widget_extra = Any(None) widget_theme = Any(None) widget_help = Any(None) widget_export_image = Any(None) widget_component_slider = Any(None) widget_repr_slider = Any(None) widget_repr_choices = Any(None) widget_repr_control_buttons = Any(None) widget_repr_add = Any(None) widget_accordion_repr_parameters = Any(None) widget_repr_parameters_dialog = Any(None) widget_repr_name = Any(None) widget_component_dropdown = Any(None) widget_drag = Any(None) def __init__(self, view, step=1, delay=100, sync_frame=False, min_delay=40): self._view = view self.step = step self.sync_frame = sync_frame self.delay = delay self.min_delay = min_delay self._interpolation_t = 0.5 self._iterpolation_type = 'linear' self.iparams = dict( t=self._interpolation_t, step=1, type=self._iterpolation_type) self._render_params = dict( factor=4, antialias=True, trim=False, transparent=False) self._widget_names = [w for w in dir(self) if w.startswith('wiget_')] def _update_padding(self, padding=default.DEFAULT_PADDING): widget_collection = [ self.widget_general, self.widget_repr, self.widget_preference, self.widget_repr_parameters, self.widget_help, self.widget_extra, self.widget_picked ] for widget in widget_collection: if widget is not None: widget.layout.padding = padding def _create_all_widgets(self): if self.widget_tab is None: self.widget_tab = self._display() old_index = self.widget_tab.selected_index for index, _ in enumerate(self.widget_tab.children): self.widget_tab.selected_index = index self.widget_tab.selected_index = old_index def smooth(self): self.interpolate = True @observe('camera') def on_camera_changed(self, change): camera_type = change['new'] self._view._remote_call( "setParameters", target='Stage', kwargs=dict(cameraType=camera_type)) @property def frame(self): return self._view.frame @frame.setter def frame(self, value): self._view.frame = value @property def count(self): return self._view.count @observe('sync_frame') def update_sync_frame(self, change): value = change['new'] if value: self._view._set_sync_frame() else: self._view._set_unsync_frame() @observe("delay") def update_delay(self, change): delay = change['new'] self._view._set_delay(delay) @observe('parameters') def update_parameters(self, change): params = change['new'] self.sync_frame = params.get("sync_frame", self.sync_frame) self.delay = params.get("delay", self.delay) self.step = params.get("step", self.step) @observe('_interpolation_t') def _interpolation_t_changed(self, change): self.iparams['t'] = change['new'] @observe('spin') def on_spin_changed(self, change): self.spin = change['new'] if self.spin: self._view._set_spin([self._spin_x, self._spin_y, self._spin_z], self._spin_speed) else: # stop self._view._set_spin(None, None) @observe('_spin_x') def on_spin_x_changed(self, change): self._spin_x = change['new'] if self.spin: self._view._set_spin([self._spin_x, self._spin_y, self._spin_z], self._spin_speed) @observe('_spin_y') def on_spin_y_changed(self, change): self._spin_y = change['new'] if self.spin: self._view._set_spin([self._spin_x, self._spin_y, self._spin_z], self._spin_speed) @observe('_spin_z') def on_spin_z_changed(self, change): self._spin_z = change['new'] if self.spin: self._view._set_spin([self._spin_x, self._spin_y, self._spin_z], self._spin_speed) @observe('_spin_speed') def on_spin_speed_changed(self, change): self._spin_speed = change['new'] if self.spin: self._view._set_spin([self._spin_x, self._spin_y, self._spin_z], self._spin_speed) def _display(self): box_factory = [(self._make_general_box, 'General'), (self._make_widget_repr, 'Representation'), (self._make_widget_preference, 'Preference'), (self._make_theme_box, 'Theme'), (self._make_extra_box, 'Extra'), (self._show_website, 'Help')] tab = _make_delay_tab(box_factory, selected_index=0) # tab = _make_autofit(tab) tab.layout.align_self = 'center' tab.layout.align_items = 'stretch' self.widget_tab = tab return self.widget_tab def _make_widget_tab(self): return self._display() def _make_button_center(self): button = Button(description=' Center', icon='fa-bullseye') @button.on_click def on_click(button): self._view.center() return button def _make_button_theme(self): button = Button(description='Oceans16') @button.on_click def on_click(button): from nglview import theme display(theme.oceans16()) self._view._remote_call('cleanOutput', target='Widget') return button def _make_button_reset_theme(self, hide_toolbar=False): from nglview import theme if hide_toolbar: button = Button(description='Simplified Default') @button.on_click def on_click(button): theme.reset(hide_toolbar=True) else: button = Button(description='Default') @button.on_click def on_click(button): theme.reset() return button def _make_button_clean_error_output(self): button = Button(description='Clear Error') @button.on_click def on_click(_): js_utils.clean_error_output() return button def _make_widget_preference(self, width='100%'): def make_func(): parameters = self._view._full_stage_parameters def func(pan_speed=parameters.get('panSpeed', 0.8), rotate_speed=parameters.get('rotateSpeed', 2), zoom_speed=parameters.get('zoomSpeed', 1.2), clip_dist=parameters.get('clipDist', 10), camera_fov=parameters.get('cameraFov', 40), clip_far=parameters.get('clipFar', 100), clip_near=parameters.get('clipNear', 0), fog_far=parameters.get('fogFar', 100), fog_near=parameters.get('fogNear', 50), impostor=parameters.get('impostor', True), light_intensity=parameters.get('lightIntensity', 1), quality=parameters.get('quality', 'medium'), sample_level=parameters.get('sampleLevel', 1)): self._view.parameters = dict( panSpeed=pan_speed, rotateSpeed=rotate_speed, zoomSpeed=zoom_speed, clipDist=clip_dist, clipFar=clip_far, clipNear=clip_near, cameraFov=camera_fov, fogFar=fog_far, fogNear=fog_near, impostor=impostor, lightIntensity=light_intensity, quality=quality, sampleLevel=sample_level) return func def make_widget_box(): widget_sliders = interactive( make_func(), pan_speed=(0, 10, 0.1), rotate_speed=(0, 10, 1), zoom_speed=(0, 10, 1), clip_dist=(0, 200, 5), clip_far=(0, 100, 1), clip_near=(0, 100, 1), camera_fov=(15, 120, 1), fog_far=(0, 100, 1), fog_near=(0, 100, 1), light_intensity=(0, 10, 0.02), quality=['low', 'medium', 'high'], sample_level=(-1, 5, 1)) for child in widget_sliders.children: if isinstance(child, (IntSlider, FloatSlider)): child.layout.width = default.DEFAULT_SLIDER_WIDTH return widget_sliders if self.widget_preference is None: widget_sliders = make_widget_box() reset_button = Button(description='Reset') widget_sliders.children = [ reset_button, ] + list(widget_sliders.children) @reset_button.on_click def on_click(reset_button): self._view.parameters = self._view._original_stage_parameters self._view._full_stage_parameters = self._view._original_stage_parameters widget_sliders.children = [ reset_button, ] + list(make_widget_box().children) self.widget_preference = _relayout_master( widget_sliders, width=width) return self.widget_preference def _show_download_image(self): # "interactive" does not work for True/False in ipywidgets 4 yet. button = Button(description=' Screenshot', icon='fa-camera') @button.on_click def on_click(button): self._view.download_image() return button def _make_button_url(self, url, description): button = Button(description=description) @button.on_click def on_click(button): display(Javascript(js_utils.open_url_template.format(url=url))) return button def _show_website(self, ngl_base_url=default.NGL_BASE_URL): buttons = [ self._make_button_url(url.format(ngl_base_url), description) for url, description in [("'http://arose.github.io/nglview/latest/'", "nglview" ), ("'{}/index.html'", "NGL" ), ("'{}/tutorial-selection-language.html'", "Selection"), ("'{}/tutorial-molecular-representations.html'", "Representation" )] ] self.widget_help = _make_autofit(HBox(buttons)) return self.widget_help def _make_button_qtconsole(self): from nglview import js_utils button = Button(description='qtconsole', tooltip='pop up qtconsole') @button.on_click def on_click(button): js_utils.launch_qtconsole() return button def _make_text_picked(self): ta = Textarea( value=json.dumps(self._view.picked), description='Picked atom') ta.layout.width = '300px' return ta def _refresh(self, component_slider, repr_slider): """update representation and component information """ self._view._request_repr_parameters( component=component_slider.value, repr_index=repr_slider.value) self._view._remote_call('requestReprInfo', target='Widget') self._view._handle_repr_dict_changed(change=dict( new=self._view._repr_dict)) def _make_button_repr_control(self, component_slider, repr_slider, repr_selection): button_refresh = Button( description=' Refresh', tooltip='Get representation info', icon='fa-refresh') button_center_selection = Button( description=' Center', tooltip='center selected atoms', icon='fa-bullseye') button_center_selection._ngl_name = 'button_center_selection' button_hide = Button( description=' Hide', icon='fa-eye-slash', tooltip='Hide/Show current representation') button_remove = Button( description=' Remove', icon='fa-trash', tooltip='Remove current representation') button_repr_parameter_dialog = Button( description=' Dialog', tooltip='Pop up representation parameters control dialog') @button_refresh.on_click def on_click_refresh(button): self._refresh(component_slider, repr_slider) @button_center_selection.on_click def on_click_center(center_selection): self._view.center_view( selection=repr_selection.value, component=component_slider.value) @button_hide.on_click def on_click_hide(button_hide): component = component_slider.value repr_index = repr_slider.value if button_hide.description == 'Hide': hide = True button_hide.description = 'Show' else: hide = False button_hide.description = 'Hide' self._view._remote_call( 'setVisibilityForRepr', target='Widget', args=[component, repr_index, not hide]) @button_remove.on_click def on_click_remove(button_remove): self._view._remove_representation( component=component_slider.value, repr_index=repr_slider.value) self._view._request_repr_parameters( component=component_slider.value, repr_index=repr_slider.value) @button_repr_parameter_dialog.on_click def on_click_repr_dialog(_): from nglview.widget_box import DraggableBox if self.widget_repr_parameters is not None and self.widget_repr_choices: self.widget_repr_parameters_dialog = DraggableBox( [self.widget_repr_choices, self.widget_repr_parameters]) self.widget_repr_parameters_dialog._ipython_display_() self.widget_repr_parameters_dialog._dialog = 'on' bbox = _make_autofit( HBox([ button_refresh, button_center_selection, button_hide, button_remove, button_repr_parameter_dialog ])) return bbox def _make_widget_repr(self): self.widget_repr_name = Text(value='', description='representation') self.widget_repr_name._ngl_name = 'repr_name_text' repr_selection = Text(value=' ', description='selection') repr_selection._ngl_name = 'repr_selection' repr_selection.width = self.widget_repr_name.width = default.DEFAULT_TEXT_WIDTH max_n_components = max(self._view.n_components - 1, 0) self.widget_component_slider = IntSlider( value=0, max=max_n_components, min=0, description='component') self.widget_component_slider._ngl_name = 'component_slider' cvalue = ' ' self.widget_component_dropdown = Dropdown( value=cvalue, options=[ cvalue, ], description='component') self.widget_component_dropdown._ngl_name = 'component_dropdown' self.widget_repr_slider = IntSlider( value=0, description='representation', width=default.DEFAULT_SLIDER_WIDTH) self.widget_repr_slider._ngl_name = 'repr_slider' self.widget_repr_slider.visible = True self.widget_component_slider.layout.width = default.DEFAULT_SLIDER_WIDTH self.widget_repr_slider.layout.width = default.DEFAULT_SLIDER_WIDTH self.widget_component_dropdown.layout.width = self.widget_component_dropdown.max_width = default.DEFAULT_TEXT_WIDTH # turn off for now self.widget_component_dropdown.layout.display = 'none' self.widget_component_dropdown.description = '' # self.widget_accordion_repr_parameters = Accordion() self.widget_accordion_repr_parameters = Tab() self.widget_repr_parameters = self._make_widget_repr_parameters( self.widget_component_slider, self.widget_repr_slider, self.widget_repr_name) self.widget_accordion_repr_parameters.children = [ self.widget_repr_parameters, Box() ] self.widget_accordion_repr_parameters.set_title(0, 'Parameters') self.widget_accordion_repr_parameters.set_title(1, 'Hide') self.widget_accordion_repr_parameters.selected_index = 1 checkbox_reprlist = Checkbox(value=False, description='reprlist') checkbox_reprlist._ngl_name = 'checkbox_reprlist' self.widget_repr_choices = self._make_repr_name_choices( self.widget_component_slider, self.widget_repr_slider) self.widget_repr_choices._ngl_name = 'reprlist_choices' self.widget_repr_add = self._make_add_widget_repr( self.widget_component_slider) def on_update_checkbox_reprlist(change): self.widget_repr_choices.visible = change['new'] checkbox_reprlist.observe(on_update_checkbox_reprlist, names='value') def on_repr_name_text_value_changed(change): name = change['new'].strip() old = change['old'].strip() should_update = (self._real_time_update and old and name and name in REPRESENTATION_NAMES and name != change['old'].strip()) if should_update: component = self.widget_component_slider.value repr_index = self.widget_repr_slider.value self._view._remote_call( 'setRepresentation', target='Widget', args=[change['new'], {}, component, repr_index]) self._view._request_repr_parameters(component, repr_index) def on_component_or_repr_slider_value_changed(change): self._view._request_repr_parameters( component=self.widget_component_slider.value, repr_index=self.widget_repr_slider.value) self.widget_component_dropdown.options = tuple( self._view._ngl_component_names) if self.widget_accordion_repr_parameters.selected_index >= 0: self.widget_repr_parameters.name = self.widget_repr_name.value self.widget_repr_parameters.repr_index = self.widget_repr_slider.value self.widget_repr_parameters.component_index = self.widget_component_slider.value def on_repr_selection_value_changed(change): if self._real_time_update: component = self.widget_component_slider.value repr_index = self.widget_repr_slider.value self._view._set_selection( change['new'], component=component, repr_index=repr_index) def on_change_component_dropdown(change): choice = change['new'] if choice and choice.strip(): # bool(" ") is True self.widget_component_slider.value = self._view._ngl_component_names.index( choice) self.widget_component_dropdown.observe( on_change_component_dropdown, names='value') self.widget_repr_slider.observe( on_component_or_repr_slider_value_changed, names='value') self.widget_component_slider.observe( on_component_or_repr_slider_value_changed, names='value') self.widget_repr_name.observe( on_repr_name_text_value_changed, names='value') repr_selection.observe(on_repr_selection_value_changed, names='value') self.widget_repr_control_buttons = self._make_button_repr_control( self.widget_component_slider, self.widget_repr_slider, repr_selection) blank_box = Box([Label("")]) all_kids = [ self.widget_repr_control_buttons, blank_box, self.widget_repr_add, self.widget_component_dropdown, self.widget_repr_name, repr_selection, self.widget_component_slider, self.widget_repr_slider, self.widget_repr_choices, self.widget_accordion_repr_parameters ] vbox = VBox(all_kids) self._view._request_repr_parameters( component=self.widget_component_slider.value, repr_index=self.widget_repr_slider.value) self.widget_repr = _relayout_master(vbox, width='100%') self._refresh(self.widget_component_slider, self.widget_repr_slider) setattr(self.widget_repr, "_saved_widgets", []) for _box in self.widget_repr.children: if hasattr(_box, 'children'): for kid in _box.children: self.widget_repr._saved_widgets.append(kid) return self.widget_repr def _make_widget_repr_parameters(self, component_slider, repr_slider, repr_name_text=None): name = repr_name_text.value if repr_name_text is not None else ' ' widget = self._view._display_repr( component=component_slider.value, repr_index=repr_slider.value, name=name) widget._ngl_name = 'repr_parameters_box' return widget def _make_button_export_image(self): slider_factor = IntSlider(value=4, min=1, max=10, description='scale') checkbox_antialias = Checkbox(value=True, description='antialias') checkbox_trim = Checkbox(value=False, description='trim') checkbox_transparent = Checkbox(value=False, description='transparent') filename_text = Text(value='Screenshot', description='Filename') delay_text = FloatText( value=1, description='delay (s)', tooltip='hello') start_text, stop_text, step_text = ( IntText(value=0, description='start'), IntText(value=self._view.count, description='stop'), IntText(value=1, description='step')) start_text.layout.max_width = stop_text.layout.max_width = step_text.layout.max_width \ = filename_text.layout.max_width = delay_text.layout.max_width = default.DEFAULT_TEXT_WIDTH button_movie_images = Button(description='Export Images') def download_image(filename): self._view.download_image( factor=slider_factor.value, antialias=checkbox_antialias.value, trim=checkbox_trim.value, transparent=checkbox_transparent.value, filename=filename) @button_movie_images.on_click def on_click_images(button_movie_images): for i in range(start_text.value, stop_text.value, step_text.value): self._view.frame = i time.sleep(delay_text.value) download_image(filename=filename_text.value + str(i)) time.sleep(delay_text.value) vbox = VBox([ button_movie_images, start_text, stop_text, step_text, delay_text, filename_text, slider_factor, checkbox_antialias, checkbox_trim, checkbox_transparent, ]) form_items = _relayout(vbox, make_form_item_layout()) form = Box(form_items, layout=_make_box_layout()) # form = _relayout_master(vbox) return form def _make_resize_notebook_slider(self): resize_notebook_slider = IntSlider( min=300, max=2000, description='resize notebook') def on_resize_notebook(change): width = change['new'] self._view._remote_call( 'resizeNotebook', target='Widget', args=[ width, ]) resize_notebook_slider.observe(on_resize_notebook, names='value') return resize_notebook_slider def _make_add_widget_repr(self, component_slider): dropdown_repr_name = Dropdown( options=REPRESENTATION_NAMES, value='cartoon') repr_selection = Text(value='*', description='') repr_button = Button( description='Add', tooltip="""Add representation. You can also hit Enter in selection box""") repr_button.layout = Layout(width='auto', flex='1 1 auto') dropdown_repr_name.layout.width = repr_selection.layout.width = default.DEFAULT_TEXT_WIDTH def on_click_or_submit(button_or_text_area): self._view.add_representation( selection=repr_selection.value.strip(), repr_type=dropdown_repr_name.value, component=component_slider.value) repr_button.on_click(on_click_or_submit) repr_selection.on_submit(on_click_or_submit) add_repr_box = HBox([repr_button, dropdown_repr_name, repr_selection]) add_repr_box._ngl_name = 'add_repr_box' return add_repr_box def _make_repr_playground(self): vbox = VBox() children = [] rep_names = REPRESENTATION_NAMES[:] excluded_names = ['ball+stick', 'distance'] for name in excluded_names: rep_names.remove(name) repr_selection = Text(value='*') repr_selection.layout.width = default.DEFAULT_TEXT_WIDTH repr_selection_box = HBox([Label('selection'), repr_selection]) setattr(repr_selection_box, 'value', repr_selection.value) for index, name in enumerate(rep_names): button = ToggleButton(description=name) def make_func(): def on_toggle_button_value_change(change, button=button): selection = repr_selection.value new = change['new'] # True/False if new: self._view.add_representation( button.description, selection=selection) else: self._view._remove_representations_by_name( button.description) return on_toggle_button_value_change button.observe(make_func(), names='value') children.append(button) button_clear = Button( description='clear', button_style='info', icon='fa-eraser') @button_clear.on_click def on_clear(button_clear): self._view.clear() for kid in children: # unselect kid.value = False vbox.children = children + [repr_selection, button_clear] _make_autofit(vbox) self.widget_quick_repr = vbox return self.widget_quick_repr def _make_repr_name_choices(self, component_slider, repr_slider): repr_choices = Dropdown(options=[ " ", ]) def on_chosen(change): repr_name = change.get('new', " ") try: repr_index = repr_choices.options.index(repr_name) repr_slider.value = repr_index except ValueError: pass repr_choices.observe(on_chosen, names='value') repr_choices.layout.width = default.DEFAULT_TEXT_WIDTH self.widget_repr_choices = repr_choices return self.widget_repr_choices def _make_drag_widget(self): button_drag = Button( description='widget drag: off', tooltip='dangerous') drag_nb = Button(description='notebook drag: off', tooltip='dangerous') button_reset_notebook = Button( description='notebook: reset', tooltip='reset?') button_dialog = Button(description='dialog', tooltip='make a dialog') button_split_half = Button( description='split screen', tooltip='try best to make a good layout') @button_drag.on_click def on_drag(button_drag): if button_drag.description == 'widget drag: off': self._view._set_draggable(True) button_drag.description = 'widget drag: on' else: self._view._set_draggable(False) button_drag.description = 'widget drag: off' @drag_nb.on_click def on_drag_nb(button_drag): if drag_nb.description == 'notebook drag: off': js_utils._set_notebook_draggable(True) drag_nb.description = 'notebook drag: on' else: js_utils._set_notebook_draggable(False) drag_nb.description = 'notebook drag: off' @button_reset_notebook.on_click def on_reset(button_reset_notebook): js_utils._reset_notebook() @button_dialog.on_click def on_dialog(button_dialog): self._view._remote_call('setDialog', target='Widget') @button_split_half.on_click def on_split_half(button_dialog): from nglview import js_utils import time js_utils._move_notebook_to_the_left() js_utils._set_notebook_width('5%') time.sleep(0.1) self._view._remote_call('setDialog', target='Widget') drag_box = HBox([ button_drag, drag_nb, button_reset_notebook, button_dialog, button_split_half ]) drag_box = _make_autofit(drag_box) self.widget_drag = drag_box return drag_box def _make_spin_box(self): checkbox_spin = Checkbox(self.spin, description='spin') spin_x_slide = IntSlider( self._spin_x, min=-1, max=1, description='spin_x') spin_y_slide = IntSlider( self._spin_y, min=-1, max=1, description='spin_y') spin_z_slide = IntSlider( self._spin_z, min=-1, max=1, description='spin_z') spin_speed_slide = FloatSlider( self._spin_speed, min=0, max=0.2, step=0.001, description='spin speed') # spin link((checkbox_spin, 'value'), (self, 'spin')) link((spin_x_slide, 'value'), (self, '_spin_x')) link((spin_y_slide, 'value'), (self, '_spin_y')) link((spin_z_slide, 'value'), (self, '_spin_z')) link((spin_speed_slide, 'value'), (self, '_spin_speed')) spin_box = VBox([ checkbox_spin, spin_x_slide, spin_y_slide, spin_z_slide, spin_speed_slide ]) spin_box = _relayout_master(spin_box, width='75%') return spin_box def _make_widget_picked(self): self.widget_picked = self._make_text_picked() picked_box = HBox([ self.widget_picked, ]) return _relayout_master(picked_box, width='75%') def _make_export_image_widget(self): if self.widget_export_image is None: self.widget_export_image = HBox([self._make_button_export_image()]) return self.widget_export_image def _make_extra_box(self): if self.widget_extra is None: extra_list = [(self._make_drag_widget, 'Drag'), (self._make_spin_box, 'Spin'), (self._make_widget_picked, 'Picked'), (self._make_repr_playground, 'Quick'), (self._make_export_image_widget, 'Image'), (self._make_command_box, 'Command')] extra_box = _make_delay_tab(extra_list, selected_index=0) self.widget_extra = extra_box return self.widget_extra def _make_theme_box(self): if self.widget_theme is None: self.widget_theme = Box([ self._make_button_theme(), self._make_button_reset_theme(hide_toolbar=False), self._make_button_reset_theme(hide_toolbar=True), self._make_button_clean_error_output() ]) return self.widget_theme def _make_general_box(self): if self.widget_general is None: step_slide = IntSlider( value=self.step, min=-100, max=100, description='step') delay_text = IntSlider( value=self.delay, min=10, max=1000, description='delay') toggle_button_interpolate = ToggleButton( self.interpolate, description='Smoothing', tooltip='smoothing trajectory') link((toggle_button_interpolate, 'value'), (self, 'interpolate')) background_color_picker = ColorPicker( value='white', description='background') camera_type = Dropdown( value=self.camera, options=['perspective', 'orthographic'], description='camera') link((step_slide, 'value'), (self, 'step')) link((delay_text, 'value'), (self, 'delay')) link((toggle_button_interpolate, 'value'), (self, 'interpolate')) link((camera_type, 'value'), (self, 'camera')) link((background_color_picker, 'value'), (self._view, 'background')) center_button = self._make_button_center() render_button = self._show_download_image() qtconsole_button = self._make_button_qtconsole() center_render_hbox = _make_autofit( HBox([ toggle_button_interpolate, center_button, render_button, qtconsole_button ])) v0_left = VBox([ step_slide, delay_text, background_color_picker, camera_type, center_render_hbox, ]) v0_left = _relayout_master(v0_left, width='100%') self.widget_general = v0_left return self.widget_general def _make_command_box(self): widget_text_command = Text() @widget_text_command.on_submit def _on_submit_command(_): command = widget_text_command.value js_utils.execute(command) widget_text_command.value = '' return widget_text_command def _create_all_tabs(self): tab = self._display() for index, _ in enumerate(tab.children): # trigger ceating widgets tab.selected_index = index self.widget_extra = self._make_extra_box() for index, _ in enumerate(self.widget_extra.children): self.widget_extra.selected_index = index def _simplify_repr_control(self): for widget in self.widget_repr._saved_widgets: if not isinstance(widget, Tab): widget.layout.display = 'none' self.widget_repr_choices.layout.display = 'flex' self.widget_accordion_repr_parameters.selected_index = 0
class Map(ipyleaflet.Map): def __init__(self, **kwargs): # Change defaults kwargs.setdefault('center', [0, 0]) kwargs.setdefault('zoom', 2) super(Map, self).__init__(**kwargs) # self.added_geometries = {} # self.added_images = {} self.is_shown = False self.EELayers = {} # CREATE TABS self.tabs = Tab() tab_names = ['Inspector', 'Assets', 'Tasks'] ## widgets self.inspectorWid = Accordion() # Inspector Widget self.assetsWid = Accordion() # Assets Widget self.tasksWid = HTML() # Tasks Widget childrenName = ['Inspector', 'Assets', 'Tasks'] childrenWid = [self.inspectorWid, self.assetsWid, self.tasksWid] # Dictonary to hold tab's widgets # (tab's name:widget) self.childrenDict = OrderedDict(zip(childrenName, childrenWid)) # Set tabs children self.tabs.children = self.childrenDict.values() # Set tabs names for i, name in enumerate(tab_names): self.tabs.set_title(i, name) # Handlers self.tabs.observe(self.handle_change_tab) self.handlers = {'Inspector': self.handle_inspector} # First handler: Inspector self.on_interaction(self.handlers['Inspector']) @property def added_images(self): return sum( [1 for val in self.EELayers.values() if val['type'] == 'Image']) @property def added_geometries(self): return sum( [1 for val in self.EELayers.values() if val['type'] == 'Geometry']) def create_assets_tab(self): # ASSETS TAB # Get assets root rootid = ee.data.getAssetRoots()[0]['id'] assets_list = ee.data.getList({'id': rootid}) widlist = [] namelist = [] for asset in assets_list: wid = HTML('') widlist.append(wid) name = asset['id'].split('/')[-1] ty = asset['type'] namelist.append('{} ({})'.format(name, ty)) self.assetsWid.children = widlist for i, name in enumerate(namelist): self.assetsWid.set_title(i, name) def show(self, inspector=True): """ Show the Map on the Notebook """ if not self.is_shown: # Layers Control lc = ipyleaflet.LayersControl() self.add_control(lc) self.is_shown = True if inspector: # Create Assets Tab self.create_assets_tab() # Display display(self, self.tabs) else: display(self) elif inspector: display(self, self.tabs) else: display(self) def addLayer(self, eeObject, visParams=None, name=None, show=True, opacity=None, inspect={ 'data': None, 'reducer': None, 'scale': None }): """ Adds a given EE object to the map as a layer. :param eeObject: Earth Engine object to add to map :type eeObject: ee.Image || ee.Geometry || ee.Feature :param visParams: visualization parameters. For Images can have the following arguments: bands, min, max. :type visParams: dict :param name: name for the layer :type name: str :param inspect: when adding a geometry or a feature you can pop up data from a desired layer. Params are: :data: the EEObject where to get the data from :reducer: the reducer to use :scale: the scale to reduce :return: the added layer :rtype: """ def addImage(image, name): # Check if layer exists if name in self.EELayers.keys(): print("Layer with name {} exists already, please choose" + "another name".format(name)) return params = get_image_tile(image, visParams, show, opacity) layer = ipyleaflet.TileLayer(url=params['url'], attribution=params['attribution'], name=name) self.add_layer(layer) self.EELayers[name] = { 'type': 'Image', 'object': image, 'visParams': visParams, 'layer': layer } return layer def addGeoJson(geometry, name): # Check if layer exists if name in self.EELayers.keys(): print("Layer with name {} exists already, please choose" + "another name".format(name)) return params = get_geojson_tile(geometry, inspect) layer = ipyleaflet.GeoJSON(data=params['geojson'], name=name, popup=HTML(params['pop'])) self.add_layer(layer) self.EELayers[name] = { 'type': 'Geometry', 'object': geometry, 'visParams': None, 'layer': layer } return layer # CASE: ee.Image if isinstance(eeObject, ee.Image): thename = name if name else 'Image {}'.format(self.added_images) addImage(eeObject, thename) elif isinstance(eeObject, ee.Geometry): thename = name if name else 'Geometry {}'.format( self.added_geometries) addGeoJson(eeObject, thename) elif isinstance(eeObject, ee.Feature): geom = eeObject.geometry() addGeoJson(geom) elif isinstance(eeObject, ee.ImageCollection): proxy = eeObject.sort('system:time_start') mosaic = ee.Image(proxy.mosaic()) thename = name if name else 'Mosaic {}'.format(self.added_images) addImage(mosaic, thename) else: print("`addLayer` doesn't support adding the specified object to" "the map") def removeLayer(self, name): """ Remove a layer by its name """ if name in self.EELayers.keys(): layer = self.EELayers[name]['layer'] self.remove_layer(layer) self.EELayers.pop(name) else: print('Layer {} is not present in the map'.format(name)) return def centerObject(self, eeObject, zoom=None, method=1): """ Center an eeObject :param eeObject: :param zoom: :param method: experimetal methods to estimate zoom for fitting bounds Currently: 1 or 2 :type: int """ bounds = get_bounds(eeObject) if isinstance(eeObject, ee.Geometry): centroid = eeObject.centroid().getInfo()['coordinates'] elif isinstance(eeObject, ee.Feature) or isinstance( eeObject, ee.Image): centroid = eeObject.geometry().centroid().getInfo()['coordinates'] elif isinstance(eeObject, list): pol = ee.Geometry.Polygon(inverse_coordinates(list)) centroid = pol.centroid().getInfo()['coordinates'] self.center = inverse_coordinates(centroid) if zoom: self.zoom = zoom else: self.zoom = get_zoom(bounds, method) def getCenter(self): """ Returns the coordinates at the center of the map. No arguments. Returns: Geometry.Point :return: """ center = self.center coords = inverse_coordinates(center) return ee.Geometry.Point(coords) def getBounds(self, asGeoJSON=True): """ Returns the bounds of the current map view, as a list in the format [west, south, east, north] in degrees. Arguments: asGeoJSON (Boolean, optional): If true, returns map bounds as GeoJSON. Returns: GeoJSONGeometry|List<Number>|String """ bounds = inverse_coordinates(self.bounds) if asGeoJSON: return ee.Geometry.Rectangle(bounds) else: return bounds def addTab(self, name, handler, widget=None): """ Add a Tab to the Panel. The handler is for the Map :param name: name for the new tab :type name: str :param handler: handle function for the new tab. Arguments of the function are: :type: the type of the event (click, mouseover, etc..) :coordinates: coordinates where the event occured [lon, lat] :widget: the widget inside the Tab :map: the Map instance :param widget: widget inside the Tab. Defaults to HTML('') :type widget: ipywidgets.Widget """ # Widget wid = widget if widget else HTML('') # Get tab's children as a list tab_children = list(self.tabs.children) # Get a list of tab's titles titles = [ self.tabs.get_title(i) for i, child in enumerate(tab_children) ] # Check if tab already exists if name not in titles: ntabs = len(tab_children) # Add widget as a new children self.childrenDict[name] = wid tab_children.append(wid) # Overwrite tab's children self.tabs.children = tab_children # Set name of the new tab self.tabs.set_title(ntabs, name) # Set the handler for the new tab def proxy_handler(f): def wrap(**kwargs): # Add widget to handler arguments kwargs['widget'] = self.childrenDict[name] coords = kwargs['coordinates'] kwargs['coordinates'] = inverse_coordinates(coords) kwargs['map'] = self return f(**kwargs) return wrap self.handlers[name] = proxy_handler(handler) else: print('Tab {} already exists, please choose another name'.format( name)) def handle_change_tab(self, change): """ Handle function to trigger when tab changes """ # Remove all handlers if change['name'] == 'selected_index': old = change['old'] new = change['new'] old_name = self.tabs.get_title(old) new_name = self.tabs.get_title(new) # Remove all handlers for handl in self.handlers.values(): self.on_interaction(handl, True) # Set new handler if new_name in self.handlers.keys(): self.on_interaction(self.handlers[new_name]) def handle_inspector(self, **change): """ Handle function for the Inspector Widget """ # Get click coordinates coords = inverse_coordinates(change['coordinates']) event = change['type'] # event type if event == 'click': # If the user clicked # Clear children // Loading self.inspectorWid.children = [HTML('wait a second please..')] self.inspectorWid.set_title(0, 'Loading...') # create a point where the user clicked point = ee.Geometry.Point(coords) # First Accordion row text (name) first = 'Point {} at {} zoom'.format(coords, self.zoom) namelist = [first] wids4acc = [HTML('')] # first row has no content for name, obj in self.EELayers.items(): # for every added layer # name = obj['name'] # IMAGES if obj['type'] == 'Image': # Get the image's values image = obj['object'] values = tools.get_value(image, point, 10, 'client') values = tools.sort_dict(values) # Create the content img_html = '' for band, value in values.items(): img_html += '<b>{}</b>: {}</br>'.format(band, value) wid = HTML(img_html) # append widget to list of widgets wids4acc.append(wid) namelist.append(name) # GEOMETRIES elif obj['type'] == 'Geometry': geom = obj['object'] data = str(geom.getInfo()) wid = HTML(data) wids4acc.append(wid) namelist.append(name) # Set children and children's name of inspector widget self.inspectorWid.children = wids4acc for i, n in enumerate(namelist): self.inspectorWid.set_title(i, n)
class Demo3(Demo): desc = '''### Diferencias entre los valores de gamma''' def __init__(self): # self.gammas = [0.00001, 0.0001, 0.001, 0.01, 0.1, 1, 10, 100] self.gammas = [10**i for i in range(-5, 3)] self.all_datasets_names = SUPPORTED_DATASETS self.run_bt = Button(description='Demo3', button_style='info') self.dataset_selector = self.get_default_dts_selector() self.size_selector = self.get_default_size_selector() self.dataset_selector.description = 'Dataset:' self.model_selector = self.get_default_model_selector() self.model_selector.description = 'Model' self.sampler_selector = Dropdown( options=['rbf', 'nystroem'], value='rbf', description='Sampler') self.features_selector = self.get_default_features_selector() self.features_selector.description = 'Features' self.features_selector.layout = Layout(width='800px') self.box_type_selector = self.get_default_box_type_selector() self.box_type_selector.description = 'Bagging' self.n_estimators_selector = self.get_default_n_estimators_selector() self.n_estimators_selector.description = 'N. estim.' self.pca_checkbox = self.get_default_pca_checkbox() self.pca_checkbox.description = 'Perform PCA?' self.pca_order_selector = self.get_default_pca_order_selector() self.g = VBox([ self.dataset_selector, self.size_selector, self.model_selector, self.sampler_selector, self.features_selector, self.box_type_selector, self.n_estimators_selector, self.pca_checkbox, self.pca_order_selector, ]) # self.gui = VBox([self.g, self.run_bt]) self.tab0 = VBox([self.g, self.run_bt]) self.tab1 = self.get_dt_hp_tab() self.tab2 = self.get_logit_hp_tab() self.tab3 = self.get_linearsvc_hp_tab() self.gui = Tab() self.gui.children = [self.tab0, self.tab1, self.tab2, self.tab3] tab_names = ['General', 'DT H-Params.', 'Logit H-Params.', 'SVC H-Params.'] for i, e in enumerate(tab_names): self.gui.set_title(i, e) self.box_type_selector.observe(self.box_type_changed, 'value') self.pca_checkbox.observe(self.pca_checkbox_changed, 'value') # self.sampler_selector.observe(self.sampler_changed, 'value') # Solo para inhabilitar los que tocan self.box_type_changed() self.pca_checkbox_changed() # self.sampler_changed() super().__init__() def gui_to_data(self): ''' Just reading from self.gui, return a dictionary with keys and values needed to run the demo. Keys are the arguments of run_demo ''' dts_name = self.dataset_selector.value dts_size = self.size_selector.value model_name = self.model_selector.value sampler_name = self.sampler_selector.value box_type = self.box_type_selector.value if box_type == "None": box_type = 'none' n_estimators = self.n_estimators_selector.value if box_type == 'none': n_estimators = None pca = self.pca_checkbox.value pca_first = self.pca_order_selector.value features_range = self.features_selector.value model_data = { 'model_name': model_name, 'sampler_name': sampler_name, 'pca_bool': pca, 'pca_first': pca_first, 'n_estim': n_estimators, 'box_type': box_type, } dt_hp = { 'max_depth': self.dt_max_depth_selector.value, 'min_samples_split': self.dt_min_samples_split_selector.value, 'min_samples_leaf': self.dt_min_samples_leaf_selector.value, 'min_weight_fraction_leaf': self.dt_min_weight_fraction_leaf_selector.value, 'max_leaf_nodes': int(self.dt_max_leaf_nodes_selector.value), 'min_impurity_decrease': self.dt_min_impurity_decrease_selector.value, } logit_hp = { 'C': self.logit_C_selector.value } linearsvc_hp = { 'C': self.linearsvc_C_selector.value } ret_dict = { 'dts_name': dts_name, 'dts_size': dts_size, 'model_data': model_data, 'hparams': { 'dt': dt_hp, 'logit': logit_hp, # 'linearsvc': linearsvc_hp, 'linear_svc': linearsvc_hp, }, 'features_range': features_range, } return ret_dict def run_demo(self, dts_name, dts_size, model_data, hparams, features_range): ''' Parameters ---------- dts_name : str model_data : dict Required keys: ['model_name', 'sampler_name', 'pca_bool', 'n_estim', 'box_type'] Almost everything get_model needs hparams: dict With keys ['dt', 'logit', 'linearsvc'] features_range : list The list is the range, so len(features) == 2, and increasing order is assumed ''' # info_run = ''' # - Model: **{0}** # - Sampler: **{1}** # - Bagging: **{2}** # - N. estim.: **{3}** # - PCA: **{4}** # ''' info_run = { 'Dataset': dts_name, 'Size': dts_size, 'Model': model_data['model_name'], 'Sampler': model_data['sampler_name'], 'Box': model_data['box_type'], 'N. estimators': model_data['n_estim'], 'PCA': model_data['pca_bool'], 'PCA first': model_data['pca_first'] # 'DT max. depth': hparams['dt']['max_depth'], # 'DT min. samples split': hparams['dt']['min_samples_split'], # 'DT min. samples leaf': hparams['dt']['min_samples_leaf'], # 'DT min. weight fraction leaf': hparams['dt']['min_weight_fraction_leaf'], # 'DT max. leaf nodes': hparams['dt']['max_leaf_nodes'], # 'DT min. impurity decrease': hparams['dt']['min_impurity_decrease'], # 'Logit C': hparams['logit']['C'], # 'Linear SVC': hparams['linearsvc']['C'], } dt_info_hparams = { 'DT max. depth': hparams['dt']['max_depth'], 'DT min. samples split': hparams['dt']['min_samples_split'], 'DT min. samples leaf': hparams['dt']['min_samples_leaf'], 'DT min. weight fraction leaf': hparams['dt']['min_weight_fraction_leaf'], 'DT max. leaf nodes': hparams['dt']['max_leaf_nodes'], 'DT min. impurity decrease': hparams['dt']['min_impurity_decrease'], } logit_info_hparams = { 'Logit C': hparams['logit']['C'], } linearsvc_info_hparams = { # 'Linear SVC': hparams['linearsvc']['C'], 'Linear SVC': hparams['linear_svc']['C'], } if model_data['model_name'] == 'dt': info_run.update(dt_info_hparams) elif model_data['model_name'] == 'logit': info_run.update(logit_info_hparams) elif model_data['model_name'] == 'linear_svc': info_run.update(linearsvc_info_hparams) else: print('Tenemos un problema') # self.run_specific = info_run.format(model_data['model_name'], # model_data['sampler_name'], # model_data['box_type'], # model_data['n_estim'], # model_data['pca_bool']) self.run_specific = self.get_run_specific_widget(info_run) self.train_scores.clear() self.test_scores.clear() # a list of int is assumed n_splits_features = 30 features = list(range(*features_range)) if (features_range[1] - features_range[0]) > n_splits_features: features = np.linspace(*features_range, num=n_splits_features, dtype=np.int).tolist() self.run_demo_with_sampling(dts_name=dts_name, dts_size=dts_size, model_data=model_data, hparams=hparams, features=features) def run_demo_with_sampling(self, dts_name, dts_size, model_data, hparams, features): ''' Gets the score of many models, all equal (specified in model_data) except for the gamma value of the sampler, which uses self.gammas for each model. Parameters ---------- dts_name : str model_data : dict Data needed to generate a model. Required keys: ['model_name', 'sampler_name', 'pca_bool', 'n_estim', 'box_type'] features : list of int A list with real features to test with. Values of -1 are not allowed Returns ------- (train, test) : tuple of list of dict The scores for many models, which only disagree in the gamma value Keys of dict: ['absi', 'ord', 'label'] ''' train_dicts = [] test_dicts = [] dataset = get_data(dts_name, n_ins=dts_size) model_params = self.get_hparams(model_data['model_name'], hparams) for g in self.gammas: # model = get_model(gamma=g, **model_data) # TODO un poco cutre # model_params = self.get_hparams(model_data['model_name'], # hparams) # model_data tiene # 'model_name' # 'sampler_name' # 'pca_bool' # 'n_estim' # 'box_type' model = get_model(rbfsampler_gamma=g, nystroem_gamma=g, model_params=model_params, **model_data) train_score, test_score, errors =\ get_sampling_model_scores(model, dataset, features) train_score['label'] = 'gamma {}'.format(g) test_score['label'] = 'gamma {}'.format(g) train_dicts.append(train_score) test_dicts.append(test_score) # Ejecutar también el caso de no usar sampler # model_data['sampler_name'] = 'identity' m_data = dict(model_data) m_data['sampler_name'] = 'identity' model = get_model(rbfsampler_gamma=g, nystroem_gamma=g, model_params=model_params, **m_data) tr_score, te_score = get_non_sampling_model_scores(model, dataset) train_score = { 'absi': [features[0], features[-1]], 'ord': [tr_score, tr_score], 'label': 'No sampler' } test_score = { 'absi': [features[0], features[-1]], 'ord': [te_score, te_score], 'label': 'No sampler' } # train_score['label'] = 'No sampler' # test_score['label'] = 'No sampler' train_dicts.append(train_score) test_dicts.append(test_score) # return train_dicts, test_dicts # self.train_scores.append(train_dicts) # self.test_scores.append(test_dicts) self.train_scores = train_dicts self.test_scores = test_dicts def get_hparams(self, model_name, hparams): ''' Depending on the model name, return the dicionary inside hparams with the hyper-parameter ''' if model_name == 'dt': return hparams['dt'] if model_name == 'logit': return hparams['logit'] if model_name == 'linear_svc': # return hparams['linearsvc'] return hparams['linear_svc'] raise ValueError('This model name is not supported') def box_type_changed(self, *args): ''' Desactiva n_estim_selector cuando no se hará bagging El parámetro *args es solo por ipywidgets, no me hace falta ''' if self.box_type_selector.value == 'None': self.n_estimators_selector.disabled = True self.n_estimators_selector.layout.visibility = 'hidden' else: self.n_estimators_selector.disabled = False self.n_estimators_selector.layout.visibility = 'visible' def pca_checkbox_changed(self, *args): ''' Desactiva y hace invisible pca_order_selector cuando no se hará PCA ''' if self.pca_checkbox.value: self.pca_order_selector.disabled = False self.pca_order_selector.layout.visibility = 'visible' else: self.pca_order_selector.disabled = True self.pca_order_selector.layout.visibility = 'hidden'
class marker_detector_tab(VBox): """ Summary: Widget containing several marker detector widgets """ def __init__(self, signal_components: dict): """ Summary: Object constructor. Arguments: signal_components - dictionary with the signal components. Returns: Nothing. """ self.signal_components = signal_components self.count = 0 # List of marker detectors self.marker_detectors = [] self.wt_marker_detectors = Tab() self.wb_add = Button(description='Add', disabled=False, icon='Add') supported_types = [ x._type for x in base_marker_detector_widget.__subclasses__() ] self.wdd_types = Dropdown(options=supported_types, disabled=False) self.wb_remove = Button(description='Remove', disabled=False, icon='Remove') @self.wb_add.on_click def wb_add_on_click(b): new_w = None md_type = self.wdd_types.value if md_type in supported_types: ind = supported_types.index(md_type) new_w = base_marker_detector_widget.__subclasses__()[ind]( self.signal_components) if new_w is not None: self.marker_detectors.append(new_w) self.wt_marker_detectors.children = self.marker_detectors self.wt_marker_detectors.set_title(self.count, new_w.type) self.count += 1 @self.wb_remove.on_click def wd_remove_on_click(b): if len(self.marker_detectors): self.marker_detectors.pop() self.count -= 1 self.wt_marker_detectors.children = self.marker_detectors self.wb_save = Button(description='Save', disabled=False, icon='save') @self.wb_save.on_click def wb_save_on_click(b): # Create the output element in the JSON file _dict = self.dump() key = list(_dict.keys())[0] value = _dict[key] config.set_value(key, value) # Add an empty key for the marker-aggregator (to be dealt with # in a second phase) if config.get_value("marker-aggregator") is None: config.set_value("marker-aggregator", [{}]) # Add a default marker-sink (to be dealt with # in a second phase) config.set_value("marker-sink", [{ "output_file": "./marker_output.csv", "include_header": True }]) else: config.set_value("marker-sink", [{ "output_file": "./marker_output.csv", "include_header": True }, { "output_file": "./agg_marker_output.csv", "include_header": True }]) self.wb_load = Button(description='Load', disabled=False, icon='load') wfc_options = FileChooser(placeholder='Option file', description='Option file:', disabled=False) self.whb_load = HBox([self.wb_load, wfc_options]) @self.wb_load.on_click def wb_load_on_click(b): if wfc_options.selected is not None: optionFile = open(wfc_options.selected) options = json.load(optionFile) self.initialize(options) super().__init__([ self.wt_marker_detectors, HBox([self.wb_add, self.wdd_types]), self.wb_remove, self.wb_save, self.whb_load ]) def dump(self) -> dict: """ Summary: Build and return a dictiory descibing the data displayer tab and its options. Arguments: None. Returns: Dictionary describing the preprocessor. """ tab_list = [] # Build the list of data displayers for data_disp in self.marker_detectors: tab_list.append(data_disp.dump()) out_dict = {"marker-detectors": tab_list} return out_dict def initialize(self, options: dict): """ Summary: Initialize the data displayer tab using a dictionary, which needs to have the same format has that produced by the dump function. Arguments: options - dictionary with the options to initialize the data displayer tab Returns: Nothing. """ if "marker-detectors" not in options: return else: tab_list = options["marker-detectors"] # delete all the marker detectors self.marker_detectors = [] self.count = 0 # supported types supported_types = [ x._type for x in base_marker_detector_widget.__subclasses__() ] for tab in tab_list: if ("type" in tab) and (tab["type"] in supported_types): ind = supported_types.index(tab["type"]) marker_detector = base_marker_detector_widget.__subclasses__()[ind](\ self.signal_components, self) marker_detector.initialize(tab) self.marker_detectors.append(marker_detector) self.wt_marker_detectors.children = self.marker_detectors for ii, wmd in enumerate(self.marker_detectors): self.wt_marker_detectors.set_title(ii, wmd.type) self.count = len(self.marker_detectors) self.children = [ self.wt_marker_detectors, HBox([self.wb_add, self.wdd_types]), self.wb_remove, self.wb_save, self.whb_load ] def set_title(self, tab_index: int, title: str): self.wt_marker_detectors.set_title(tab_index, title) def set_title_from_widget(self, child_tab): # check if the child_tab is a real children of the widget if child_tab not in self.marker_detectors: return index = self.marker_detectors.index(child_tab) title = child_tab.type self.set_title(index, title)
class TrajectoryPlayer(DOMWidget): # should set default values here different from desired defaults # so `observe` can be triggered step = Int(0).tag(sync=True) sync_frame = Bool(True).tag(sync=True) interpolate = Bool(False).tag(sync=False) delay = Float(0.0).tag(sync=True) parameters = Dict().tag(sync=True) iparams = Dict().tag(sync=False) _interpolation_t = Float().tag(sync=False) _iterpolation_type = CaselessStrEnum(['linear', 'spline']).tag(sync=False) spin = Bool(False).tag(sync=False) _spin_x = Int(1).tag(sync=False) _spin_y = Int(0).tag(sync=False) _spin_z = Int(0).tag(sync=False) _spin_speed = Float(0.005).tag(sync=False) camera = CaselessStrEnum(['perspective', 'orthographic'], default_value='perspective').tag(sync=False) _render_params = Dict().tag(sync=False) _real_time_update = Bool(False).tag(sync=False) widget_tab = Any(None).tag(sync=False) widget_repr = Any(None).tag(sync=False) widget_repr_parameters = Any(None).tag(sync=False) widget_quick_repr = Any(None).tag(sync=False) widget_general = Any(None).tag(sync=False) widget_picked = Any(None).tag(sync=False) widget_preference = Any(None).tag(sync=False) widget_extra = Any(None).tag(sync=False) widget_theme = Any(None).tag(sync=False) widget_help = Any(None).tag(sync=False) widget_export_image = Any(None).tag(sync=False) widget_component_slider = Any(None).tag(sync=False) widget_repr_slider = Any(None).tag(sync=False) widget_repr_choices = Any(None).tag(sync=False) widget_repr_control_buttons = Any(None).tag(sync=False) widget_repr_add = Any(None).tag(sync=False) widget_accordion_repr_parameters = Any(None).tag(sync=False) widget_repr_parameters_dialog = Any(None).tag(sync=False) widget_repr_name = Any(None).tag(sync=False) widget_component_dropdown = Any(None).tag(sync=False) widget_drag = Any(None).tag(sync=False) def __init__(self, view, step=1, delay=100, sync_frame=False, min_delay=40): self._view = view self.step = step self.sync_frame = sync_frame self.delay = delay self.min_delay = min_delay self._interpolation_t = 0.5 self._iterpolation_type = 'linear' self.iparams = dict( t=self._interpolation_t, step=1, type=self._iterpolation_type) self._render_params = dict(factor=4, antialias=True, trim=False, transparent=False) self._widget_names = [w for w in dir(self) if w.startswith('wiget_')] self.observe(self._on_widget_built, names=['widget_repr_parameters', 'widget_repr', 'widget_preference']) self._movie_maker = None def _on_widget_built(self, change): widget = change['new'] if widget is not None: widget.layout.padding = '5%' def _update_padding(self, padding=default.DEFAULT_PADDING): widget_collection = [ self.widget_general, self.widget_repr, self.widget_preference, self.widget_repr_parameters, self.widget_help, self.widget_extra, self.widget_picked ] for widget in widget_collection: if widget is not None: widget.layout.padding = padding def _create_all_widgets(self): if self.widget_tab is None: self.widget_tab = self._display() old_index = self.widget_tab.selected_index for index, _ in enumerate(self.widget_tab.children): self.widget_tab.selected_index = index self.widget_tab.selected_index = old_index def smooth(self): self.interpolate = True @observe('camera') def on_camera_changed(self, change): camera_type = change['new'] self._view._remote_call("setParameters", target='Stage', kwargs=dict(cameraType=camera_type)) @property def frame(self): return self._view.frame @frame.setter def frame(self, value): self._view.frame = value @property def count(self): return self._view.count @observe('sync_frame') def update_sync_frame(self, change): value = change['new'] if value: self._view._set_sync_frame() else: self._view._set_unsync_frame() @observe("delay") def update_delay(self, change): delay = change['new'] self._view._set_delay(delay) @observe('parameters') def update_parameters(self, change): params = change['new'] self.sync_frame = params.get("sync_frame", self.sync_frame) self.delay = params.get("delay", self.delay) self.step = params.get("step", self.step) @observe('_interpolation_t') def _interpolation_t_changed(self, change): self.iparams['t'] = change['new'] @observe('spin') def on_spin_changed(self, change): self.spin = change['new'] if self.spin: self._view._set_spin([self._spin_x, self._spin_y, self._spin_z], self._spin_speed) else: # stop self._view._set_spin(None, None) @observe('_spin_x') def on_spin_x_changed(self, change): self._spin_x = change['new'] if self.spin: self._view._set_spin([self._spin_x, self._spin_y, self._spin_z], self._spin_speed) @observe('_spin_y') def on_spin_y_changed(self, change): self._spin_y = change['new'] if self.spin: self._view._set_spin([self._spin_x, self._spin_y, self._spin_z], self._spin_speed) @observe('_spin_z') def on_spin_z_changed(self, change): self._spin_z = change['new'] if self.spin: self._view._set_spin([self._spin_x, self._spin_y, self._spin_z], self._spin_speed) @observe('_spin_speed') def on_spin_speed_changed(self, change): self._spin_speed = change['new'] if self.spin: self._view._set_spin([self._spin_x, self._spin_y, self._spin_z], self._spin_speed) def _display(self): box_factory = [(self._make_general_box, 'General'), (self._make_widget_repr, 'Representation'), (self._make_widget_preference, 'Preference'), (self._make_theme_box, 'Theme'), (self._make_extra_box, 'Extra'), (self._show_website, 'Help')] tab = _make_delay_tab(box_factory, selected_index=-1) # tab = _make_autofit(tab) tab.layout.align_self = 'center' tab.layout.align_items = 'stretch' self.widget_tab = tab return self.widget_tab def _make_widget_tab(self): return self._display() def _make_button_center(self): button = Button(description=' Center', icon='fa-bullseye') @button.on_click def on_click(button): self._view.center() return button def _make_button_theme(self): button = Button(description='Oceans16') @button.on_click def on_click(button): from nglview import theme display(theme.oceans16()) self._view._remote_call('cleanOutput', target='Widget') return button def _make_button_reset_theme(self, hide_toolbar=False): from nglview import theme if hide_toolbar: button = Button(description='Simplified Default') @button.on_click def on_click(button): theme.reset(hide_toolbar=True) else: button = Button(description='Default') @button.on_click def on_click(button): theme.reset() return button def _make_button_clean_error_output(self): button = Button(description='Clear Error') @button.on_click def on_click(_): js_utils.clean_error_output() return button def _make_widget_preference(self, width='100%'): def make_func(): parameters = self._view._full_stage_parameters def func(pan_speed=parameters.get('panSpeed', 0.8), rotate_speed=parameters.get('rotateSpeed', 2), zoom_speed=parameters.get('zoomSpeed', 1.2), clip_dist=parameters.get('clipDist', 10), camera_fov=parameters.get('cameraFov', 40), clip_far=parameters.get('clipFar', 100), clip_near=parameters.get('clipNear', 0), fog_far=parameters.get('fogFar', 100), fog_near=parameters.get('fogNear', 50), impostor=parameters.get('impostor', True), light_intensity=parameters.get('lightIntensity', 1), quality=parameters.get('quality', 'medium'), sample_level=parameters.get('sampleLevel', 1)): self._view.parameters = dict( panSpeed=pan_speed, rotateSpeed=rotate_speed, zoomSpeed=zoom_speed, clipDist=clip_dist, clipFar=clip_far, clipNear=clip_near, cameraFov=camera_fov, fogFar=fog_far, fogNear=fog_near, impostor=impostor, lightIntensity=light_intensity, quality=quality, sampleLevel=sample_level) return func def make_widget_box(): widget_sliders = interactive(make_func(), pan_speed=(0, 10, 0.1), rotate_speed=(0, 10, 1), zoom_speed=(0, 10, 1), clip_dist=(0, 200, 5), clip_far=(0, 100, 1), clip_near=(0, 100, 1), camera_fov=(15, 120, 1), fog_far=(0, 100, 1), fog_near=(0, 100, 1), light_intensity=(0, 10, 0.02), quality=['low', 'medium', 'high'], sample_level=(-1, 5, 1)) for child in widget_sliders.children: if isinstance(child, (IntSlider, FloatSlider)): child.layout.width = default.DEFAULT_SLIDER_WIDTH return widget_sliders if self.widget_preference is None: widget_sliders = make_widget_box() reset_button = Button(description='Reset') widget_sliders.children = [reset_button,] + list(widget_sliders.children) @reset_button.on_click def on_click(reset_button): self._view.parameters = self._view._original_stage_parameters self._view._full_stage_parameters = self._view._original_stage_parameters widget_sliders.children = [reset_button,] + list(make_widget_box().children) self.widget_preference = _relayout_master(widget_sliders, width=width) return self.widget_preference def _show_download_image(self): # "interactive" does not work for True/False in ipywidgets 4 yet. button = Button(description=' Screenshot', icon='fa-camera') @button.on_click def on_click(button): self._view.download_image() return button def _make_button_url(self, url, description): button = Button(description=description) @button.on_click def on_click(button): display(Javascript(js_utils.open_url_template.format(url=url))) return button def _show_website(self, ngl_base_url=default.NGL_BASE_URL): buttons = [self._make_button_url(url.format(ngl_base_url), description) for url, description in [("'http://arose.github.io/nglview/latest/'", "nglview"), ("'{}/index.html'", "NGL"), ("'{}/tutorial-selection-language.html'", "Selection"), ("'{}/tutorial-molecular-representations.html'", "Representation")] ] self.widget_help = _make_autofit(HBox(buttons)) return self.widget_help def _make_button_qtconsole(self): from nglview import js_utils button = Button(description='qtconsole', tooltip='pop up qtconsole') @button.on_click def on_click(button): js_utils.launch_qtconsole() return button def _make_text_picked(self): ta = Textarea(value=json.dumps(self._view.picked), description='Picked atom') ta.layout.width = '300px' return ta def _refresh(self, component_slider, repr_slider): """update representation and component information """ self._view._request_repr_parameters(component=component_slider.value, repr_index=repr_slider.value) self._view._remote_call('requestReprInfo', target='Widget') self._view._handle_repr_dict_changed(change=dict(new=self._view._repr_dict)) def _make_button_repr_control(self, component_slider, repr_slider, repr_selection): button_refresh = Button(description=' Refresh', tooltip='Get representation info', icon='fa-refresh') button_center_selection = Button(description=' Center', tooltip='center selected atoms', icon='fa-bullseye') button_center_selection._ngl_name = 'button_center_selection' button_hide = Button(description=' Hide', icon='fa-eye-slash', tooltip='Hide/Show current representation') button_remove = Button(description=' Remove', icon='fa-trash', tooltip='Remove current representation') button_repr_parameter_dialog = Button(description=' Dialog', tooltip='Pop up representation parameters control dialog') @button_refresh.on_click def on_click_refresh(button): self._refresh(component_slider, repr_slider) @button_center_selection.on_click def on_click_center(center_selection): self._view.center_view(selection=repr_selection.value, component=component_slider.value) @button_hide.on_click def on_click_hide(button_hide): component=component_slider.value repr_index=repr_slider.value if button_hide.description == 'Hide': hide = True button_hide.description = 'Show' else: hide = False button_hide.description = 'Hide' self._view._remote_call('setVisibilityForRepr', target='Widget', args=[component, repr_index, not hide]) @button_remove.on_click def on_click_remove(button_remove): self._view._remove_representation(component=component_slider.value, repr_index=repr_slider.value) self._view._request_repr_parameters(component=component_slider.value, repr_index=repr_slider.value) @button_repr_parameter_dialog.on_click def on_click_repr_dialog(_): from nglview.widget_box import DraggableBox if self.widget_repr_parameters is not None and self.widget_repr_choices: self.widget_repr_parameters_dialog = DraggableBox([self.widget_repr_choices, self.widget_repr_parameters]) self.widget_repr_parameters_dialog._ipython_display_() self.widget_repr_parameters_dialog._dialog = 'on' bbox = _make_autofit(HBox([button_refresh, button_center_selection, button_hide, button_remove, button_repr_parameter_dialog])) return bbox def _make_widget_repr(self): self.widget_repr_name = Text(value='', description='representation') self.widget_repr_name._ngl_name = 'repr_name_text' repr_selection = Text(value=' ', description='selection') repr_selection._ngl_name = 'repr_selection' repr_selection.width = self.widget_repr_name.width = default.DEFAULT_TEXT_WIDTH max_n_components = max(self._view.n_components-1, 0) self.widget_component_slider = IntSlider(value=0, max=max_n_components, min=0, description='component') self.widget_component_slider._ngl_name = 'component_slider' cvalue = ' ' self.widget_component_dropdown = Dropdown(value=cvalue, options=[cvalue,], description='component') self.widget_component_dropdown._ngl_name = 'component_dropdown' self.widget_repr_slider = IntSlider(value=0, description='representation', width=default.DEFAULT_SLIDER_WIDTH) self.widget_repr_slider._ngl_name = 'repr_slider' self.widget_repr_slider.visible = True self.widget_component_slider.layout.width = default.DEFAULT_SLIDER_WIDTH self.widget_repr_slider.layout.width = default.DEFAULT_SLIDER_WIDTH self.widget_component_dropdown.layout.width = self.widget_component_dropdown.max_width = default.DEFAULT_TEXT_WIDTH # turn off for now self.widget_component_dropdown.layout.display = 'none' self.widget_component_dropdown.description = '' # self.widget_accordion_repr_parameters = Accordion() self.widget_accordion_repr_parameters = Tab() self.widget_repr_parameters = self._make_widget_repr_parameters(self.widget_component_slider, self.widget_repr_slider, self.widget_repr_name) self.widget_accordion_repr_parameters.children = [self.widget_repr_parameters, Box()] self.widget_accordion_repr_parameters.set_title(0, 'Parameters') self.widget_accordion_repr_parameters.set_title(1, 'Hide') self.widget_accordion_repr_parameters.selected_index = 1 checkbox_reprlist = Checkbox(value=False, description='reprlist') checkbox_reprlist._ngl_name = 'checkbox_reprlist' self.widget_repr_choices = self._make_repr_name_choices(self.widget_component_slider, self.widget_repr_slider) self.widget_repr_choices._ngl_name = 'reprlist_choices' self.widget_repr_add = self._make_add_widget_repr(self.widget_component_slider) def on_update_checkbox_reprlist(change): self.widget_repr_choices.visible= change['new'] checkbox_reprlist.observe(on_update_checkbox_reprlist, names='value') def on_repr_name_text_value_changed(change): name = change['new'].strip() old = change['old'].strip() should_update = (self._real_time_update and old and name and name in REPRESENTATION_NAMES and name != change['old'].strip()) if should_update: component=self.widget_component_slider.value repr_index=self.widget_repr_slider.value self._view._remote_call('setRepresentation', target='Widget', args=[change['new'], {}, component, repr_index]) self._view._request_repr_parameters(component, repr_index) def on_component_or_repr_slider_value_changed(change): self._view._request_repr_parameters(component=self.widget_component_slider.value, repr_index=self.widget_repr_slider.value) self.widget_component_dropdown.options = tuple(self._view._ngl_component_names) if self.widget_accordion_repr_parameters.selected_index >= 0: self.widget_repr_parameters.name = self.widget_repr_name.value self.widget_repr_parameters.repr_index = self.widget_repr_slider.value self.widget_repr_parameters.component_index = self.widget_component_slider.value def on_repr_selection_value_changed(change): if self._real_time_update: component = self.widget_component_slider.value repr_index = self.widget_repr_slider.value self._view._set_selection(change['new'], component=component, repr_index=repr_index) def on_change_component_dropdown(change): choice = change['new'] if choice: self.widget_component_slider.value = self._view._ngl_component_names.index(choice) self.widget_component_dropdown.observe(on_change_component_dropdown, names='value') self.widget_repr_slider.observe(on_component_or_repr_slider_value_changed, names='value') self.widget_component_slider.observe(on_component_or_repr_slider_value_changed, names='value') self.widget_repr_name.observe(on_repr_name_text_value_changed, names='value') repr_selection.observe(on_repr_selection_value_changed, names='value') self.widget_repr_control_buttons = self._make_button_repr_control(self.widget_component_slider, self.widget_repr_slider, repr_selection) blank_box = Box([Label("")]) all_kids = [self.widget_repr_control_buttons, blank_box, self.widget_repr_add, self.widget_component_dropdown, self.widget_repr_name, repr_selection, self.widget_component_slider, self.widget_repr_slider, self.widget_repr_choices, self.widget_accordion_repr_parameters ] vbox = VBox(all_kids) self._view._request_repr_parameters(component=self.widget_component_slider.value, repr_index=self.widget_repr_slider.value) self.widget_repr = _relayout_master(vbox, width='100%') self._refresh(self.widget_component_slider, self.widget_repr_slider) setattr(self.widget_repr, "_saved_widgets", []) for _box in self.widget_repr.children: if hasattr(_box, 'children'): for kid in _box.children: self.widget_repr._saved_widgets.append(kid) return self.widget_repr def _make_widget_repr_parameters(self, component_slider, repr_slider, repr_name_text=None): name = repr_name_text.value if repr_name_text is not None else ' ' widget = self._view._display_repr(component=component_slider.value, repr_index=repr_slider.value, name=name) widget._ngl_name = 'repr_parameters_box' return widget def _make_button_export_image(self): slider_factor = IntSlider(value=4, min=1, max=10, description='scale') checkbox_antialias = Checkbox(value=True, description='antialias') checkbox_trim = Checkbox(value=False, description='trim') checkbox_transparent = Checkbox(value=False, description='transparent') filename_text = Text(value='Screenshot', description='Filename') delay_text = FloatText(value=1, description='delay (s)', tooltip='hello') start_text, stop_text, step_text = (IntText(value=0, description='start'), IntText(value=self._view.count, description='stop'), IntText(value=1, description='step')) start_text.layout.max_width = stop_text.layout.max_width = step_text.layout.max_width \ = filename_text.layout.max_width = delay_text.layout.max_width = default.DEFAULT_TEXT_WIDTH button_movie_images = Button(description='Export Images') def download_image(filename): self._view.download_image(factor=slider_factor.value, antialias=checkbox_antialias.value, trim=checkbox_trim.value, transparent=checkbox_transparent.value, filename=filename) @button_movie_images.on_click def on_click_images(button_movie_images): for i in range(start_text.value, stop_text.value, step_text.value): self._view.frame = i time.sleep(delay_text.value) download_image(filename=filename_text.value + str(i)) time.sleep(delay_text.value) vbox = VBox([ button_movie_images, start_text, stop_text, step_text, delay_text, filename_text, slider_factor, checkbox_antialias, checkbox_trim, checkbox_transparent, ]) form_items = _relayout(vbox, make_form_item_layout()) form = Box(form_items, layout=_make_box_layout()) # form = _relayout_master(vbox) return form def _make_resize_notebook_slider(self): resize_notebook_slider = IntSlider(min=300, max=2000, description='resize notebook') def on_resize_notebook(change): width = change['new'] self._view._remote_call('resizeNotebook', target='Widget', args=[width,]) resize_notebook_slider.observe(on_resize_notebook, names='value') return resize_notebook_slider def _make_add_widget_repr(self, component_slider): dropdown_repr_name = Dropdown(options=REPRESENTATION_NAMES, value='cartoon') repr_selection = Text(value='*', description='') repr_button = Button(description='Add', tooltip="""Add representation. You can also hit Enter in selection box""") repr_button.layout = Layout(width='auto', flex='1 1 auto') dropdown_repr_name.layout.width = repr_selection.layout.width = default.DEFAULT_TEXT_WIDTH def on_click_or_submit(button_or_text_area): self._view.add_representation(selection=repr_selection.value.strip(), repr_type=dropdown_repr_name.value, component=component_slider.value) repr_button.on_click(on_click_or_submit) repr_selection.on_submit(on_click_or_submit) add_repr_box = HBox([repr_button, dropdown_repr_name, repr_selection]) add_repr_box._ngl_name = 'add_repr_box' return add_repr_box def _make_repr_playground(self): vbox = VBox() children = [] rep_names = REPRESENTATION_NAMES[:] excluded_names = ['ball+stick', 'distance'] for name in excluded_names: rep_names.remove(name) repr_selection = Text(value='*') repr_selection.layout.width = default.DEFAULT_TEXT_WIDTH repr_selection_box = HBox([Label('selection'), repr_selection]) setattr(repr_selection_box, 'value', repr_selection.value) for index, name in enumerate(rep_names): button = ToggleButton(description=name) def make_func(): def on_toggle_button_value_change(change, button=button): selection = repr_selection.value new = change['new'] # True/False if new: self._view.add_representation(button.description, selection=selection) else: self._view._remove_representations_by_name(button.description) return on_toggle_button_value_change button.observe(make_func(), names='value') children.append(button) button_clear = Button(description='clear', button_style='info', icon='fa-eraser') @button_clear.on_click def on_clear(button_clear): self._view.clear() for kid in children: # unselect kid.value = False vbox.children = children + [repr_selection, button_clear] _make_autofit(vbox) self.widget_quick_repr = vbox return self.widget_quick_repr def _make_repr_name_choices(self, component_slider, repr_slider): repr_choices = Dropdown(options=[" ",]) def on_chose(change): repr_name = change['new'] repr_index = repr_choices.options.index(repr_name) repr_slider.value = repr_index repr_choices.observe(on_chose, names='value') repr_choices.layout.width = default.DEFAULT_TEXT_WIDTH self.widget_repr_choices = repr_choices return self.widget_repr_choices def _make_drag_widget(self): button_drag = Button(description='widget drag: off', tooltip='dangerous') drag_nb = Button(description='notebook drag: off', tooltip='dangerous') button_reset_notebook = Button(description='notebook: reset', tooltip='reset?') button_dialog = Button(description='dialog', tooltip='make a dialog') button_split_half = Button(description='split screen', tooltip='try best to make a good layout') @button_drag.on_click def on_drag(button_drag): if button_drag.description == 'widget drag: off': self._view._set_draggable(True) button_drag.description = 'widget drag: on' else: self._view._set_draggable(False) button_drag.description = 'widget drag: off' @drag_nb.on_click def on_drag_nb(button_drag): if drag_nb.description == 'notebook drag: off': js_utils._set_notebook_draggable(True) drag_nb.description = 'notebook drag: on' else: js_utils._set_notebook_draggable(False) drag_nb.description = 'notebook drag: off' @button_reset_notebook.on_click def on_reset(button_reset_notebook): js_utils._reset_notebook() @button_dialog.on_click def on_dialog(button_dialog): self._view._remote_call('setDialog', target='Widget') @button_split_half.on_click def on_split_half(button_dialog): from nglview import js_utils import time js_utils._move_notebook_to_the_left() js_utils._set_notebook_width('5%') time.sleep(0.1) self._view._remote_call('setDialog', target='Widget') drag_box = HBox([button_drag, drag_nb, button_reset_notebook, button_dialog, button_split_half]) drag_box = _make_autofit(drag_box) self.widget_drag = drag_box return drag_box def _make_spin_box(self): checkbox_spin = Checkbox(self.spin, description='spin') spin_x_slide = IntSlider( self._spin_x, min=-1, max=1, description='spin_x') spin_y_slide = IntSlider( self._spin_y, min=-1, max=1, description='spin_y') spin_z_slide = IntSlider( self._spin_z, min=-1, max=1, description='spin_z') spin_speed_slide = FloatSlider( self._spin_speed, min=0, max=0.2, step=0.001, description='spin speed') # spin link((checkbox_spin, 'value'), (self, 'spin')) link((spin_x_slide, 'value'), (self, '_spin_x')) link((spin_y_slide, 'value'), (self, '_spin_y')) link((spin_z_slide, 'value'), (self, '_spin_z')) link((spin_speed_slide, 'value'), (self, '_spin_speed')) spin_box= VBox([checkbox_spin, spin_x_slide, spin_y_slide, spin_z_slide, spin_speed_slide]) spin_box = _relayout_master(spin_box, width='75%') return spin_box def _make_widget_picked(self): self.widget_picked = self._make_text_picked() picked_box = HBox([self.widget_picked,]) return _relayout_master(picked_box, width='75%') def _make_export_image_widget(self): if self.widget_export_image is None: self.widget_export_image = HBox([self._make_button_export_image()]) return self.widget_export_image def _make_extra_box(self): if self.widget_extra is None: extra_list = [(self._make_drag_widget, 'Drag'), (self._make_spin_box, 'Spin'), (self._make_widget_picked, 'Picked'), (self._make_repr_playground, 'Quick'), (self._make_export_image_widget, 'Image'), (self._make_command_box, 'Command')] extra_box = _make_delay_tab(extra_list, selected_index=0) self.widget_extra = extra_box return self.widget_extra def _make_theme_box(self): if self.widget_theme is None: self.widget_theme = Box([self._make_button_theme(), self._make_button_reset_theme(hide_toolbar=False), self._make_button_reset_theme(hide_toolbar=True), self._make_button_clean_error_output()]) return self.widget_theme def _make_general_box(self): if self.widget_general is None: step_slide = IntSlider( value=self.step, min=-100, max=100, description='step') delay_text = IntSlider( value=self.delay, min=10, max=1000, description='delay') toggle_button_interpolate = ToggleButton(self.interpolate, description='Smoothing', tooltip='smoothing trajectory') link((toggle_button_interpolate, 'value'), (self, 'interpolate')) background_color_picker = ColorPicker(value='white', description='background') camera_type = Dropdown(value=self.camera, options=['perspective', 'orthographic'], description='camera') link((step_slide, 'value'), (self, 'step')) link((delay_text, 'value'), (self, 'delay')) link((toggle_button_interpolate, 'value'), (self, 'interpolate')) link((camera_type, 'value'), (self, 'camera')) link((background_color_picker, 'value'), (self._view, 'background')) center_button = self._make_button_center() render_button = self._show_download_image() qtconsole_button = self._make_button_qtconsole() center_render_hbox = _make_autofit(HBox([toggle_button_interpolate, center_button, render_button, qtconsole_button])) v0_left = VBox([step_slide, delay_text, background_color_picker, camera_type, center_render_hbox, ]) v0_left = _relayout_master(v0_left, width='100%') self.widget_general = v0_left return self.widget_general def _make_command_box(self): widget_text_command = Text() @widget_text_command.on_submit def _on_submit_command(_): command = widget_text_command.value js_utils.execute(command) widget_text_command.value = '' return widget_text_command def _create_all_tabs(self): tab = self._display() for index, _ in enumerate(tab.children): # trigger ceating widgets tab.selected_index = index self.widget_extra = self._make_extra_box() for index, _ in enumerate(self.widget_extra.children): self.widget_extra.selected_index = index def _simplify_repr_control(self): for widget in self.widget_repr._saved_widgets: if not isinstance(widget, Tab): widget.layout.display = 'none' self.widget_repr_choices.layout.display = 'flex' self.widget_accordion_repr_parameters.selected_index = 0
buildBtn.on_click(buildBtn_clicked) #modelDd.observe(model_change) buildTab = VBox(build_items) ################################# image tab end ################################### ################################ Finally ########################################################## tab_nest = Tab() tab_nest.children = [swanInputBox, runBox, outputBox, buildTab] tab_nest.set_title(0, 'Input') tab_nest.set_title(1, 'Run') tab_nest.set_title(2, 'Output') tab_nest.set_title(3, 'Build') setvar("""PATH=$HOME/agave-model/bin:$PATH""") cmd("auth-tokens-refresh") clear_output() def on_change(change): global cur_model if change['type'] == 'change' and change['name'] == 'value': with logOp: setvar("MODEL_TITLE="+modelTitle.value) build_model.value = modelTitle.value + " VERSION"
def settings_panel(self): # getMolMap calulation settings. NOTE: should only be called once. margin = 2 num_angles_slider_text = "Number of Inverse Cone Angles to calculate:" num_angles_slider_widget = IntSlider(value=1, min=1, max=5) num_angles_slider = VBox( children=[HTML(value=num_angles_slider_text), num_angles_slider_widget], margin=margin, width="100%" ) link((self.model, "num_angles"), (num_angles_slider_widget, "value")) sub_slider_text = "Subdivision value of the icosphere for numerical calculation:" sub_slider_widget = IntSlider(value=5, min=1, max=9) link((self.model, "sub"), (sub_slider_widget, "value")) sub_slider = VBox(children=[HTML(value=sub_slider_text), sub_slider_widget], margin=margin, width="100%") # link((sub_slider, 'value'), (i, 'value')) # print(self.width) # sub_slider.align = 'center' # sub_slider.width = '100%' # sub_slider.border_color = 'black' # sub_slider.border_width = 2 radius_slider_text = "Cut radius measured from the central atom:" radius_slider_widget = FloatSlider(value=0, min=0, max=10) link((self.model, "radius"), (radius_slider_widget, "value")) radius_slider = VBox(children=[HTML(value=radius_slider_text), radius_slider_widget], margin=margin) atomradscale_slider_text = "Atomic radius scaling factor:" atomradscale_slider_widget = FloatSlider(value=1, min=0, max=4) link((self.model, "rad_scale"), (atomradscale_slider_widget, "value")) atomradscale_slider = VBox( children=[HTML(value=atomradscale_slider_text), atomradscale_slider_widget], margin=margin ) excludeH_button = Checkbox(description="Exclude H from every geometry:") link((self.model, "excludeH"), (excludeH_button, "value")) excludeH_button.on_trait_change(self.excludeH_changed, "value") dont = "Don't exclude any elements" self.dont = dont # TODO: Syncronize exclude_list_widget with excludeH button and define an event on the # model to filter out the `dont` text. # Alternatevily, separate this option into a checkbox and hide the exclude options # while the button is selected. exclude_list_text = "Exclude elements from every geometry:" exclude_list_widget = SelectMultiple( options=[dont] + [e.symbol for e in ELEMENTS], selected_labels=[dont], color="Black", font_size=14, height=120, ) link((exclude_list_widget, "value"), (self.model, "excludes")) # The dirty old SelectMultiple widget does not have an .on_trait_change method. # So we create a new traitlet (excludes_notifier), which has an .on_trait_change method # because it inherits HasTraits. We link the 'value' trait to excludes_notifier.excludes; # and we bind the event handler to excludes_notifier.on_trait_change self.excludes_notifier = ExcludesNotifier() link((exclude_list_widget, "value"), (self.excludes_notifier, "excludes")) self.excludes_notifier.on_trait_change(self.excludes_changed) exclude_list = VBox(children=[HTML(value=exclude_list_text), exclude_list_widget], margin=margin) atomrad_button = ToggleButtons( description="Atomic radius type:", options=["vdwrad", "covrad", "atmrad"], background_color="AliceBlue", margin=margin, ) link((self.model, "rad_type"), (atomrad_button, "value")) runbutton = Button( description="Run calculation!", tooltip="Click here to calculate Buried Volumes and Inverse Cone Angles!", margin=margin * 3, border_color="#9acfea", # border_radius=5, border_width=3, font_size=20, ) runbutton.on_click(self.run_button_clicked) basic_tab = VBox(children=[atomrad_button, excludeH_button]) sliders = VBox(children=[num_angles_slider, atomradscale_slider, radius_slider, sub_slider]) sliders.width = "100%" sliders.pack = "center" advanced_tab = VBox(children=[atomrad_button, sliders, exclude_list]) main_window = Tab(children=[basic_tab, advanced_tab]) main_window.set_title(0, "Basic") main_window.set_title(1, "Advanced") return ControlPanel( title="getMolMap Settings:", children=[main_window, runbutton], border_width=2, border_radius=4, margin=10, padding=0, )