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,
)
