def slider(self, value, min, max, step, description): label = Label(description) self.labels.append(label) ind = len(self.normals) button = ImageButton(width=36, height=28, image_path="%s/plane.png" % (self.image_path), tooltip="Set clipping plane", type=str(ind), layout=Layout(margin="0px 10px 0px 0px")) button.on_click(self.handler) button.add_class("view_button") slider = FloatSlider(value=value, min=min, max=max, step=step, description="", disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='.2f', layout=Layout(width="%dpx" % (self.width - 20))) slider.observe(self.cq_view.clip(ind), "value") return [HBox([button, label]), slider]
def _fill_folder(self): atoms = Button(description=' Fill', icon='adjust', layout=_wlo) opt = ['Ball and Stick', 'Van Der Waals Spheres', 'Covalent Spheres'] #'High Performance']#,'Stick'] fill = Select(options=opt, value=opt[0], layout=_wlo) bond_r = FloatSlider(max=1.0, description='Bond Radius') def _atoms(c): for scn in self.active(): scn.atom_3d = not scn.atom_3d def _fill(c): for scn in self.active(): scn.fill_idx = c.new bond_r.disabled = True if c.new == 1 else False def _bond_r(c): for scn in self.active(): scn.bond_r = c.new atoms.on_click(_atoms) fill.observe(_fill, names='index') bond_r.observe(_bond_r, names='value') content = _ListDict([('opt', fill), ('bond_r', bond_r)]) return Folder(atoms, content)
def MakePoseSlidersThatPublishOnCallback(publishing_system, root_context, my_callback, min_range=PoseSliders.MinRange(), max_range=PoseSliders.MaxRange(), value=PoseSliders.Value(), resolution=0.01, length=200, continuous_update=True): def value_to_pose(val): return RigidTransform(RollPitchYaw(val.roll, val.pitch, val.yaw), [val.x, val.y, val.z]) def pose_to_value(pose): rpy = RollPitchYaw(pose.rotation()) xyz = pose.translation() return PoseSliders.Value(rpy.roll_angle(), rpy.pitch_angle(), rpy.yaw_angle(), xyz[0], xyz[1], xyz[2]) if isinstance(value, RigidTransform): value = pose_to_value(value) publishing_context = publishing_system.GetMyContextFromRoot(root_context) # Publish once immediately. my_callback(root_context, value_to_pose(value)) publishing_system.Publish(publishing_context) global v v = value def _slider_callback(change, var): global v v = v._replace(**{var: change.new}) my_callback(root_context, value_to_pose(v)) publishing_system.Publish(publishing_context) slider_widgets = [] for var in ["roll", "pitch", "yaw", "x", "y", "z"]: slider = FloatSlider(min=getattr(min_range, var), max=getattr(max_range, var), value=getattr(value, var), step=resolution, continuous_update=continuous_update, description=var, layout=Layout(width='90%')) slider.observe(partial(_slider_callback, var=var), names='value') display(slider) slider_widgets.append(slider) return slider_widgets
def notebook_interaction(self, display=True): from ipywidgets import (Checkbox, FloatSlider, VBox) from traitlets import TraitError as TraitletError from IPython.display import display as ip_display try: active = Checkbox(description='active', value=self.active) def on_active_change(change): self.active = change['new'] active.observe(on_active_change, names='value') fine_structure = Checkbox(description='Fine structure', value=self.fine_structure_active) def on_fine_structure_active_change(change): self.fine_structure_active = change['new'] fine_structure.observe(on_fine_structure_active_change, names='value') fs_smoothing = FloatSlider(description='Fine structure smoothing', min=0, max=1, step=0.001, value=self.fine_structure_smoothing) def on_fs_smoothing_change(change): self.fine_structure_smoothing = change['new'] fs_smoothing.observe(on_fs_smoothing_change, names='value') container = VBox([active, fine_structure, fs_smoothing]) for parameter in [ self.intensity, self.effective_angle, self.onset_energy ]: container.children += parameter.notebook_interaction(False), if not display: return container ip_display(container) except TraitletError: if display: print('This function is only avialable when running in a' ' notebook') else: raise
def _create_notebook_widget(self, index=None): from ipywidgets import (FloatSlider, FloatText, Layout, HBox) widget_bounds = self._interactive_slider_bounds(index=index) thismin = FloatText( value=widget_bounds['min'], description='min', layout=Layout(flex='0 1 auto', width='auto'), ) thismax = FloatText( value=widget_bounds['max'], description='max', layout=Layout(flex='0 1 auto', width='auto'), ) current_value = self.value if index is None else self.value[index] current_name = self.name if index is not None: current_name += '_{}'.format(index) widget = FloatSlider(value=current_value, min=thismin.value, max=thismax.value, step=widget_bounds['step'], description=current_name, layout=Layout(flex='1 1 auto', width='auto')) def on_min_change(change): if widget.max > change['new']: widget.min = change['new'] widget.step = np.abs(widget.max - widget.min) * 0.001 def on_max_change(change): if widget.min < change['new']: widget.max = change['new'] widget.step = np.abs(widget.max - widget.min) * 0.001 thismin.observe(on_min_change, names='value') thismax.observe(on_max_change, names='value') this_observed = functools.partial(self._interactive_update, index=index) widget.observe(this_observed, names='value') container = HBox((thismin, widget, thismax)) return container
def _create_widgets(self): """Create widget in the current visual control""" for param in self._param_descriptors: value = self._native_params[param] parameter = self._param_descriptors[param] props = parameter.__propinfo__['__literal__'] description = props['title'] if isinstance(value, float): minimum = self._get_value(props, 'minimum', 0) maximum = self._get_value(props, 'maximum', 1e4) float_slider = FloatSlider(description=description, min=minimum, max=maximum, value=value, STYLE=STYLE, layout=DEFAULT_LAYOUT) float_slider.observe(self._update_params, 'value') self._widgets_list[param] = float_slider if isinstance(value, int): minimum = self._get_value(props, 'minimum', 0) maximum = self._get_value(props, 'maximum', 1e4) int_slider = IntSlider(description=description, min=minimum, max=maximum, value=value, STYLE=STYLE, layout=DEFAULT_LAYOUT) int_slider.observe(self._update_params, 'value') self._widgets_list[param] = int_slider if isinstance(value, bool): check_box = Checkbox(description=description, value=bool(value), STYLE=STYLE, layout=DEFAULT_LAYOUT) check_box.observe(self._update_params, 'value') self._widgets_list[param] = check_box if isinstance(value, str): text_box = Text(description=description, value=value, STYLE=STYLE, layout=DEFAULT_LAYOUT) text_box.observe(self._update_params, 'value') self._widgets_list[param] = text_box
def _create_notebook_widget(self, index=None): from ipywidgets import (FloatSlider, FloatText, Layout, HBox) widget_bounds = self._interactive_slider_bounds(index=index) thismin = FloatText(value=widget_bounds['min'], description='min', layout=Layout(flex='0 1 auto', width='auto'),) thismax = FloatText(value=widget_bounds['max'], description='max', layout=Layout(flex='0 1 auto', width='auto'),) current_value = self.value if index is None else self.value[index] current_name = self.name if index is not None: current_name += '_{}'.format(index) widget = FloatSlider(value=current_value, min=thismin.value, max=thismax.value, step=widget_bounds['step'], description=current_name, layout=Layout(flex='1 1 auto', width='auto')) def on_min_change(change): if widget.max > change['new']: widget.min = change['new'] widget.step = np.abs(widget.max - widget.min) * 0.001 def on_max_change(change): if widget.min < change['new']: widget.max = change['new'] widget.step = np.abs(widget.max - widget.min) * 0.001 thismin.observe(on_min_change, names='value') thismax.observe(on_max_change, names='value') this_observed = functools.partial(self._interactive_update, index=index) widget.observe(this_observed, names='value') container = HBox((thismin, widget, thismax)) return container
def notebook_interaction(self, display=True): from ipywidgets import (Checkbox, FloatSlider, VBox) from traitlets import TraitError as TraitletError from IPython.display import display as ip_display try: active = Checkbox(description='active', value=self.active) def on_active_change(change): self.active = change['new'] active.observe(on_active_change, names='value') fine_structure = Checkbox(description='Fine structure', value=self.fine_structure_active) def on_fine_structure_active_change(change): self.fine_structure_active = change['new'] fine_structure.observe(on_fine_structure_active_change, names='value') fs_smoothing = FloatSlider(description='Fine structure smoothing', min=0, max=1, step=0.001, value=self.fine_structure_smoothing) def on_fs_smoothing_change(change): self.fine_structure_smoothing = change['new'] fs_smoothing.observe(on_fs_smoothing_change, names='value') container = VBox([active, fine_structure, fs_smoothing]) for parameter in [self.intensity, self.effective_angle, self.onset_energy]: container.children += parameter.notebook_interaction(False), if not display: return container ip_display(container) except TraitletError: if display: print('This function is only avialable when running in a' ' notebook') else: raise
def _tensor_folder(self): alo = Layout(width='70px') rlo = Layout(width='220px') scale = FloatSlider(max=10.0, step=0.001, readout=True, value=1.0) tens = Button(description=' Tensor', icon='bank') def _tens(c): for scn in self.active(): scn.tens = not scn.tens def _scale(c): for scn in self.active(): scn.scale = c.new tens.on_click(_tens) scale.observe(_scale, names='value') content = _ListDict([ ('scale', scale), ]) return Folder(tens, content)
class Dashboard(VBox): """ Build the dashboard for Jupyter widgets. Requires running in a notebook/jupyterlab. """ def __init__(self, net, width="95%", height="550px", play_rate=0.5): self._ignore_layer_updates = False self.player = _Player(self, play_rate) self.player.start() self.net = net r = random.randint(1, 1000000) self.class_id = "picture-dashboard-%s-%s" % (self.net.name, r) self._width = width self._height = height ## Global widgets: style = {"description_width": "initial"} self.feature_columns = IntText(description="Feature columns:", value=self.net.config["dashboard.features.columns"], min=0, max=1024, style=style) self.feature_scale = FloatText(description="Feature scale:", value=self.net.config["dashboard.features.scale"], min=0.1, max=10, style=style) self.feature_columns.observe(self.regenerate, names='value') self.feature_scale.observe(self.regenerate, names='value') ## Hack to center SVG as justify-content is broken: self.net_svg = HTML(value="""<p style="text-align:center">%s</p>""" % ("",), layout=Layout( width=self._width, overflow_x='auto', overflow_y="auto", justify_content="center")) # Make controls first: self.output = Output() controls = self.make_controls() config = self.make_config() super().__init__([config, controls, self.net_svg, self.output]) def propagate(self, inputs): """ Propagate inputs through the dashboard view of the network. """ if dynamic_pictures_check(): return self.net.propagate(inputs, class_id=self.class_id, update_pictures=True) else: self.regenerate(inputs=input) def goto(self, position): if len(self.net.dataset.inputs) == 0 or len(self.net.dataset.targets) == 0: return if self.control_select.value == "Train": length = len(self.net.dataset.train_inputs) elif self.control_select.value == "Test": length = len(self.net.dataset.test_inputs) #### Position it: if position == "begin": self.control_slider.value = 0 elif position == "end": self.control_slider.value = length - 1 elif position == "prev": if self.control_slider.value - 1 < 0: self.control_slider.value = length - 1 # wrap around else: self.control_slider.value = max(self.control_slider.value - 1, 0) elif position == "next": if self.control_slider.value + 1 > length - 1: self.control_slider.value = 0 # wrap around else: self.control_slider.value = min(self.control_slider.value + 1, length - 1) self.position_text.value = self.control_slider.value def change_select(self, change=None): """ """ self.update_control_slider(change) self.regenerate() def update_control_slider(self, change=None): self.net.config["dashboard.dataset"] = self.control_select.value if len(self.net.dataset.inputs) == 0 or len(self.net.dataset.targets) == 0: self.total_text.value = "of 0" self.control_slider.value = 0 self.position_text.value = 0 self.control_slider.disabled = True self.position_text.disabled = True for child in self.control_buttons.children: if not hasattr(child, "icon") or child.icon != "refresh": child.disabled = True return if self.control_select.value == "Test": self.total_text.value = "of %s" % len(self.net.dataset.test_inputs) minmax = (0, max(len(self.net.dataset.test_inputs) - 1, 0)) if minmax[0] <= self.control_slider.value <= minmax[1]: pass # ok else: self.control_slider.value = 0 self.control_slider.min = minmax[0] self.control_slider.max = minmax[1] if len(self.net.dataset.test_inputs) == 0: disabled = True else: disabled = False elif self.control_select.value == "Train": self.total_text.value = "of %s" % len(self.net.dataset.train_inputs) minmax = (0, max(len(self.net.dataset.train_inputs) - 1, 0)) if minmax[0] <= self.control_slider.value <= minmax[1]: pass # ok else: self.control_slider.value = 0 self.control_slider.min = minmax[0] self.control_slider.max = minmax[1] if len(self.net.dataset.train_inputs) == 0: disabled = True else: disabled = False self.control_slider.disabled = disabled self.position_text.disbaled = disabled self.position_text.value = self.control_slider.value for child in self.control_buttons.children: if not hasattr(child, "icon") or child.icon != "refresh": child.disabled = disabled def update_zoom_slider(self, change): if change["name"] == "value": self.net.config["svg_scale"] = self.zoom_slider.value self.regenerate() def update_position_text(self, change): # {'name': 'value', 'old': 2, 'new': 3, 'owner': IntText(value=3, layout=Layout(width='100%')), 'type': 'change'} self.control_slider.value = change["new"] def get_current_input(self): if self.control_select.value == "Train" and len(self.net.dataset.train_targets) > 0: return self.net.dataset.train_inputs[self.control_slider.value] elif self.control_select.value == "Test" and len(self.net.dataset.test_targets) > 0: return self.net.dataset.test_inputs[self.control_slider.value] def get_current_targets(self): if self.control_select.value == "Train" and len(self.net.dataset.train_targets) > 0: return self.net.dataset.train_targets[self.control_slider.value] elif self.control_select.value == "Test" and len(self.net.dataset.test_targets) > 0: return self.net.dataset.test_targets[self.control_slider.value] def update_slider_control(self, change): if len(self.net.dataset.inputs) == 0 or len(self.net.dataset.targets) == 0: self.total_text.value = "of 0" return if change["name"] == "value": self.position_text.value = self.control_slider.value if self.control_select.value == "Train" and len(self.net.dataset.train_targets) > 0: self.total_text.value = "of %s" % len(self.net.dataset.train_inputs) if self.net.model is None: return if not dynamic_pictures_check(): self.regenerate(inputs=self.net.dataset.train_inputs[self.control_slider.value], targets=self.net.dataset.train_targets[self.control_slider.value]) return output = self.net.propagate(self.net.dataset.train_inputs[self.control_slider.value], class_id=self.class_id, update_pictures=True) if self.feature_bank.value in self.net.layer_dict.keys(): self.net.propagate_to_features(self.feature_bank.value, self.net.dataset.train_inputs[self.control_slider.value], cols=self.feature_columns.value, scale=self.feature_scale.value, html=False) if self.net.config["show_targets"]: if len(self.net.output_bank_order) == 1: ## FIXME: use minmax of output bank self.net.display_component([self.net.dataset.train_targets[self.control_slider.value]], "targets", class_id=self.class_id, minmax=(-1, 1)) else: self.net.display_component(self.net.dataset.train_targets[self.control_slider.value], "targets", class_id=self.class_id, minmax=(-1, 1)) if self.net.config["show_errors"]: ## minmax is error if len(self.net.output_bank_order) == 1: errors = np.array(output) - np.array(self.net.dataset.train_targets[self.control_slider.value]) self.net.display_component([errors.tolist()], "errors", class_id=self.class_id, minmax=(-1, 1)) else: errors = [] for bank in range(len(self.net.output_bank_order)): errors.append( np.array(output[bank]) - np.array(self.net.dataset.train_targets[self.control_slider.value][bank])) self.net.display_component(errors, "errors", class_id=self.class_id, minmax=(-1, 1)) elif self.control_select.value == "Test" and len(self.net.dataset.test_targets) > 0: self.total_text.value = "of %s" % len(self.net.dataset.test_inputs) if self.net.model is None: return if not dynamic_pictures_check(): self.regenerate(inputs=self.net.dataset.test_inputs[self.control_slider.value], targets=self.net.dataset.test_targets[self.control_slider.value]) return output = self.net.propagate(self.net.dataset.test_inputs[self.control_slider.value], class_id=self.class_id, update_pictures=True) if self.feature_bank.value in self.net.layer_dict.keys(): self.net.propagate_to_features(self.feature_bank.value, self.net.dataset.test_inputs[self.control_slider.value], cols=self.feature_columns.value, scale=self.feature_scale.value, html=False) if self.net.config["show_targets"]: ## FIXME: use minmax of output bank self.net.display_component([self.net.dataset.test_targets[self.control_slider.value]], "targets", class_id=self.class_id, minmax=(-1, 1)) if self.net.config["show_errors"]: ## minmax is error if len(self.net.output_bank_order) == 1: errors = np.array(output) - np.array(self.net.dataset.test_targets[self.control_slider.value]) self.net.display_component([errors.tolist()], "errors", class_id=self.class_id, minmax=(-1, 1)) else: errors = [] for bank in range(len(self.net.output_bank_order)): errors.append( np.array(output[bank]) - np.array(self.net.dataset.test_targets[self.control_slider.value][bank])) self.net.display_component(errors, "errors", class_id=self.class_id, minmax=(-1, 1)) def toggle_play(self, button): ## toggle if self.button_play.description == "Play": self.button_play.description = "Stop" self.button_play.icon = "pause" self.player.resume() else: self.button_play.description = "Play" self.button_play.icon = "play" self.player.pause() def prop_one(self, button=None): self.update_slider_control({"name": "value"}) def regenerate(self, button=None, inputs=None, targets=None): ## Protection when deleting object on shutdown: if isinstance(button, dict) and 'new' in button and button['new'] is None: return ## Update the config: self.net.config["dashboard.features.bank"] = self.feature_bank.value self.net.config["dashboard.features.columns"] = self.feature_columns.value self.net.config["dashboard.features.scale"] = self.feature_scale.value inputs = inputs if inputs is not None else self.get_current_input() targets = targets if targets is not None else self.get_current_targets() features = None if self.feature_bank.value in self.net.layer_dict.keys() and inputs is not None: if self.net.model is not None: features = self.net.propagate_to_features(self.feature_bank.value, inputs, cols=self.feature_columns.value, scale=self.feature_scale.value, display=False) svg = """<p style="text-align:center">%s</p>""" % (self.net.to_svg(inputs=inputs, targets=targets, class_id=self.class_id),) if inputs is not None and features is not None: html_horizontal = """ <table align="center" style="width: 100%%;"> <tr> <td valign="top" style="width: 50%%;">%s</td> <td valign="top" align="center" style="width: 50%%;"><p style="text-align:center"><b>%s</b></p>%s</td> </tr> </table>""" html_vertical = """ <table align="center" style="width: 100%%;"> <tr> <td valign="top">%s</td> </tr> <tr> <td valign="top" align="center"><p style="text-align:center"><b>%s</b></p>%s</td> </tr> </table>""" self.net_svg.value = (html_vertical if self.net.config["svg_rotate"] else html_horizontal) % ( svg, "%s features" % self.feature_bank.value, features) else: self.net_svg.value = svg def make_colormap_image(self, colormap_name): from .layers import Layer if not colormap_name: colormap_name = get_colormap() layer = Layer("Colormap", 100) minmax = layer.get_act_minmax() image = layer.make_image(np.arange(minmax[0], minmax[1], .01), colormap_name, {"pixels_per_unit": 1, "svg_rotate": self.net.config["svg_rotate"]}).resize((300, 25)) return image def set_attr(self, obj, attr, value): if value not in [{}, None]: ## value is None when shutting down if isinstance(value, dict): value = value["value"] if isinstance(obj, dict): obj[attr] = value else: setattr(obj, attr, value) ## was crashing on Widgets.__del__, if get_ipython() no longer existed self.regenerate() def make_controls(self): button_begin = Button(icon="fast-backward", layout=Layout(width='100%')) button_prev = Button(icon="backward", layout=Layout(width='100%')) button_next = Button(icon="forward", layout=Layout(width='100%')) button_end = Button(icon="fast-forward", layout=Layout(width='100%')) #button_prop = Button(description="Propagate", layout=Layout(width='100%')) #button_train = Button(description="Train", layout=Layout(width='100%')) self.button_play = Button(icon="play", description="Play", layout=Layout(width="100%")) refresh_button = Button(icon="refresh", layout=Layout(width="25%")) self.position_text = IntText(value=0, layout=Layout(width="100%")) self.control_buttons = HBox([ button_begin, button_prev, #button_train, self.position_text, button_next, button_end, self.button_play, refresh_button ], layout=Layout(width='100%', height="50px")) length = (len(self.net.dataset.train_inputs) - 1) if len(self.net.dataset.train_inputs) > 0 else 0 self.control_slider = IntSlider(description="Dataset index", continuous_update=False, min=0, max=max(length, 0), value=0, layout=Layout(width='100%')) if self.net.config["dashboard.dataset"] == "Train": length = len(self.net.dataset.train_inputs) else: length = len(self.net.dataset.test_inputs) self.total_text = Label(value="of %s" % length, layout=Layout(width="100px")) self.zoom_slider = FloatSlider(description="Zoom", continuous_update=False, min=0, max=1.0, style={"description_width": 'initial'}, layout=Layout(width="65%"), value=self.net.config["svg_scale"] if self.net.config["svg_scale"] is not None else 0.5) ## Hook them up: button_begin.on_click(lambda button: self.goto("begin")) button_end.on_click(lambda button: self.goto("end")) button_next.on_click(lambda button: self.goto("next")) button_prev.on_click(lambda button: self.goto("prev")) self.button_play.on_click(self.toggle_play) self.control_slider.observe(self.update_slider_control, names='value') refresh_button.on_click(lambda widget: (self.update_control_slider(), self.output.clear_output(), self.regenerate())) self.zoom_slider.observe(self.update_zoom_slider, names='value') self.position_text.observe(self.update_position_text, names='value') # Put them together: controls = VBox([HBox([self.control_slider, self.total_text], layout=Layout(height="40px")), self.control_buttons], layout=Layout(width='100%')) #net_page = VBox([control, self.net_svg], layout=Layout(width='95%')) controls.on_displayed(lambda widget: self.regenerate()) return controls def make_config(self): layout = Layout() style = {"description_width": "initial"} checkbox1 = Checkbox(description="Show Targets", value=self.net.config["show_targets"], layout=layout, style=style) checkbox1.observe(lambda change: self.set_attr(self.net.config, "show_targets", change["new"]), names='value') checkbox2 = Checkbox(description="Errors", value=self.net.config["show_errors"], layout=layout, style=style) checkbox2.observe(lambda change: self.set_attr(self.net.config, "show_errors", change["new"]), names='value') hspace = IntText(value=self.net.config["hspace"], description="Horizontal space between banks:", style=style, layout=layout) hspace.observe(lambda change: self.set_attr(self.net.config, "hspace", change["new"]), names='value') vspace = IntText(value=self.net.config["vspace"], description="Vertical space between layers:", style=style, layout=layout) vspace.observe(lambda change: self.set_attr(self.net.config, "vspace", change["new"]), names='value') self.feature_bank = Select(description="Features:", value=self.net.config["dashboard.features.bank"], options=[""] + [layer.name for layer in self.net.layers if self.net._layer_has_features(layer.name)], rows=1) self.feature_bank.observe(self.regenerate, names='value') self.control_select = Select( options=['Test', 'Train'], value=self.net.config["dashboard.dataset"], description='Dataset:', rows=1 ) self.control_select.observe(self.change_select, names='value') column1 = [self.control_select, self.zoom_slider, hspace, vspace, HBox([checkbox1, checkbox2]), self.feature_bank, self.feature_columns, self.feature_scale ] ## Make layer selectable, and update-able: column2 = [] layer = self.net.layers[-1] self.layer_select = Select(description="Layer:", value=layer.name, options=[layer.name for layer in self.net.layers], rows=1) self.layer_select.observe(self.update_layer_selection, names='value') column2.append(self.layer_select) self.layer_visible_checkbox = Checkbox(description="Visible", value=layer.visible, layout=layout) self.layer_visible_checkbox.observe(self.update_layer, names='value') column2.append(self.layer_visible_checkbox) self.layer_colormap = Select(description="Colormap:", options=[""] + AVAILABLE_COLORMAPS, value=layer.colormap if layer.colormap is not None else "", layout=layout, rows=1) self.layer_colormap_image = HTML(value="""<img src="%s"/>""" % self.net._image_to_uri(self.make_colormap_image(layer.colormap))) self.layer_colormap.observe(self.update_layer, names='value') column2.append(self.layer_colormap) column2.append(self.layer_colormap_image) ## get dynamic minmax; if you change it it will set it in layer as override: minmax = layer.get_act_minmax() self.layer_mindim = FloatText(description="Leftmost color maps to:", value=minmax[0], style=style) self.layer_maxdim = FloatText(description="Rightmost color maps to:", value=minmax[1], style=style) self.layer_mindim.observe(self.update_layer, names='value') self.layer_maxdim.observe(self.update_layer, names='value') column2.append(self.layer_mindim) column2.append(self.layer_maxdim) output_shape = layer.get_output_shape() self.layer_feature = IntText(value=layer.feature, description="Feature to show:", style=style) self.svg_rotate = Checkbox(description="Rotate", value=layer.visible, layout=layout) self.layer_feature.observe(self.update_layer, names='value') column2.append(self.layer_feature) self.svg_rotate = Checkbox(description="Rotate network", value=self.net.config["svg_rotate"], style={"description_width": 'initial'}, layout=Layout(width="52%")) self.svg_rotate.observe(lambda change: self.set_attr(self.net.config, "svg_rotate", change["new"]), names='value') self.save_config_button = Button(icon="save", layout=Layout(width="10%")) self.save_config_button.on_click(self.save_config) column2.append(HBox([self.svg_rotate, self.save_config_button])) config_children = HBox([VBox(column1, layout=Layout(width="100%")), VBox(column2, layout=Layout(width="100%"))]) accordion = Accordion(children=[config_children]) accordion.set_title(0, self.net.name) accordion.selected_index = None return accordion def save_config(self, widget=None): self.net.save_config() def update_layer(self, change): """ Update the layer object, and redisplay. """ if self._ignore_layer_updates: return ## The rest indicates a change to a display variable. ## We need to save the value in the layer, and regenerate ## the display. # Get the layer: layer = self.net[self.layer_select.value] # Save the changed value in the layer: layer.feature = self.layer_feature.value layer.visible = self.layer_visible_checkbox.value ## These three, dealing with colors of activations, ## can be done with a prop_one(): if "color" in change["owner"].description.lower(): ## Matches: Colormap, lefmost color, rightmost color ## overriding dynamic minmax! layer.minmax = (self.layer_mindim.value, self.layer_maxdim.value) layer.minmax = (self.layer_mindim.value, self.layer_maxdim.value) layer.colormap = self.layer_colormap.value if self.layer_colormap.value else None self.layer_colormap_image.value = """<img src="%s"/>""" % self.net._image_to_uri(self.make_colormap_image(layer.colormap)) self.prop_one() else: self.regenerate() def update_layer_selection(self, change): """ Just update the widgets; don't redraw anything. """ ## No need to redisplay anything self._ignore_layer_updates = True ## First, get the new layer selected: layer = self.net[self.layer_select.value] ## Now, let's update all of the values without updating: self.layer_visible_checkbox.value = layer.visible self.layer_colormap.value = layer.colormap if layer.colormap != "" else "" self.layer_colormap_image.value = """<img src="%s"/>""" % self.net._image_to_uri(self.make_colormap_image(layer.colormap)) minmax = layer.get_act_minmax() self.layer_mindim.value = minmax[0] self.layer_maxdim.value = minmax[1] self.layer_feature.value = layer.feature self._ignore_layer_updates = False
class Player(VBox): def __init__(self, title, function, length, play_rate=0.1): """ function - takes a slider value and returns displayables """ self.player = _Player(self, play_rate) self.player.start() self.title = title self.function = function self.length = length self.output = Output() self.position_text = FloatText(value=0.0, layout=Layout(width="100%")) self.total_text = Label(value="of %s" % round(self.length * 0.1, 1), layout=Layout(width="100px")) controls = self.make_controls() super().__init__([controls, self.output]) def update_length(self, length): self.length = length self.total_text.value = "of %s" % round(self.length * 0.1, 1) self.control_slider.max = round(max(self.length * 0.1, 0), 1) def goto(self, position): #### Position it: if position == "begin": self.control_slider.value = 0.0 elif position == "end": self.control_slider.value = round(self.length * 0.1, 1) elif position == "prev": if self.control_slider.value - 0.1 < 0: self.control_slider.value = round(self.length * 0.1, 1) # wrap around else: self.control_slider.value = round( max(self.control_slider.value - 0.1, 0), 1) elif position == "next": if round(self.control_slider.value + 0.1, 1) > round( self.length * 0.1, 1): self.control_slider.value = 0 # wrap around else: self.control_slider.value = round( min(self.control_slider.value + 0.1, self.length * 0.1), 1) self.position_text.value = round(self.control_slider.value, 1) def toggle_play(self, button): ## toggle if self.button_play.description == "Play": self.button_play.description = "Stop" self.button_play.icon = "pause" self.player.resume() else: self.button_play.description = "Play" self.button_play.icon = "play" self.player.pause() def make_controls(self): button_begin = Button(icon="fast-backward", layout=Layout(width="100%")) button_prev = Button(icon="backward", layout=Layout(width="100%")) button_next = Button(icon="forward", layout=Layout(width="100%")) button_end = Button(icon="fast-forward", layout=Layout(width="100%")) self.button_play = Button(icon="play", description="Play", layout=Layout(width="100%")) self.control_buttons = HBox( [ button_begin, button_prev, self.position_text, button_next, button_end, self.button_play, ], layout=Layout(width="100%", height="50px"), ) self.control_slider = FloatSlider( description=self.title, continuous_update=False, min=0.0, step=0.1, max=max(round(self.length * 0.1, 1), 0.0), value=0.0, readout_format=".1f", style={"description_width": "initial"}, layout=Layout(width="100%"), ) ## Hook them up: button_begin.on_click(lambda button: self.goto("begin")) button_end.on_click(lambda button: self.goto("end")) button_next.on_click(lambda button: self.goto("next")) button_prev.on_click(lambda button: self.goto("prev")) self.button_play.on_click(self.toggle_play) self.control_slider.observe(self.update_slider_control, names="value") controls = VBox( [ HBox([self.control_slider, self.total_text], layout=Layout(height="40px")), self.control_buttons, ], layout=Layout(width="100%"), ) controls.on_displayed(lambda widget: self.initialize()) return controls def initialize(self): """ Setup the displayer ids to map results to the areas. """ results = self.function(self.control_slider.value) if not isinstance(results, (list, tuple)): results = [results] self.displayers = [display(x, display_id=True) for x in results] def update_slider_control(self, change): """ If the slider changes the value, call the function and update display areas. """ if change["name"] == "value": self.position_text.value = self.control_slider.value self.output.clear_output(wait=True) results = self.function(self.control_slider.value) if not isinstance(results, (list, tuple)): results = [results] for i in range(len(self.displayers)): self.displayers[i].update(results[i])
out = widgets.interactive_output(f, {'a': a, 'b': b, 'c': c}) display(ui, out) """#*observe : 相互に依存している引数""" x_widget = FloatSlider(min=0.0, max=10.0, step=0.05) y_widget = FloatSlider(min=0.5, max=10.0, step=0.05, value=5.0) def update_x_range(*args): x_widget.max = 2.0 * y_widget.value y_widget.observe(update_x_range, 'value') def printer(x, y): print(x, y) interact(printer, x=x_widget, y=y_widget) """#output.layout : ちらつきを防ぐ""" # Commented out IPython magic to ensure Python compatibility. # %matplotlib inline from ipywidgets import interactive import matplotlib.pyplot as plt import numpy as np
def addLayer(inMap, path, name, clip=[0, 0.8], bands=None): #Check the filetype: netcdf or geotiff if path.split('.')[-1] == 'nc': da = xr.open_dataset(path) if 't' in da.dims: da = da.drop('t').squeeze('t').to_array().astype(np.float32) elif 'time' in da.dims: da = da.drop('time').squeeze('time').to_array().astype(np.float32) else: da = da.to_array().astype(np.float32) if 'variable' in da.dims and 'bands' in da.dims: da = da.drop('variable').squeeze('variable').rename( {'bands': 'variable'}) else: da = xr.open_rasterio(path) if 't' in da.dims: da = da.rename({ 'band': 'variable' }).drop('t').squeeze('t').astype(np.float32) else: da = da.rename({'band': 'variable'}).astype(np.float32) rds4326 = da.rio.reproject("epsg:4326") rds4326.name = name rds4326 = rds4326.rio.write_crs(4326) # WGS 84 if bands is not None: rds4326 = rds4326.loc[dict(variable=bands)] opacity_slider = FloatSlider(description=name + ' opacity:', min=0, max=1, value=1) def set_opacity(change): l.opacity = change['new'] if (len(rds4326.variable) == 3): rds4326 = rds4326.clip(clip[0], clip[1]) / clip[1] * 255 rds4326 = rds4326.fillna(0).rio.write_nodata(0) rds4326 = rds4326.chunk((1000, 1000)) l = rds4326.leaflet.plot(inMap.map, rgb_dim='variable') opacity_slider.observe(set_opacity, names='value') slider_control = WidgetControl(widget=opacity_slider, position='bottomleft') inMap.map.add_control(slider_control) elif (len(rds4326.variable) == 1): rds4326 = rds4326[0] rds4326 = rds4326.clip(clip[0], clip[1]) rds4326 = rds4326.fillna(0).rio.write_nodata(0) rds4326 = rds4326.chunk((1000, 1000)) cmap = plt.cm.get_cmap('Greys_r') l = rds4326.leaflet.plot(inMap.map, colormap=cmap) def set_opacity(change): l.opacity = change['new'] opacity_slider.observe(set_opacity, names='value') slider_control = WidgetControl(widget=opacity_slider, position='bottomleft') inMap.map.add_control(slider_control) else: rds4326 = rds4326[0] rds4326 = rds4326.fillna(0).rio.write_nodata(0) rds4326 = rds4326.chunk((1000, 1000)) rds4326 = rds4326.clip(clip[0], clip[1]) cmap = plt.cm.get_cmap('Greys_r') l = rds4326.leaflet.plot(inMap.map, colormap=cmap) def set_opacity(change): l.opacity = change['new'] opacity_slider.observe(set_opacity, names='value') slider_control = WidgetControl(widget=opacity_slider, position='bottomleft') inMap.map.add_control(slider_control) return
def create_param_widget(self, param, value): from ipywidgets import Layout, HBox children = (HBox(),) if isinstance(value, bool): from ipywidgets import Label, ToggleButton p = Label(value=param, layout=Layout(width='10%')) t = ToggleButton(description=str(value), value=value) def on_bool_change(change): t.description = str(change['new']) self.params[self._method][param] = change['new'] self.replot_peaks() t.observe(on_bool_change, names='value') children = (p, t) elif isinstance(value, float): from ipywidgets import FloatSlider, FloatText, BoundedFloatText, \ Label from traitlets import link p = Label(value=param, layout=Layout(flex='0 1 auto', width='10%')) b = BoundedFloatText(value=0, min=1e-10, layout=Layout(flex='0 1 auto', width='10%'), font_weight='bold') a = FloatText(value=2 * value, layout=Layout(flex='0 1 auto', width='10%')) f = FloatSlider(value=value, min=b.value, max=a.value, step=np.abs(a.value - b.value) * 0.01, layout=Layout(flex='1 1 auto', width='60%')) l = FloatText(value=f.value, layout=Layout(flex='0 1 auto', width='10%'), disabled=True) link((f, 'value'), (l, 'value')) def on_min_change(change): if f.max > change['new']: f.min = change['new'] f.step = np.abs(f.max - f.min) * 0.01 def on_max_change(change): if f.min < change['new']: f.max = change['new'] f.step = np.abs(f.max - f.min) * 0.01 def on_param_change(change): self.params[self._method][param] = change['new'] self.replot_peaks() b.observe(on_min_change, names='value') f.observe(on_param_change, names='value') a.observe(on_max_change, names='value') children = (p, l, b, f, a) elif isinstance(value, int): from ipywidgets import IntSlider, IntText, BoundedIntText, \ Label from traitlets import link p = Label(value=param, layout=Layout(flex='0 1 auto', width='10%')) b = BoundedIntText(value=0, min=1e-10, layout=Layout(flex='0 1 auto', width='10%'), font_weight='bold') a = IntText(value=2 * value, layout=Layout(flex='0 1 auto', width='10%')) f = IntSlider(value=value, min=b.value, max=a.value, step=1, layout=Layout(flex='1 1 auto', width='60%')) l = IntText(value=f.value, layout=Layout(flex='0 1 auto', width='10%'), disabled=True) link((f, 'value'), (l, 'value')) def on_min_change(change): if f.max > change['new']: f.min = change['new'] f.step = 1 def on_max_change(change): if f.min < change['new']: f.max = change['new'] f.step = 1 def on_param_change(change): self.params[self._method][param] = change['new'] self.replot_peaks() b.observe(on_min_change, names='value') f.observe(on_param_change, names='value') a.observe(on_max_change, names='value') children = (p, l, b, f, a) container = HBox(children) return container
def display_palette_for_models(self): """Display visual controls for color palettes applied to models""" def set_colormap(model_id, colormap_name, shading_mode): material_ids = self._be.get_material_ids(model_id)['ids'] nb_materials = len(material_ids) palette = sns.color_palette(colormap_name, nb_materials) self._be.set_materials_from_palette( model_ids=[model_id], material_ids=material_ids, palette=palette, specular_exponent=specular_exponent_slider.value, shading_mode=shading_mode, opacity=opacity_slider.value, refraction_index=refraction_index_slider.value, reflection_index=reflection_index_slider.value, glossiness=glossiness_slider.value, user_parameter=user_param_slider.value, emission=emission_slider.value, chameleon_mode=chameleon_combobox.index) self._client.set_renderer(accumulation=True) # Models model_names = list() for model in self._client.scene.models: model_names.append(model['name']) model_combobox = Select(options=model_names, description='Models:', disabled=False) # Shading modes shading_combobox = Select(options=SHADING_MODES, description='Shading:', disabled=False) # Colors palette_combobox = Select(options=COLOR_MAPS, description='Palette:', disabled=False) # Chameleon modes chameleon_combobox = Select(options=CHAMELEON_MODES, description='Chameleon:', disabled=False) # Events def update_materials_from_palette(value): """Update materials when palette is modified""" set_colormap(self._client.scene.models[model_combobox.index]['id'], value['new'], shading_combobox.index) def update_materials_from_shading_modes(_): """Update materials when shading is modified""" set_colormap(self._client.scene.models[model_combobox.index]['id'], palette_combobox.value, shading_combobox.index) def update_materials_from_chameleon_modes(_): """Update materials when chameleon mode is modified""" set_colormap(self._client.scene.models[model_combobox.index]['id'], palette_combobox.value, shading_combobox.index) shading_combobox.observe(update_materials_from_shading_modes, 'value') palette_combobox.observe(update_materials_from_palette, 'value') chameleon_combobox.observe(update_materials_from_chameleon_modes, 'value') horizontal_box_list = HBox( [model_combobox, shading_combobox, palette_combobox]) opacity_slider = FloatSlider(description='Opacity', min=0, max=1, value=1) opacity_slider.observe(update_materials_from_shading_modes) refraction_index_slider = FloatSlider(description='Refraction', min=1, max=5, value=1) refraction_index_slider.observe(update_materials_from_shading_modes) reflection_index_slider = FloatSlider(description='Reflection', min=0, max=1, value=0) reflection_index_slider.observe(update_materials_from_shading_modes) glossiness_slider = FloatSlider(description='Glossiness', min=0, max=1, value=1) glossiness_slider.observe(update_materials_from_shading_modes) specular_exponent_slider = FloatSlider(description='Specular exponent', min=1, max=100, value=1) specular_exponent_slider.observe(update_materials_from_shading_modes) user_param_slider = FloatSlider(description='User param', min=0, max=100, value=1) user_param_slider.observe(update_materials_from_shading_modes) emission_slider = FloatSlider(description='Emission', min=0, max=100, value=0) emission_slider.observe(update_materials_from_shading_modes) cast_simulation_checkbox = Checkbox(description='Simulation', value=False) cast_simulation_checkbox.observe(update_materials_from_shading_modes) horizontal_box_detail1 = HBox( [opacity_slider, refraction_index_slider, reflection_index_slider]) horizontal_box_detail2 = HBox( [glossiness_slider, specular_exponent_slider, user_param_slider]) horizontal_box_detail3 = HBox( [emission_slider, cast_simulation_checkbox, chameleon_combobox]) vertical_box = VBox([ horizontal_box_list, horizontal_box_detail1, horizontal_box_detail2, horizontal_box_detail3 ], layout=DEFAULT_GRID_LAYOUT) display(vertical_box)
class NGLDisplay: """Structure display class Provides basic structure/trajectory display in the notebook and optional gui which can be used to enhance its usability. It is also possible to extend the functionality of the particular instance of the viewer by adding further widgets manipulating the structure. """ def __init__(self, atoms, xsize=500, ysize=500): import nglview from ipywidgets import Dropdown, FloatSlider, IntSlider, HBox, VBox self.atoms = atoms if isinstance(atoms[0], Atoms): # Assume this is a trajectory or struct list self.view = nglview.show_asetraj(atoms) self.frm = IntSlider(value=0, min=0, max=len(atoms) - 1) self.frm.observe(self._update_frame) self.struct = atoms[0] else: # Assume this is just a single structure self.view = nglview.show_ase(atoms) self.struct = atoms self.frm = None self.colors = {} self.view._remote_call('setSize', target='Widget', args=['%dpx' % (xsize,), '%dpx' % (ysize,)]) self.view.add_unitcell() self.view.add_spacefill() self.view.camera = 'orthographic' self.view.update_spacefill(radiusType='covalent', scale=0.7) self.view.center() self.asel = Dropdown(options=['All'] + list(set(self.struct.get_chemical_symbols())), value='All', description='Show') self.rad = FloatSlider(value=0.8, min=0.0, max=1.5, step=0.01, description='Ball size') self.asel.observe(self._select_atom) self.rad.observe(self._update_repr) wdg = [self.asel, self.rad] if self.frm: wdg.append(self.frm) self.gui = HBox([self.view, VBox(wdg)]) # Make useful shortcuts for the user of the class self.gui.view = self.view self.gui.control_box = self.gui.children[1] self.gui.custom_colors = self.custom_colors def _update_repr(self, chg=None): self.view.update_spacefill(radiusType='covalent', scale=self.rad.value) def _update_frame(self, chg=None): self.view.frame = self.frm.value return def _select_atom(self, chg=None): sel = self.asel.value self.view.remove_spacefill() for e in set(self.struct.get_chemical_symbols()): if (sel == 'All' or e == sel): if e in self.colors: self.view.add_spacefill(selection='#' + e, color=self.colors[e]) else: self.view.add_spacefill(selection='#' + e) self._update_repr() def custom_colors(self, clr=None): """ Define custom colors for some atoms. Pass a dictionary of the form {'Fe':'red', 'Au':'yellow'} to the function. To reset the map to default call the method without parameters. """ if clr: self.colors = clr else: self.colors = {} self._select_atom()
def interactive_differences_with_probability( data, beta_time=-0.5, beta_cost=-0.8, likelihood=False, loglikelihood=False, correct=False, beta_bus=None, ): from plotly import graph_objects as go from ipywidgets import FloatSlider, HBox, Layout likelihood |= bool(loglikelihood) choose_car = data.query("choice == 'car'") choose_bus = data.query("choice == 'bus'") space = np.linspace(-11, 11) grid = np.meshgrid(space, space) b_cost = FloatSlider( value=beta_cost, max=2.5, min=-2.5, step=0.01, orientation="vertical", description=r"$\beta$ Cost", ) b_time = FloatSlider( value=beta_time, max=2.5, min=-2.5, step=0.01, orientation="vertical", description=r"$\beta$ Time", ) b_bus = FloatSlider( value=beta_bus or 0, max=2.5, min=-2.5, step=0.01, orientation="vertical", description=r"$\beta$ Bus", ) field = 1 / (1 + np.exp(grid[0] * b_time.value + grid[1] * b_cost.value + b_bus.value)) fig = go.FigureWidget([ go.Contour( name="Probability of Car", z=field, x=space, y=space, colorbar=dict( thickness=25, thicknessmode="pixels", len=0.65, lenmode="fraction", outlinewidth=0, yanchor="bottom", y=0, title="Probability of Car", titleside="right", ), colorscale="bluered_r", contours=dict( start=0, end=1.0, size=0.1, ), ), go.Scatter( x=choose_bus.timediff, y=choose_bus.costdiff, mode="markers", name="bus", marker_line_width=2, marker_line_color="white", marker_size=10, marker_color="red", ), go.Scatter( x=choose_car.timediff, y=choose_car.costdiff, mode="markers", name="car", marker_line_width=2, marker_line_color="white", marker_size=10, marker_symbol="square", marker_color="blue", ), ]) fig.update_xaxes( range=[-11, 11], showline=True, ) fig.update_yaxes( range=[-11, 11], showline=True, ) fig.layout.margin = {"b": 5, "t": 5, "l": 5, "r": 5} fig.layout.width = 450 fig.layout.height = 250 fig.update_layout( xaxis_title="Car Time Advantage", yaxis_title="Car Cost Advantage", legend_title="Chosen", font=dict(size=11, ), ) if likelihood: fig.update_layout( title=dict( text="Likelihood = ", y=0.98, x=0.5, xref="paper", xanchor="center", yanchor="top", font_size=11, ), margin={ "b": 5, "t": 20, "l": 5, "r": 5 }, ) def refield(*args): with fig.batch_update(): field = 1 / (1 + np.exp(grid[0] * b_time.value + grid[1] * b_cost.value + b_bus.value)) fig.data[0].z = field if correct or likelihood: likely2 = 1 / ( 1 + np.exp(fig.data[2].x * b_time.value + fig.data[2].y * b_cost.value + b_bus.value)) likely1 = 1 - ( 1 / (1 + np.exp(fig.data[1].x * b_time.value + fig.data[1].y * b_cost.value + b_bus.value))) if correct: fig.data[2].marker.symbol = np.where( likely2 > 0.5, np.where(likely2 > 0.95, "square-dot", "square"), "x", ) fig.data[1].marker.symbol = np.where( likely1 > 0.5, np.where(likely1 > 0.95, "circle-dot", "circle"), "x", ) if likelihood: fig.data[2].marker.size = np.clip(15 * likely2, 3, 15) fig.data[1].marker.size = np.clip(15 * likely1, 3, 15) if loglikelihood: fig.update_layout( title_text= f"Log Likelihood = {np.log(likely1).sum()+np.log(likely2).sum():.4g}", ) else: fig.update_layout( title_text= f"Likelihood = {likely1.prod()*likely2.prod():.4g}", ) refield() b_cost.observe(refield) b_time.observe(refield) b_bus.observe(refield) if beta_bus is None: parts = [fig, b_cost, b_time] else: parts = [fig, b_cost, b_time, b_bus] return HBox(parts, layout=Layout(display="flex", align_items="center"))
def interactive_differences_on_field(data, beta_time=-0.5, beta_cost=-0.8): from plotly import graph_objects as go from ipywidgets import FloatSlider, HBox, Layout choose_car = data.query("choice == 'car'") choose_bus = data.query("choice == 'bus'") space = np.linspace(-11, 11) grid = np.meshgrid(space, space) b_cost = FloatSlider( value=beta_cost, max=1.0, min=-1.0, step=0.05, orientation="vertical", description=r"$\beta$ Cost", ) b_time = FloatSlider( value=beta_time, max=1.0, min=-1.0, step=0.05, orientation="vertical", description=r"$\beta$ Time", ) field = grid[0] * -b_time.value + grid[1] * -b_cost.value fig = go.FigureWidget([ go.Contour( name="Net Utility of Car", z=field, x=space, y=space, colorbar=dict( thickness=25, thicknessmode="pixels", len=0.65, lenmode="fraction", outlinewidth=0, yanchor="bottom", y=0, title="Net Utility of Car", titleside="right", ), colorscale="rdbu", ), go.Scatter( x=choose_bus.timediff, y=choose_bus.costdiff, mode="markers", name="bus", marker_line_width=2, marker_line_color="white", marker_size=10, marker_color="red", ), go.Scatter( x=choose_car.timediff, y=choose_car.costdiff, mode="markers", name="car", marker_line_width=2, marker_line_color="white", marker_size=10, marker_symbol="square", marker_color="blue", ), ]) fig.update_xaxes( range=[-11, 11], showline=True, ) fig.update_yaxes( range=[-11, 11], showline=True, ) fig.layout.margin = {"b": 5, "t": 5, "l": 5, "r": 5} fig.layout.width = 450 fig.layout.height = 250 fig.update_layout( xaxis_title="Car Time Advantage", yaxis_title="Car Cost Advantage", legend_title="Chosen", font=dict(size=11, ), ) def refield(*args): field = grid[0] * -b_time.value + grid[1] * -b_cost.value fig.data[0].z = field b_cost.observe(refield) b_time.observe(refield) return HBox([fig, b_cost, b_time], layout=Layout(display="flex", align_items="center"))
l = Label("update every text box every {}".format(s.value)) def update_text(change=None): t.value = str(float(s.value)**2) def push_update_text(): while True: time.sleep(s.value) t.value = str(datetime.datetime.now()) l.value = "update every text box every {}".format(s.value) s.observe(update_text, names='value') update_text() h_box = HBox([l, s]) vbox = VBox([h_box, t]) thread = Thread(target=push_update_text) thread.daemon = True thread.start() @app.route('/') def index(): return render_template('example2.html', widget=vbox, widgets=vbox) if __name__ == "__main__":
class NGLDisplay: """Structure display class Provides basic structure/trajectory display in the notebook and optional gui which can be used to enhance its usability. It is also possible to extend the functionality of the particular instance of the viewer by adding further widgets manipulating the structure. """ def __init__(self, atoms, xsize=500, ysize=500): import nglview import nglview.color from ipywidgets import Dropdown, FloatSlider, IntSlider, HBox, VBox self.atoms = atoms if isinstance(atoms[0], Atoms): # Assume this is a trajectory or struct list self.view = nglview.show_asetraj(atoms) self.frm = IntSlider(value=0, min=0, max=len(atoms) - 1) self.frm.observe(self._update_frame) self.struct = atoms[0] else: # Assume this is just a single structure self.view = nglview.show_ase(atoms) self.struct = atoms self.frm = None self.colors = {} self.view._remote_call('setSize', target='Widget', args=['%dpx' % (xsize, ), '%dpx' % (ysize, )]) self.view.add_unitcell() self.view.add_spacefill() self.view.remove_ball_and_stick() self.view.camera = 'orthographic' self.view.parameters = {"clipDist": 0} self.view.center() self.asel = Dropdown(options=['All'] + list(set(self.struct.get_chemical_symbols())), value='All', description='Show') self.csel = Dropdown(options=nglview.color.COLOR_SCHEMES, value=' ', description='Color scheme') self.rad = FloatSlider(value=0.8, min=0.0, max=1.5, step=0.01, description='Ball size') self.asel.observe(self._select_atom) self.csel.observe(self._update_repr) self.rad.observe(self._update_repr) self.view.update_spacefill(radiusType='covalent', scale=0.8, color_scheme=self.csel.value, color_scale='rainbow') wdg = [self.asel, self.csel, self.rad] if self.frm: wdg.append(self.frm) self.gui = HBox([self.view, VBox(wdg)]) # Make useful shortcuts for the user of the class self.gui.view = self.view self.gui.control_box = self.gui.children[1] self.gui.custom_colors = self.custom_colors def _update_repr(self, chg=None): self.view.update_spacefill(radiusType='covalent', scale=self.rad.value, color_scheme=self.csel.value, color_scale='rainbow') def _update_frame(self, chg=None): self.view.frame = self.frm.value return def _select_atom(self, chg=None): sel = self.asel.value self.view.remove_spacefill() for e in set(self.struct.get_chemical_symbols()): if (sel == 'All' or e == sel): if e in self.colors: self.view.add_spacefill(selection='#' + e, color=self.colors[e]) else: self.view.add_spacefill(selection='#' + e) self._update_repr() def custom_colors(self, clr=None): """ Define custom colors for some atoms. Pass a dictionary of the form {'Fe':'red', 'Au':'yellow'} to the function. To reset the map to default call the method without parameters. """ if clr: self.colors = clr else: self.colors = {} self._select_atom()
def MakeJointSlidersThatPublishOnCallback(plant, publishing_system, root_context, my_callback=None, lower_limit=-10., upper_limit=10., resolution=0.01, length=200, continuous_update=True, floating_base=True): """ Creates an ipywidget slider for each joint in the plant. Unlike the JointSliders System, we do not expect this to be used in a Simulator. It simply updates the context and calls Publish directly from the slider callback. Args: plant: A MultibodyPlant. publishing_system: The System whos Publish method will be called. Can be the entire Diagram, but can also be a subsystem. root_context: A mutable root Context of the Diagram containing both the ``plant`` and the ``publishing_system``; we will extract the subcontext's using `GetMyContextFromRoot`. my_callback: An optional additional callback function that will be called once immediately and again whenever the sliders are moved, using ``my_callback(plant_context)``. This can be useful, e.g. for outputting text that prints the current end-effector Jacobian, or for showing a rendered image from a camera. lower_limit: A scalar or vector of length robot.num_velocities(). The lower limit of the slider will be the maximum value of this number and any limit specified in the Joint. upper_limit: A scalar or vector of length robot.num_velocities(). The upper limit of the slider will be the minimum value of this number and any limit specified in the Joint. resolution: A scalar or vector of length robot.num_velocities() that specifies the step argument of the FloatSlider. length: The length of the sliders, which will be passed as a string to the CSS width field and can be any valid CSS entry (e.g. 100, 100px). continuous_update: The continuous_update field for the FloatSliders. The default ``True`` means that this method will publish/ callback as the sliders are dragged. ``False`` means that the publish/callback will only happen once the user finishes dragging the slider. floating_base: If True, then include XYZ/RPY sliders corresponding to the pose of any floating joints. Returns: A list of the slider widget objects that are created. Note: Some publishers (like MeshcatVisualizer) use an initialization event to "load" the geometry. You should call that *before* calling this method (e.g. with `meshcat.load()`). """ def _broadcast(x, num): x = np.asarray(x) assert len(x.shape) <= 1 return np.array(x) * np.ones(num) # Use num_velocities instead of num_positions because we want 6 per # floating base, not 7. lower_limit = _broadcast(lower_limit, plant.num_velocities()) upper_limit = _broadcast(upper_limit, plant.num_velocities()) resolution = _broadcast(resolution, plant.num_velocities()) publishing_context = publishing_system.GetMyContextFromRoot(root_context) plant_context = plant.GetMyContextFromRoot(root_context) positions = plant.GetPositions(plant_context) # Publish once immediately. publishing_system.Publish(publishing_context) if my_callback: my_callback(plant_context) def _slider_callback(change, index, body=None): if body: # Then it's a floating base pose = plant.GetFreeBodyPose(plant_context, body) vector_pose = np.concatenate( (RollPitchYaw(pose.rotation()).vector(), pose.translation())) vector_pose[index] = change.new plant.SetFreeBodyPose( plant_context, body, RigidTransform(RollPitchYaw(vector_pose[:3]), vector_pose[3:])) else: positions[index] = change.new plant.SetPositions(plant_context, positions) publishing_system.Publish(publishing_context) if my_callback: my_callback(plant_context) slider_widgets = [] for i in range(plant.num_joints()): joint = plant.get_joint(JointIndex(i)) low = joint.position_lower_limits() upp = joint.position_upper_limits() for j in range(joint.num_positions()): index = joint.position_start() + j description = joint.name() if joint.num_positions() > 1: description += f"[{j}]" slider = FloatSlider(value=positions[index], min=max(low[j], lower_limit[index]), max=min(upp[j], upper_limit[index]), step=resolution[index], continuous_update=continuous_update, description=description, style={'description_width': 'initial'}, layout=Layout(width=f"'{length}'")) slider.observe(partial(_slider_callback, index=index), names='value') display(slider) slider_widgets.append(slider) if floating_base: for bi in plant.GetFloatingBaseBodies(): body = plant.get_body(bi) index = body.floating_velocities_start() - plant.num_positions() pose = plant.GetFreeBodyPose(plant_context, body) vector_pose = np.concatenate( (RollPitchYaw(pose.rotation()).vector(), pose.translation())) relative_index = 0 for dof in ["roll", "pitch", "yaw", "x", "y", "z"]: slider = FloatSlider(min=lower_limit[index], max=upper_limit[index], value=vector_pose[relative_index], step=resolution[index], continuous_update=continuous_update, description=f"{body.name()}_{dof}", layout=Layout(width='90%')) slider.observe(partial(_slider_callback, index=relative_index, body=body), names='value') display(slider) slider_widgets.append(slider) index += 1 relative_index += 1 return slider_widgets
def interact_distributions(): from ipywidgets import FloatSlider, Label, GridBox, interactive, Layout, VBox, \ HBox, Checkbox, IntSlider, Box, Button, widgets fx0 = FloatSlider(value=2, description=" ", min=.5, max=4., step=.2, continuous_update=False, layout=Layout(width='auto', grid_area='vx0')) fy0 = FloatSlider(value=3, description=" ", min=.5, max=4., step=.2, continuous_update=False, layout=Layout(width='auto', grid_area='vy0')) fs0 = FloatSlider(value=1, description=" ", min=.1, max=4., step=.2, continuous_update=False, layout=Layout(width='auto', grid_area='vs0')) fd0 = FloatSlider(value=.9, description=" ", min=-2., max=2., step=.1, continuous_update=False, layout=Layout(width='auto', grid_area='vd0')) fx1 = FloatSlider(value=2, description=" ", min=.5, max=4., step=.2, continuous_update=False, layout=Layout(width='auto', grid_area='vx1')) fy1 = FloatSlider(value=2, description=" ", min=.5, max=4., step=.2, continuous_update=False, layout=Layout(width='auto', grid_area='vy1')) fs1 = FloatSlider(value=1, description=" ", min=.1, max=4., step=.2, continuous_update=False, layout=Layout(width='auto', grid_area='vs1')) fd1 = FloatSlider(value=-.3, description=" ", min=-2., max=2., step=.1, continuous_update=False, layout=Layout(width='auto', grid_area='vd1')) fdummy = FloatSlider(value=2, description=" ", min=1, max=4, step=1) l = lambda s, p, w="auto": Label(s, layout=Layout(width=w, grid_area=p)) bay = Checkbox(value=False, description='show NATURAL frontiers', disabled=False, indent=False, layout=Layout(width="80%")) resample = Button(description="resample data points") from IPython.core.display import clear_output def resample_onclick(_): global do_resample_points do_resample_points = True tmp = fdummy.value fdummy.value = tmp + (1 if tmp < 3 else -1) do_resample_points = False resample.on_click(resample_onclick) w = interactive(display_distributions, x0=fx0, y0=fy0, s0=fs0, d0=fd0, x1=fx1, y1=fy1, s1=fs1, d1=fd1, show_bayesians=bay, dummy=fdummy, continuous_update=False) w.children[-1].layout = Layout(width='auto', grid_area='fig') controls = Box([bay, resample], layout=Layout(grid_area="ctr", display="flex-flow", justify_content="flex-start", flex_flow="column", align_items='flex-start')) gb = GridBox(children=[ fx0, fy0, fs0, fd0, fx1, fy1, fs1, fd1, l("AMERICAN TRILOBYTE", "h0"), l("AFRICAN TRILOBYTE", "h1"), l("size", "lx0"), l("weight", "ly0"), l("spread", "ls0"), l("tilt", "ld0"), l("size", "lx1"), l("weight", "ly1"), l("spread", "ls1"), l("tilt", "ld1"), controls ], layout=Layout( width='100%', grid_template_rows='auto auto auto auto auto auto auto', grid_template_columns='5% 30% 5% 30% 30%', grid_template_areas=''' "h0 h0 h1 h1 ." "lx0 vx0 lx1 vx1 ." "ly0 vy0 ly1 vy1 ctr" "ls0 vs0 ls1 vs1 ctr" "ld0 vd0 ld1 vd1 ctr" "fig fig fig fig fig" ''')) def limit_fd0(*args): fd0.max = fs0.value + fs0.value * 0.5 fd0.min = -fs0.value * 0.5 def limit_fd1(*args): fd1.max = fs1.value + fs1.value * 0.5 fd1.min = -fs1.value * 0.5 fs0.observe(limit_fd0, "value") fd0.observe(limit_fd0, "value") fs1.observe(limit_fd1, "value") fd1.observe(limit_fd1, "value") w.children[0].value = 1 widget1 = VBox([gb, w.children[-1]]) display(widget1) return fx0, fy0, fs0, fd0, fx1, fy1, fs1, fd1
def display_focal_distance(self): """Display visual controls for setting camera focal distance""" x_slider = FloatSlider(description='X', min=0, max=1, value=0.5) y_slider = FloatSlider(description='Y', min=0, max=1, value=0.5) a_slider = FloatSlider(description='Aperture', min=0, max=1, value=0) f_slider = FloatSlider(description='Focus radius', min=0, max=1, value=0.01) d_slider = FloatSlider(description='Focus distance', min=0, max=10000, value=0, disabled=True) f_button = Button(description='Refresh') class Updated: """Class object embedding communication with remote server""" def __init__(self, client): self._client = client self._widget_value = None self._x = 0.5 self._y = 0.5 self._aperture = 0.0 self._focus_radius = 0.01 self._focus_distance = 0.0 self._nb_focus_points = 20 def _update_camera(self): self._focus_distance = 0.0 for _ in range(self._nb_focus_points): self._focus_distance = self._focus_distance + self._get_focal_distance( (self._x + (random.random() - 0.5) * self._focus_radius, self._y + (random.random() - 0.5) * self._focus_radius)) self._focus_distance = self._focus_distance / self._nb_focus_points params = self._client.BioExplorerPerspectiveCameraParams() params.focus_distance = self._focus_distance params.aperture_radius = self._aperture params.enable_clipping_planes = True d_slider.value = self._focus_distance self._client.set_camera_params(params) def update(self): """Update all settings of the camera""" self._update_camera() def update_focus_radius(self, val_dict) -> None: """Update camera focus radius""" self._widget_value = val_dict['new'] self._focus_radius = self._widget_value self._update_camera() def update_aperture(self, val_dict) -> None: """Update camera aperture""" self._widget_value = val_dict['new'] self._aperture = self._widget_value self._update_camera() def update_x(self, val_dict) -> None: """Update camera normalized horizontal focus location""" self._widget_value = val_dict['new'] self._x = self._widget_value self._update_camera() def update_y(self, val_dict) -> None: """Update camera normalized vertical focus location""" self._widget_value = val_dict['new'] self._y = self._widget_value self._update_camera() def _get_focal_distance(self, coordinates=(0.5, 0.5)): """ Return the focal distance for the specified normalized coordinates in the image :param list coordinates: Coordinates in the image :return: The focal distance :rtype: float """ target = self._client.inspect(array=coordinates)['position'] origin = self._client.camera.position.data vector = [0, 0, 0] for k in range(3): vector[k] = float(target[k]) - float(origin[k]) return math.sqrt(vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2]) update_class = Updated(self._client) def update_x(value): update_class.update_x(value) def update_y(value): update_class.update_y(value) def update_aperture(value): update_class.update_aperture(value) def update_focus_radius(value): update_class.update_focus_radius(value) def update_button(_): update_class.update() x_slider.observe(update_x, 'value') y_slider.observe(update_y, 'value') a_slider.observe(update_aperture, 'value') f_slider.observe(update_focus_radius, 'value') f_button.on_click(update_button) position_box = VBox([x_slider, y_slider, f_button]) parameters_box = VBox([a_slider, f_slider, d_slider]) horizontal_box = HBox([position_box, parameters_box], layout=DEFAULT_GRID_LAYOUT) display(horizontal_box)
fig.canvas.header_visible = False fig.canvas.layout.min_height = '400px' plt.title('Plotting of linear graph'.format(slider.value)) x = lin['campaign_id'] y = lin['campaign_count'] lines = plt.plot(x,y) def update_lines(change): plt.title('Plotting of linear graph'.format(change.new)) lines[0].set_data(x, y) fig.canvas.draw() fig.canvas.flush_events() slider.observe(update_lines, names='value') AppLayout( center=fig.canvas, footer=slider, pane_heights=[0, 6, 1] ) # In[ ]: # In[31]:
def draw_roaming_ui(): global iter_slider, reset_button, color_it_button, juliabrot_button, canvases global drawing, uly_select, ulx_select, color_list, picker1, picker2, bump_ud_slider, hue_slider, sat_slider, val_slider global lry_select, lrx_select, color_it, modulo_slider, picker3, bump_lr_slider, zoom_slider, save_button # This establishes the size of the preview gui drawing = False color_it = True uly_select = 0 ulx_select = 0 lry_select = jgrid.settings.sizeY lrx_select = jgrid.settings.sizeX canvases = MultiCanvas(3, width=jgrid.settings.sizeX * 2.5, height=jgrid.settings.sizeY + 75) canvases[drawing_layer].font = '25px serif' canvases[drawing_layer].fill_style = '#aaaaaa' canvases[drawing_layer].line_width = 3 canvases[interaction_layer].font = '35px serif' canvases[interaction_layer].fill_style = '#eee800' canvases[interaction_layer].stroke_style = '#ffffff' canvases[interaction_layer].line_width = 3 iter_slider = FloatLogSlider(description='Iterations:', base=10, value=jgrid.settings.max_iterations, min=1, max=7, step=.01, continuous_update=False) iter_slider.observe(handler=iter_slider_handler, names='value') max_lr_bump = jgrid.settings.sizeX max_ud_bump = jgrid.settings.sizeY bump_ud_slider = IntSlider(description='Bump UD pix:', value=1, min=0, max=max_ud_bump, step=1, continuous_update=False) bump_lr_slider = IntSlider(description='Bump LR pix:', value=1, min=0, max=max_lr_bump, step=1, continuous_update=False) zoom_slider = FloatSlider(description='Zoom:', value=2.0, min=0.0, max=1000.0, step=.001, continuous_update=False) #zoom_slider.observe(handler=zoom_button_handler, names='value') hue_slider = FloatSlider(description='Hue :', value=jgrid.settings.hue, min=0.0, max=1.0, step=.001, continuous_update=False) sat_slider = FloatSlider(description='Sat:', value=jgrid.settings.sat, min=0.0, max=1.0, step=.01, continuous_update=False) val_slider = FloatSlider(description='Val:', value=jgrid.settings.val, min=0.0, max=1.0, step=.02, continuous_update=False) hue_slider.observe(handler=hue_slider_handler, names='value') sat_slider.observe(handler=sat_slider_handler, names='value') val_slider.observe(handler=val_slider_handler, names='value') modulo_slider = IntSlider(description='Modulo:', value=jgrid.settings.modulo, min=1, max=1000000, step=1, continuous_update=False) modulo_slider.observe(handler=modulo_slider_handler, names='value') canvases[interaction_layer].on_mouse_down(on_mouse_down) canvases[interaction_layer].on_mouse_move(on_mouse_move) reset_button = Button(description='Zoom', disabled=False, button_style='', tooltip='Click to use zoom slider setting for zoom', icon='') reset_button.on_click(zoom_button_handler) save_button = Button(description='Save', disabled=False, button_style='', tooltip='Click to save as JSON settings file', icon='') save_button.on_click(save_button_handler) color_it_button = Button(description='Color/BW', disabled=False, button_style='', tooltip='Click for BW or Color', icon='') color_it_button.on_click(color_button_handler) juliabrot_button = Button(description='JM Mode', disabled=False, button_style='', tooltip='Click for Julia or Mandelbrot', icon='') juliabrot_button.on_click(juliabrot_button_handler) undo_button = Button(description='Undo', disabled=False, button_style='', tooltip='Click to revert to last view', icon='') undo_button.on_click(undo_button_handler) bleft_button = Button(description='Bump L', disabled=False, button_style='', tooltip='Click to nudge left num bump LR pixels', icon='') bleft_button.on_click(bleft_button_handler) bright_button = Button(description='Bump R', disabled=False, button_style='', tooltip='Click to nudge right num bump LR pixels', icon='') bright_button.on_click(bright_button_handler) bup_button = Button(description='Bump U', disabled=False, button_style='', tooltip='Click to nudge up num bump UD pixels', icon='') bup_button.on_click(bup_button_handler) bdown_button = Button(description='Bump D', disabled=False, button_style='', tooltip='Click to nudge down bump UD pixels', icon='') bdown_button.on_click(bdown_button_handler) picker1 = ColorPicker(description='M Color:', value=jgrid.settings.m_color) #picker2 = ColorPicker(description='Color 1:', value='#fff800') #picker3 = ColorPicker(description='Color 2:', value='#fff800') picker1.observe(color_picker1_handler, names='value') #picker2.observe(color_picker2_handler, names='value') #picker3.observe(color_picker3_handler, names='value') color_list = Dropdown(disabled=False, options=[('Rainbow', 1), ('Classic', 2), ('Log', 3), ('RGB Max Iter', 4), ('Rainbow 2', 5)], value=jgrid.settings.color_mode, description='Color Mode:', tooltip='Select built-in coloring options') color_list.observe(color_select_handler, names='value') draw_fractal(canvases, jgrid.tile_list) display_info(canvases, jgrid) return AppLayout(center=canvases, header=HBox((iter_slider, bump_ud_slider, bump_lr_slider, zoom_slider)), right_sidebar=VBox( (picker1, color_list, hue_slider, sat_slider, val_slider, modulo_slider)), footer=HBox( (bleft_button, bright_button, bup_button, bdown_button, color_it_button, juliabrot_button, reset_button, undo_button, save_button)))
def _get_value_widget(obj, index=None): wdict = {} widget_bounds = _interactive_slider_bounds(obj, index=index) thismin = FloatText( value=widget_bounds['min'], description='min', layout=Layout(flex='0 1 auto', width='auto'), ) thismax = FloatText( value=widget_bounds['max'], description='max', layout=Layout(flex='0 1 auto', width='auto'), ) current_value = obj.value if index is None else obj.value[index] if index is None: current_name = obj.name else: current_name = '{}'.format(index) widget = FloatSlider(value=current_value, min=thismin.value, max=thismax.value, step=widget_bounds['step'], description=current_name, layout=Layout(flex='1 1 auto', width='auto')) def on_min_change(change): if widget.max > change['new']: widget.min = change['new'] widget.step = np.abs(widget.max - widget.min) * 0.001 def on_max_change(change): if widget.min < change['new']: widget.max = change['new'] widget.step = np.abs(widget.max - widget.min) * 0.001 thismin.observe(on_min_change, names='value') thismax.observe(on_max_change, names='value') # We store the link in the widget so that they are not deleted by the # garbage collector thismin._link = dlink((obj, "bmin"), (thismin, "value")) thismax._link = dlink((obj, "bmax"), (thismax, "value")) if index is not None: # value is tuple, expanding def _interactive_tuple_update(value): """Callback function for the widgets, to update the value """ obj.value = obj.value[:index] + (value['new'],) +\ obj.value[index + 1:] widget.observe(_interactive_tuple_update, names='value') else: link((obj, "value"), (widget, "value")) container = HBox((thismin, widget, thismax)) wdict["value"] = widget wdict["min"] = thismin wdict["max"] = thismax return { "widget": container, "wdict": wdict, }
class NasaGibsViewer(PanelObject): def __init__(self,ptype='time',*args,**kwargs): self.title = 'NASA GIBS Image Viewer' PanelObject.__init__(self,*args, **kwargs) self.url = 'https://gibs.earthdata.nasa.gov/wmts/epsg4326/best/wmts.cgi' self.plat = 24.42 self.plon = 54.43 self.height = 1.0 self.width = 1.0 def getCP(self): self.setLabel() self.imgDate = datetime.now() self.selectVar ='MODIS_Terra_SurfaceReflectance_Bands143' self.dateSW = DatePicker(description='Date', layout=Layout(width='220px'), value = self.imgDate, disabled=False) self.vardict = {'TerraRGB':'MODIS_Terra_SurfaceReflectance_Bands143', 'AquaRGB' :'MODIS_Aqua_SurfaceReflectance_Bands143', 'AquaLST Day':'MODIS_Aqua_Land_Surface_Temp_Day'} self.varSW = Dropdown(options=['TerraRGB','AquaRGB','AquaLST Day'], value='TerraRGB', layout=Layout(width='220px'), description='Var:', disabled=False ) self.latSW = Text(description='Lat:',disabled=False,value='24.42',layout=Layout(width='220px')) self.lonSW = Text(description='Lon:',disabled=False,value='54.43',layout=Layout(width='220px')) self.plotPB =Button(description='Plot',disabled=False,layout={'width':'auto','border':'3px outset'}) self.latRS = FloatSlider( value=5, min=2.0, max=15, step=0.2, description='Width', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='.1f', ) self.lonRS = FloatSlider( value=5.0, min=2.0, max=15.0, step=0.2, description='Height:', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='.1f' ) self.inpUSR.children+= (HBox([ VBox([self.plotPB]), VBox([self.dateSW,self.latSW,self.lonSW]), VBox([self.latRS,self.lonRS,self.varSW ]) ], layout={'overflow':'visible'} ),) self.dateSW.observe(self.dateSWCB) self.varSW.observe(self.varSWCB,names='value') self.latSW.observe(self.latSWCB,names='value') self.lonSW.observe(self.lonSWCB,names='value') self.latRS.observe(self.latRSCB,names='value') self.lonRS.observe(self.lonRSCB,names='value') self.plotPB.on_click(self.plotGIBS) return self.cp def dateSWCB(self,change): if change['type'] == 'change': self.imgDate = self.dateSW.value def varSWCB(self,b): self.selectVar = self.vardict[self.varSW.value] def latSWCB(self,change): self.plat = float(self.latSW.value) def lonSWCB(self,change): self.plon = float(self.lonSW.value) def latRSCB(self,change): self.height = self.latRS.value*0.5 def lonRSCB(self,change): self.width = self.lonRS.value*0.5 def plotGIBS(self,b): self.lat1 = self.plat - self.height self.lat2 = self.plat + self.height self.lon1 = self.plon - self.width self.lon2 = self.plon + self.width with self.out_cp: plt.ioff() layer = self.selectVar date_str = '{}-{}-{}'.format(self.imgDate.strftime('%Y'), self.imgDate.strftime('%m'), self.imgDate.strftime('%d') ) print(layer,date_str) fig = plt.figure(figsize=(8, 8)) ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree()) ax.add_wmts(self.url, layer,wmts_kwargs={'time': date_str}) self.out_cp.clear_output() ax.set_extent([self.lon1, self.lon2, self.lat1, self.lat2], crs=ccrs.PlateCarree()) ax.coastlines(resolution='50m', color='yellow') plt.plot(self.plon, self.plat, marker='o', color='red', markersize=15, alpha=1.0) plt.show()
def _tensor_folder(self): alo = Layout(width='70px') rlo = Layout(width='220px') scale = FloatSlider(max=10.0, step=0.001, readout=True, value=1.0) xs = [Text(layout=alo,disabled=True), Text(layout=alo,disabled=True), Text(layout=alo,disabled=True)] ys = [Text(layout=alo,disabled=True), Text(layout=alo,disabled=True), Text(layout=alo,disabled=True)] zs = [Text(layout=alo,disabled=True), Text(layout=alo,disabled=True), Text(layout=alo,disabled=True)] cs = [Text(layout=alo,disabled=True), Text(layout=alo,disabled=True), Text(layout=alo,disabled=True)] cidx = HBox([Text(disabled=True,description='Atom Index',layout=rlo)]) xbox = HBox(xs, layout=rlo) ybox = HBox(ys, layout=rlo) zbox = HBox(zs, layout=rlo) cbox = HBox(cs, layout=rlo) tens = Button(description=' Tensor', icon='bank') tensor_cont = VBox([xbox,ybox,zbox]) tensorIndex = Dropdown(options=[0],value=0,description='Tensor') # sceneIndex = Dropdown(options=[0],value=0,description='Scene') ten_label = Label(value="Change selected tensor:") sel_label = Label(value="Selected tensor in gray frame") cod_label = Label(value="Center of selected tensor: (x,y,z)") tensor = [] self.coords = [] def _changeTensor(tensor, tdx): carts = ['x','y','z'] for i,bra in enumerate(carts): for j,ket in enumerate(carts): tensor_cont.children[i].children[j].disabled=False tensor_cont.children[i].children[j].value = \ str(tensor[0][tdx][bra+ket]) tensor_cont.children[i].children[j].disabled=True adx = tensor[0][tdx]['atom'] cidx.children[0].value = str(adx) cbox.children[0].value = str(self.coords[0][int(adx)]) cbox.children[1].value = str(self.coords[1][int(adx)]) cbox.children[2].value = str(self.coords[2][int(adx)]) # scale.value = tensor[0][tdx]['scale'] def _tens(c): for scn in self.active(): scn.tens = not scn.tens self.coords = self._filter_coords() # sceneIndex.options = [x for x in range(len(self.active()))] # sceneIndex.value = sceneIndex.options[0] tensor = self.active()[0].tensor_d tensorIndex.options = [x for x in range(len(tensor[0]))] tensorIndex.value = tensorIndex.options[0] tdx = tensorIndex.value _changeTensor(tensor, tdx) def _scale(c): for scn in self.active(): scn.scale = c.new # tdx = tensorIndex.value # tensor = self.active()[0].tensor_d # tensor[0][tdx]['scale'] = c.new def _idx(c): for scn in self.active(): scn.tidx = c.new tensor = self.active()[0].tensor_d tdx = c.new _changeTensor(tensor, tdx) # def _sdx(c): # tensor = self.active()[sceneIndex.value].tensor_d # tensorIndex.options = [x for x in range(len(tensor[0]))] # tensorIndex.value = tensorIndex.options[0] # tdx = tensorIndex.value # _changeTensor(tensor, tdx) tens.on_click(_tens) scale.observe(_scale, names='value') tensorIndex.observe(_idx, names='value') # sceneIndex.observe(_sdx, names='value') content = _ListDict([ ('scale', scale), ('ten', ten_label), # ('sdx', sceneIndex), ('tdx', tensorIndex), ('tensor', tensor_cont), ('sel', sel_label), ('cidx', cidx), ('center', cod_label), ('coord', cbox)]) return Folder(tens, content)
class Dashboard(VBox): """ Build the dashboard for Jupyter widgets. Requires running in a notebook/jupyterlab. """ def __init__(self, net, width="95%", height="550px", play_rate=0.5): self._ignore_layer_updates = False self.player = _Player(self, play_rate) self.player.start() self.net = net r = random.randint(1, 1000000) self.class_id = "picture-dashboard-%s-%s" % (self.net.name, r) self._width = width self._height = height ## Global widgets: style = {"description_width": "initial"} self.feature_columns = IntText(description="Detail columns:", value=self.net.config["dashboard.features.columns"], min=0, max=1024, style=style) self.feature_scale = FloatText(description="Detail scale:", value=self.net.config["dashboard.features.scale"], min=0.1, max=10, style=style) self.feature_columns.observe(self.regenerate, names='value') self.feature_scale.observe(self.regenerate, names='value') ## Hack to center SVG as justify-content is broken: self.net_svg = HTML(value="""<p style="text-align:center">%s</p>""" % ("",), layout=Layout( width=self._width, overflow_x='auto', overflow_y="auto", justify_content="center")) # Make controls first: self.output = Output() controls = self.make_controls() config = self.make_config() super().__init__([config, controls, self.net_svg, self.output]) def propagate(self, inputs): """ Propagate inputs through the dashboard view of the network. """ if dynamic_pictures_check(): return self.net.propagate(inputs, class_id=self.class_id, update_pictures=True) else: self.regenerate(inputs=input) def goto(self, position): if len(self.net.dataset.inputs) == 0 or len(self.net.dataset.targets) == 0: return if self.control_select.value == "Train": length = len(self.net.dataset.train_inputs) elif self.control_select.value == "Test": length = len(self.net.dataset.test_inputs) #### Position it: if position == "begin": self.control_slider.value = 0 elif position == "end": self.control_slider.value = length - 1 elif position == "prev": if self.control_slider.value - 1 < 0: self.control_slider.value = length - 1 # wrap around else: self.control_slider.value = max(self.control_slider.value - 1, 0) elif position == "next": if self.control_slider.value + 1 > length - 1: self.control_slider.value = 0 # wrap around else: self.control_slider.value = min(self.control_slider.value + 1, length - 1) self.position_text.value = self.control_slider.value def change_select(self, change=None): """ """ self.update_control_slider(change) self.regenerate() def update_control_slider(self, change=None): self.net.config["dashboard.dataset"] = self.control_select.value if len(self.net.dataset.inputs) == 0 or len(self.net.dataset.targets) == 0: self.total_text.value = "of 0" self.control_slider.value = 0 self.position_text.value = 0 self.control_slider.disabled = True self.position_text.disabled = True for child in self.control_buttons.children: if not hasattr(child, "icon") or child.icon != "refresh": child.disabled = True return if self.control_select.value == "Test": self.total_text.value = "of %s" % len(self.net.dataset.test_inputs) minmax = (0, max(len(self.net.dataset.test_inputs) - 1, 0)) if minmax[0] <= self.control_slider.value <= minmax[1]: pass # ok else: self.control_slider.value = 0 self.control_slider.min = minmax[0] self.control_slider.max = minmax[1] if len(self.net.dataset.test_inputs) == 0: disabled = True else: disabled = False elif self.control_select.value == "Train": self.total_text.value = "of %s" % len(self.net.dataset.train_inputs) minmax = (0, max(len(self.net.dataset.train_inputs) - 1, 0)) if minmax[0] <= self.control_slider.value <= minmax[1]: pass # ok else: self.control_slider.value = 0 self.control_slider.min = minmax[0] self.control_slider.max = minmax[1] if len(self.net.dataset.train_inputs) == 0: disabled = True else: disabled = False self.control_slider.disabled = disabled self.position_text.disbaled = disabled self.position_text.value = self.control_slider.value for child in self.control_buttons.children: if not hasattr(child, "icon") or child.icon != "refresh": child.disabled = disabled def update_zoom_slider(self, change): if change["name"] == "value": self.net.config["svg_scale"] = self.zoom_slider.value self.regenerate() def update_position_text(self, change): # {'name': 'value', 'old': 2, 'new': 3, 'owner': IntText(value=3, layout=Layout(width='100%')), 'type': 'change'} self.control_slider.value = change["new"] def get_current_input(self): if self.control_select.value == "Train" and len(self.net.dataset.train_targets) > 0: return self.net.dataset.train_inputs[self.control_slider.value] elif self.control_select.value == "Test" and len(self.net.dataset.test_targets) > 0: return self.net.dataset.test_inputs[self.control_slider.value] def get_current_targets(self): if self.control_select.value == "Train" and len(self.net.dataset.train_targets) > 0: return self.net.dataset.train_targets[self.control_slider.value] elif self.control_select.value == "Test" and len(self.net.dataset.test_targets) > 0: return self.net.dataset.test_targets[self.control_slider.value] def update_slider_control(self, change): if len(self.net.dataset.inputs) == 0 or len(self.net.dataset.targets) == 0: self.total_text.value = "of 0" return if change["name"] == "value": self.position_text.value = self.control_slider.value if self.control_select.value == "Train" and len(self.net.dataset.train_targets) > 0: self.total_text.value = "of %s" % len(self.net.dataset.train_inputs) if self.net.model is None: return if not dynamic_pictures_check(): self.regenerate(inputs=self.net.dataset.train_inputs[self.control_slider.value], targets=self.net.dataset.train_targets[self.control_slider.value]) return output = self.net.propagate(self.net.dataset.train_inputs[self.control_slider.value], class_id=self.class_id, update_pictures=True) if self.feature_bank.value in self.net.layer_dict.keys(): self.net.propagate_to_features(self.feature_bank.value, self.net.dataset.train_inputs[self.control_slider.value], cols=self.feature_columns.value, scale=self.feature_scale.value, html=False) if self.net.config["show_targets"]: if len(self.net.output_bank_order) == 1: ## FIXME: use minmax of output bank self.net.display_component([self.net.dataset.train_targets[self.control_slider.value]], "targets", class_id=self.class_id, minmax=(-1, 1)) else: self.net.display_component(self.net.dataset.train_targets[self.control_slider.value], "targets", class_id=self.class_id, minmax=(-1, 1)) if self.net.config["show_errors"]: ## minmax is error if len(self.net.output_bank_order) == 1: errors = np.array(output) - np.array(self.net.dataset.train_targets[self.control_slider.value]) self.net.display_component([errors.tolist()], "errors", class_id=self.class_id, minmax=(-1, 1)) else: errors = [] for bank in range(len(self.net.output_bank_order)): errors.append( np.array(output[bank]) - np.array(self.net.dataset.train_targets[self.control_slider.value][bank])) self.net.display_component(errors, "errors", class_id=self.class_id, minmax=(-1, 1)) elif self.control_select.value == "Test" and len(self.net.dataset.test_targets) > 0: self.total_text.value = "of %s" % len(self.net.dataset.test_inputs) if self.net.model is None: return if not dynamic_pictures_check(): self.regenerate(inputs=self.net.dataset.test_inputs[self.control_slider.value], targets=self.net.dataset.test_targets[self.control_slider.value]) return output = self.net.propagate(self.net.dataset.test_inputs[self.control_slider.value], class_id=self.class_id, update_pictures=True) if self.feature_bank.value in self.net.layer_dict.keys(): self.net.propagate_to_features(self.feature_bank.value, self.net.dataset.test_inputs[self.control_slider.value], cols=self.feature_columns.value, scale=self.feature_scale.value, html=False) if self.net.config["show_targets"]: ## FIXME: use minmax of output bank self.net.display_component([self.net.dataset.test_targets[self.control_slider.value]], "targets", class_id=self.class_id, minmax=(-1, 1)) if self.net.config["show_errors"]: ## minmax is error if len(self.net.output_bank_order) == 1: errors = np.array(output) - np.array(self.net.dataset.test_targets[self.control_slider.value]) self.net.display_component([errors.tolist()], "errors", class_id=self.class_id, minmax=(-1, 1)) else: errors = [] for bank in range(len(self.net.output_bank_order)): errors.append( np.array(output[bank]) - np.array(self.net.dataset.test_targets[self.control_slider.value][bank])) self.net.display_component(errors, "errors", class_id=self.class_id, minmax=(-1, 1)) def toggle_play(self, button): ## toggle if self.button_play.description == "Play": self.button_play.description = "Stop" self.button_play.icon = "pause" self.player.resume() else: self.button_play.description = "Play" self.button_play.icon = "play" self.player.pause() def prop_one(self, button=None): self.update_slider_control({"name": "value"}) def regenerate(self, button=None, inputs=None, targets=None): ## Protection when deleting object on shutdown: if isinstance(button, dict) and 'new' in button and button['new'] is None: return ## Update the config: self.net.config["dashboard.features.bank"] = self.feature_bank.value self.net.config["dashboard.features.columns"] = self.feature_columns.value self.net.config["dashboard.features.scale"] = self.feature_scale.value inputs = inputs if inputs is not None else self.get_current_input() targets = targets if targets is not None else self.get_current_targets() features = None if self.feature_bank.value in self.net.layer_dict.keys() and inputs is not None: if self.net.model is not None: features = self.net.propagate_to_features(self.feature_bank.value, inputs, cols=self.feature_columns.value, scale=self.feature_scale.value, display=False) svg = """<p style="text-align:center">%s</p>""" % (self.net.to_svg( inputs=inputs, targets=targets, class_id=self.class_id, highlights={self.feature_bank.value: { "border_color": "orange", "border_width": 30, }})) if inputs is not None and features is not None: html_horizontal = """ <table align="center" style="width: 100%%;"> <tr> <td valign="top" style="width: 50%%;">%s</td> <td valign="top" align="center" style="width: 50%%;"><p style="text-align:center"><b>%s</b></p>%s</td> </tr> </table>""" html_vertical = """ <table align="center" style="width: 100%%;"> <tr> <td valign="top">%s</td> </tr> <tr> <td valign="top" align="center"><p style="text-align:center"><b>%s</b></p>%s</td> </tr> </table>""" self.net_svg.value = (html_vertical if self.net.config["svg_rotate"] else html_horizontal) % ( svg, "%s details" % self.feature_bank.value, features) else: self.net_svg.value = svg def make_colormap_image(self, colormap_name): from .layers import Layer if not colormap_name: colormap_name = get_colormap() layer = Layer("Colormap", 100) minmax = layer.get_act_minmax() image = layer.make_image(np.arange(minmax[0], minmax[1], .01), colormap_name, {"pixels_per_unit": 1, "svg_rotate": self.net.config["svg_rotate"]}).resize((300, 25)) return image def set_attr(self, obj, attr, value): if value not in [{}, None]: ## value is None when shutting down if isinstance(value, dict): value = value["value"] if isinstance(obj, dict): obj[attr] = value else: setattr(obj, attr, value) ## was crashing on Widgets.__del__, if get_ipython() no longer existed self.regenerate() def make_controls(self): layout = Layout(width='100%', height="100%") button_begin = Button(icon="fast-backward", layout=layout) button_prev = Button(icon="backward", layout=layout) button_next = Button(icon="forward", layout=layout) button_end = Button(icon="fast-forward", layout=layout) #button_prop = Button(description="Propagate", layout=Layout(width='100%')) #button_train = Button(description="Train", layout=Layout(width='100%')) self.button_play = Button(icon="play", description="Play", layout=layout) step_down = Button(icon="sort-down", layout=Layout(width="95%", height="100%")) step_up = Button(icon="sort-up", layout=Layout(width="95%", height="100%")) up_down = HBox([step_down, step_up], layout=Layout(width="100%", height="100%")) refresh_button = Button(icon="refresh", layout=Layout(width="25%", height="100%")) self.position_text = IntText(value=0, layout=layout) self.control_buttons = HBox([ button_begin, button_prev, #button_train, self.position_text, button_next, button_end, self.button_play, up_down, refresh_button ], layout=Layout(width='100%', height="100%")) length = (len(self.net.dataset.train_inputs) - 1) if len(self.net.dataset.train_inputs) > 0 else 0 self.control_slider = IntSlider(description="Dataset index", continuous_update=False, min=0, max=max(length, 0), value=0, layout=Layout(width='100%')) if self.net.config["dashboard.dataset"] == "Train": length = len(self.net.dataset.train_inputs) else: length = len(self.net.dataset.test_inputs) self.total_text = Label(value="of %s" % length, layout=Layout(width="100px")) self.zoom_slider = FloatSlider(description="Zoom", continuous_update=False, min=0, max=1.0, style={"description_width": 'initial'}, layout=Layout(width="65%"), value=self.net.config["svg_scale"] if self.net.config["svg_scale"] is not None else 0.5) ## Hook them up: button_begin.on_click(lambda button: self.goto("begin")) button_end.on_click(lambda button: self.goto("end")) button_next.on_click(lambda button: self.goto("next")) button_prev.on_click(lambda button: self.goto("prev")) self.button_play.on_click(self.toggle_play) self.control_slider.observe(self.update_slider_control, names='value') refresh_button.on_click(lambda widget: (self.update_control_slider(), self.output.clear_output(), self.regenerate())) step_down.on_click(lambda widget: self.move_step("down")) step_up.on_click(lambda widget: self.move_step("up")) self.zoom_slider.observe(self.update_zoom_slider, names='value') self.position_text.observe(self.update_position_text, names='value') # Put them together: controls = VBox([HBox([self.control_slider, self.total_text], layout=Layout(height="40px")), self.control_buttons], layout=Layout(width='100%')) #net_page = VBox([control, self.net_svg], layout=Layout(width='95%')) controls.on_displayed(lambda widget: self.regenerate()) return controls def move_step(self, direction): """ Move the layer stepper up/down through network """ options = [""] + [layer.name for layer in self.net.layers] index = options.index(self.feature_bank.value) if direction == "up": new_index = (index + 1) % len(options) else: ## down new_index = (index - 1) % len(options) self.feature_bank.value = options[new_index] self.regenerate() def make_config(self): layout = Layout() style = {"description_width": "initial"} checkbox1 = Checkbox(description="Show Targets", value=self.net.config["show_targets"], layout=layout, style=style) checkbox1.observe(lambda change: self.set_attr(self.net.config, "show_targets", change["new"]), names='value') checkbox2 = Checkbox(description="Errors", value=self.net.config["show_errors"], layout=layout, style=style) checkbox2.observe(lambda change: self.set_attr(self.net.config, "show_errors", change["new"]), names='value') hspace = IntText(value=self.net.config["hspace"], description="Horizontal space between banks:", style=style, layout=layout) hspace.observe(lambda change: self.set_attr(self.net.config, "hspace", change["new"]), names='value') vspace = IntText(value=self.net.config["vspace"], description="Vertical space between layers:", style=style, layout=layout) vspace.observe(lambda change: self.set_attr(self.net.config, "vspace", change["new"]), names='value') self.feature_bank = Select(description="Details:", value=self.net.config["dashboard.features.bank"], options=[""] + [layer.name for layer in self.net.layers], rows=1) self.feature_bank.observe(self.regenerate, names='value') self.control_select = Select( options=['Test', 'Train'], value=self.net.config["dashboard.dataset"], description='Dataset:', rows=1 ) self.control_select.observe(self.change_select, names='value') column1 = [self.control_select, self.zoom_slider, hspace, vspace, HBox([checkbox1, checkbox2]), self.feature_bank, self.feature_columns, self.feature_scale ] ## Make layer selectable, and update-able: column2 = [] layer = self.net.layers[-1] self.layer_select = Select(description="Layer:", value=layer.name, options=[layer.name for layer in self.net.layers], rows=1) self.layer_select.observe(self.update_layer_selection, names='value') column2.append(self.layer_select) self.layer_visible_checkbox = Checkbox(description="Visible", value=layer.visible, layout=layout) self.layer_visible_checkbox.observe(self.update_layer, names='value') column2.append(self.layer_visible_checkbox) self.layer_colormap = Select(description="Colormap:", options=[""] + AVAILABLE_COLORMAPS, value=layer.colormap if layer.colormap is not None else "", layout=layout, rows=1) self.layer_colormap_image = HTML(value="""<img src="%s"/>""" % self.net._image_to_uri(self.make_colormap_image(layer.colormap))) self.layer_colormap.observe(self.update_layer, names='value') column2.append(self.layer_colormap) column2.append(self.layer_colormap_image) ## get dynamic minmax; if you change it it will set it in layer as override: minmax = layer.get_act_minmax() self.layer_mindim = FloatText(description="Leftmost color maps to:", value=minmax[0], style=style) self.layer_maxdim = FloatText(description="Rightmost color maps to:", value=minmax[1], style=style) self.layer_mindim.observe(self.update_layer, names='value') self.layer_maxdim.observe(self.update_layer, names='value') column2.append(self.layer_mindim) column2.append(self.layer_maxdim) output_shape = layer.get_output_shape() self.layer_feature = IntText(value=layer.feature, description="Feature to show:", style=style) self.svg_rotate = Checkbox(description="Rotate", value=layer.visible, layout=layout) self.layer_feature.observe(self.update_layer, names='value') column2.append(self.layer_feature) self.svg_rotate = Checkbox(description="Rotate network", value=self.net.config["svg_rotate"], style={"description_width": 'initial'}, layout=Layout(width="52%")) self.svg_rotate.observe(lambda change: self.set_attr(self.net.config, "svg_rotate", change["new"]), names='value') self.save_config_button = Button(icon="save", layout=Layout(width="10%")) self.save_config_button.on_click(self.save_config) column2.append(HBox([self.svg_rotate, self.save_config_button])) config_children = HBox([VBox(column1, layout=Layout(width="100%")), VBox(column2, layout=Layout(width="100%"))]) accordion = Accordion(children=[config_children]) accordion.set_title(0, self.net.name) accordion.selected_index = None return accordion def save_config(self, widget=None): self.net.save_config() def update_layer(self, change): """ Update the layer object, and redisplay. """ if self._ignore_layer_updates: return ## The rest indicates a change to a display variable. ## We need to save the value in the layer, and regenerate ## the display. # Get the layer: layer = self.net[self.layer_select.value] # Save the changed value in the layer: layer.feature = self.layer_feature.value layer.visible = self.layer_visible_checkbox.value ## These three, dealing with colors of activations, ## can be done with a prop_one(): if "color" in change["owner"].description.lower(): ## Matches: Colormap, lefmost color, rightmost color ## overriding dynamic minmax! layer.minmax = (self.layer_mindim.value, self.layer_maxdim.value) layer.minmax = (self.layer_mindim.value, self.layer_maxdim.value) layer.colormap = self.layer_colormap.value if self.layer_colormap.value else None self.layer_colormap_image.value = """<img src="%s"/>""" % self.net._image_to_uri(self.make_colormap_image(layer.colormap)) self.prop_one() else: self.regenerate() def update_layer_selection(self, change): """ Just update the widgets; don't redraw anything. """ ## No need to redisplay anything self._ignore_layer_updates = True ## First, get the new layer selected: layer = self.net[self.layer_select.value] ## Now, let's update all of the values without updating: self.layer_visible_checkbox.value = layer.visible self.layer_colormap.value = layer.colormap if layer.colormap != "" else "" self.layer_colormap_image.value = """<img src="%s"/>""" % self.net._image_to_uri(self.make_colormap_image(layer.colormap)) minmax = layer.get_act_minmax() self.layer_mindim.value = minmax[0] self.layer_maxdim.value = minmax[1] self.layer_feature.value = layer.feature self._ignore_layer_updates = False
p4.value = softmax(3) def on_value_change(change): if change.owner == s1: values[0] = change.new if change.owner == s2: values[1] = change.new if change.owner == s3: values[2] = change.new if change.owner == s4: values[3] = change.new set_values() s1.observe(on_value_change, names='value') s2.observe(on_value_change, names='value') s3.observe(on_value_change, names='value') s4.observe(on_value_change, names='value') def main(): set_values() left_box = VBox([s1, s2, s3, s4], layout=Layout(width='50%')) middle_box = VBox([p1, p2, p3, p4]) right_box = VBox([l1, l2, l3, l4]) return HBox([left_box, middle_box, right_box]) if __name__ == "__main__": main()
value_1 = A_1.value * np.sin(w_1.value * t) value_2 = A_2.value * np.cos(w_2.value * t) else: value_1 = A_1.value * np.sin(2 * math.pi * f_1.value*t - Phi_1.value * np.pi/180) value_2 = A_2.value * np.cos(2 * math.pi * f_2.value*t - Phi_2.value * np.pi/180) return value_1, value_2 # parameters t = np.arange(0.0, 10.0, 0.001) y_1, y_2 = calculate() # figure data = [go.Scatter(y = y_1, x = t, opacity = 0.75, name = 'Trace 1'), go.Scatter(y = y_2, x = t, opacity = 0.75, name = 'Trace 2')] layout = {'yaxis': {'range': [-2, 2], 'title': "CALCULATED VALUE"}, 'xaxis': {'range': [0, 10], 'title': "TIME"}} fig = go.FigureWidget(data, layout) def recalculate(value): global fig fig.data[0].y, fig.data[1].y = calculate() A_1.observe(recalculate, 'value') A_2.observe(recalculate, 'value') f_1.observe(recalculate, 'value') f_2.observe(recalculate, 'value') w_1.observe(recalculate, 'value') w_2.observe(recalculate, 'value') Phi_1.observe(recalculate, 'value') Phi_2.observe(recalculate, 'value') use.observe(recalculate, 'value') fig
def MakeJointSlidersThatPublishOnCallback(plant, publishing_system, root_context, my_callback=None, lower_limit=-10., upper_limit=10., resolution=0.01, length=200, continuous_update=True): """ Creates an ipywidget slider for each joint in the plant. Unlike the JointSliders System, we do not expect this to be used in a Simulator. It simply updates the context and calls Publish directly from the slider callback. Args: plant: A MultibodyPlant. publishing_system: The System whose Publish method will be called. Can be the entire Diagram, but can also be a subsystem. root_context: A mutable root Context of the Diagram containing both the ``plant`` and the ``publishing_system``; we will extract the subcontext's using `GetMyContextFromRoot`. my_callback: An optional additional callback function that will be called once immediately and again whenever the sliders are moved, using ``my_callback(plant_context)``. This can be useful, e.g. for outputting text that prints the current end-effector Jacobian, or for showing a rendered image from a camera. lower_limit: A scalar or vector of length robot.num_positions(). The lower limit of the slider will be the maximum value of this number and any limit specified in the Joint. upper_limit: A scalar or vector of length robot.num_positions(). The upper limit of the slider will be the minimum value of this number and any limit specified in the Joint. resolution: A scalar or vector of length robot.num_positions() that specifies the step argument of the FloatSlider. length: The length of the sliders, which will be passed as a string to the CSS width field and can be any valid CSS entry (e.g. 100, 100px). continuous_update: The continuous_update field for the FloatSliders. The default ``True`` means that this method will publish/ callback as the sliders are dragged. ``False`` means that the publish/callback will only happen once the user finishes dragging the slider. Returns: A list of the slider widget objects that are created. Note: Some publishers (like MeshcatVisualizer) use an initialization event to "load" the geometry. You should call that *before* calling this method (e.g. with `meshcat.load()`). """ def _broadcast(x, num): x = np.array(x) assert len(x.shape) <= 1 return np.array(x) * np.ones(num) lower_limit = _broadcast(lower_limit, plant.num_positions()) upper_limit = _broadcast(upper_limit, plant.num_positions()) resolution = _broadcast(resolution, plant.num_positions()) publishing_context = publishing_system.GetMyContextFromRoot(root_context) plant_context = plant.GetMyContextFromRoot(root_context) positions = plant.GetPositions(plant_context) # Publish once immediately. publishing_system.Publish(publishing_context) if my_callback: my_callback(plant_context) def _slider_callback(change, index): positions[index] = change.new plant.SetPositions(plant_context, positions) publishing_system.Publish(publishing_context) if my_callback: my_callback(plant_context) slider_widgets = [] slider_num = 0 for i in range(plant.num_joints()): joint = plant.get_joint(JointIndex(i)) low = joint.position_lower_limits() upp = joint.position_upper_limits() for j in range(joint.num_positions()): index = joint.position_start() + j description = joint.name() if joint.num_positions() > 1: description += f"[{j}]" slider = FloatSlider(value=positions[index], min=max(low[j], lower_limit[slider_num]), max=min(upp[j], upper_limit[slider_num]), step=resolution[slider_num], continuous_update=continuous_update, description=description, style={'description_width': 'initial'}, layout=Layout(width=f"'{length}'")) slider.observe(partial(_slider_callback, index=index), names='value') display(slider) slider_widgets.append(slider) slider_num += 1 return slider_widgets
def show_plot(): plt.close('all') plt.ioff() # load in the trace from glob import glob import os global df, trace_o, trace_n, title df = pd.read_csv('merged_data.csv') # read in the models fit_o = models.oocyte_model(df) fit_n = models.oocyte_model(df) # read in the traces trace_o = pm.load_trace('trace_o', fit_o) trace_n = pm.load_trace('trace_n', fit_n) fig, ax = plt.subplots(1, 1, figsize=(8, 6)) out = widgets.Output() #res_df = pd.read_pickle("res.pkl") def click(b): global o_obs, o_x, n_obs, n_x, df mask = df['i_ind'] == choice.value if (sum(mask) > 0): title_comp = df.loc[mask, 'ucode'].values[0].split('_') fig.suptitle("{}".format(title_comp[0])) ax.set_title("day {}.rep {}, str {}".format(*title_comp[1:])) Vmax_o = Vmax_o_slide.value ao = ao_slide.value to = to_slide.value Vmin_o = Vmin_o_slide.value Vmax_n = Vmax_n_slide.value a0 = a0_slide.value t0 = t0_slide.value a1 = a1_slide.value t1 = t1_slide.value Vmin_n = Vmin_n_slide.value #plt.figure(2) ax.clear() ax.plot(-o_x, o_obs, 'o', color='red') ax.plot(-n_x, n_obs, 'o', color='blue') if (True): x = np.linspace(-2, 16, num=100) ax.plot(-x, bu.rise_only(x, Vmax_o, to, ao, 1.0, Vmin_o), color='red') ax.plot(-x, bu.rise_and_fall(x, Vmax_n, t0, a0, 1.0, t1, a1, 1, Vmin_n), color='blue') ax.plot([-to, -to], [0, bu.rise_only(to, Vmax_o, to, ao, 1.0, Vmin_o)], ls='--', color='red', lw=1.5) ax.plot([-t0, -t0], [ 0, bu.rise_and_fall(t0, Vmax_n, t0, a0, 1.0, t1, a1, 1, Vmin_n) ], ls='--', color='blue', lw=1.5) ax.plot([-t1, -t1], [ 0, bu.rise_and_fall(t1, Vmax_n, t0, a0, 1.0, t1, a1, 1, Vmin_n) ], ls='--', color='blue', lw=1.5) ax.set_xticks(range(-14, 2, 2)) ax.set_ylim(0, 200) ax.axhline(Vmax_o, ls='--', color='red') ax.axvline(0, ls='--', color='grey', lw=1) [xmin, xmax] = ax.get_xlim() [ymin, ymax] = ax.get_ylim() ax.annotate(r'$t_o$', (to + 0.2, ymax - 10)) ax.annotate(r'$Vmax_{o}}$', (xmax - 2, Vmax_o + 10)) with out: clear_output(wait=True) display(ax.figure) #choice=Dropdown( # # options='cont_r1 cont_r2 cont_r3 caged_d04_r1 caged_d07_r1'.split(), # value='cont_r1', # description='Number:', # disabled=False, #) choice = widgets.IntText(value=0, min=0, max=len(df['i_ind'].unique()), step=1, description='Test:', disabled=False, continuous_update=False, readout=True, readout_format='d') Vmax_o_slide = FloatSlider(description=r'$V$max$_o$', value=150, min=0, max=300, continuous_update=False) Vmax_o_slide.observe(click, names='value') Vmin_o_slide = FloatSlider(description=r'$V$min$_o$', value=15, min=0, max=30, continuous_update=False) Vmin_o_slide.observe(click, names='value') ao_slide = FloatSlider(description=r'$a_o$', value=0.2, min=0., max=0.75, continuous_update=False) ao_slide.observe(click, names='value') to_slide = FloatSlider(description=r'$t_o$', value=1, min=-2, max=6, continuous_update=False) to_slide.observe(click, names='value') Vmax_n_slide = FloatSlider(description=r'$V$max$_{n}$', value=150, min=0, max=300, continuous_update=False) Vmax_n_slide.observe(click, names='value') Vmin_n_slide = FloatSlider(description=r'$V$min$_n$', value=15, min=0, max=30, continuous_update=False) Vmin_n_slide.observe(click, names='value') a0_slide = FloatSlider(description=r'$a_0$', value=0.4, min=0.0, max=1.5, continuous_update=False) a0_slide.observe(click, names='value') t0_slide = FloatSlider(description=r'$t_0$', value=0, min=-4, max=8, continuous_update=False) t0_slide.observe(click, names='value') a1_slide = FloatSlider(description=r'$a_1$', value=0.4, min=0.0, max=8, continuous_update=False) a1_slide.observe(click, names='value') t1_slide = FloatSlider(description=r'$t_1$', value=0.5, min=-2, max=6, continuous_update=False) t1_slide.observe(click, names='value') def choice_selected(b): global o_obs, o_x, n_obs, n_x, df, trace_o, trace_n if (False): name = choice.value df = pd.read_csv("results_analyse/{}.csv".format(name)) o_obs = dh.unpack_results(df, 1, 'o', volume=False) o_x = np.arange(len(o_obs)) n_obs = dh.unpack_results(df, 1, 'n', volume=False) n_x = np.arange(len(n_obs)) else: iexp = choice.value mask = df['i_ind'] == iexp if (sum(mask) > 0): o_obs = df.loc[mask, 'Oc_size'] o_x = df.loc[mask, 'pos'] n_obs = df.loc[mask, 'Ns_size'] n_x = o_x vars_o = 'Vmax_o,t_o,a_o,Vmin_o'.split(',') vars_n = 'Vmax_n t0 a0 t1 a1 Vmin_n'.split() theta_o = np.median(bu.pull_post(trace_o, vars_o, iexp), axis=0) theta_n = np.median(bu.pull_post(trace_n, vars_n, iexp), axis=0) for slide, val in zip( [Vmax_o_slide, to_slide, ao_slide, Vmin_o_slide], theta_o): slide.value = val for slide, val in zip([ Vmax_n_slide, t0_slide, a0_slide, t1_slide, a1_slide, Vmin_n_slide ], theta_n): slide.value = val #rown = "{}_1".format(name) #Vmax_n_slide.value= res_df.loc[rown,('Vmax_n','m')] #a0_slide.value= res_df.loc[rown,('a0','m')] #t0_slide.value= -res_df.loc[rown,('t0','m')] #a1_slide.value= res_df.loc[rown,('a1','m')] #t1_slide.value= -res_df.loc[rown,('t1','m')] #Vmax_o_slide.value= res_df.loc[rown,('Vmax_o','m')] #ao_slide.value= res_df.loc[rown,('a_o','m')] #to_slide.value= -res_df.loc[rown,('t_o','m')] click(None) #f(Vmax_slide.value, a0_slide.value, t0_slide.value) return choice_selected(None) choice.observe(choice_selected) #display(VBox([mslide,cslide])) oocyte_params = widgets.VBox([ Label(value="Oocyte"), Vmax_o_slide, ao_slide, to_slide, Vmin_o_slide ]) nurse_params = widgets.VBox( [Vmax_n_slide, a0_slide, t0_slide, a1_slide, t1_slide, Vmin_n_slide]) box = widgets.VBox( [choice, widgets.HBox([oocyte_params, nurse_params]), out]) display(box) click(None)
def __init__(self, position: str = "bottomleft", attr_name: str = "style", kind: str = "stroke", orientation: str = "horizontal", transparent: bool = False, a_map: Map = None, layer: Layer = None, place_control: bool = True): """Add a widget to the map that allows styling some given layer. At the moment only the stroke color, opacity and weight can be changed using a color picker and sliders. Dash array might follow later. :param m: The map object to which to add a styling widget. :param layer: The layer object which is to be styled. :param attr_name: The layer's attribute name storing the style object. This is usually one of: "style", "hover_style", and "point_style" :param kind: The kind of style, either "stroke" or "fill". :param orientation: The orientation of the UI elements, either "horizontal" (default) or "vertical". :param transparent: A flag to indicate if the widget background should be transparent (default: ``False``). :param position: The map corner where this widget will be placed. TODO: The UI elements should reflect changes to the layer triggered by others. """ assert kind in ["stroke", "fill"] assert orientation in ["horizontal", "vertical"] def restyle(change): if change["type"] != "change": return owner = change["owner"] style_copy = copy.copy(getattr(layer, attr_name)) attr_map = { p: "color" if kind == "stroke" else "fillColor", o: "opacity" if kind == "stroke" else "fillOpacity", w: "weight" } if owner in [p, o, w]: style_copy[attr_map[owner]] = owner.value setattr(layer, attr_name, style_copy) def close(button): a_map.remove_control(wc) attr = getattr(layer, attr_name) style = getattr(layer, "style") b = ToggleButton(description="Stroke", value=True, tooltip="Stroke or not?") dummy = ToggleButton(value=not b.value) b.layout.width = "80px" name = "color" if kind == "stroke" else "fillColor" p = ColorPicker(value=attr.get(name, style.get(name, "#3885ff"))) p.layout.width = "100px" name = "opacity" if kind == "stroke" else "fillOpacity" o = FloatSlider(min=0, max=1, value=attr.get(name, style.get(name, 0.5))) o.layout.width = "200px" w = IntSlider(min=0, max=50, value=attr.get("weight", style.get("weight", 5))) w.layout.width = "200px" layout = Layout(width="28px", height="28px", padding="0px 0px 0px 4px") q = Button(tooltip="Close", icon="close", button_style="info", layout=layout) for el in [p, o, w] if kind == "stroke" else [p, o]: link((dummy, "value"), (el, "disabled")) p.observe(restyle) o.observe(restyle) if kind == "stroke": w.observe(restyle) else: w.disabled = True q.on_click(close) desc = HTML(f"{kind} {attr_name}") if orientation == "horizontal": self.widget = HBox([desc, p, w, o, q]) elif orientation == "vertical": self.widget = VBox([HBox([desc, q]), p, w, o]) wc = WidgetControl(widget=self.widget, position=position, transparent_bg=transparent) a_map.add_control(wc)
def display_focal_distance(self, with_preview=False): """Display visual controls for setting camera focal distance""" x_slider = FloatSlider(description='X', min=0, max=1, value=0.5) y_slider = FloatSlider(description='Y', min=0, max=1, value=0.5) a_slider = FloatSlider(description='Aperture', min=0, max=1, value=0) f_slider = FloatSlider(description='Focus radius', min=0, max=1, value=0.01) d_slider = FloatSlider(description='Focus distance', min=0, max=10000, value=0, disabled=True) f_button = Button(description='Refresh') f_target = Button(description='Target') class Updated: """Class object embedding communication with remote server""" def __init__(self, client, with_preview): self._client = client self._widget_value = None self._x = 0.5 self._y = 0.5 self._aperture = 0.0 self._focus_radius = 0.01 self._focus_distance = 0.0 self._nb_focus_points = 20 self._snapshot = None self._with_preview = with_preview def _update_camera(self): self._focus_distance = 1e6 for _ in range(self._nb_focus_points): self._focus_distance = min( self._focus_distance, self._get_focal_distance( (self._x + random.random() * self._focus_radius, self._y + random.random() * self._focus_radius))) params = self._client.BioExplorerPerspectiveCameraParams() params.focus_distance = self._focus_distance params.aperture_radius = self._aperture params.enable_clipping_planes = True d_slider.value = self._focus_distance self._client.set_camera_params(params) if self._with_preview: self._get_preview(False) def update(self): """Update all settings of the camera""" self._update_camera() if self._with_preview: self._get_preview(True) def update_target(self): """Update camera target""" inspection = self._client.inspect([self._x, self._y]) if inspection['hit']: position = inspection['position'] self._client.set_camera(target=position) self._client.set_renderer() def update_focus_radius(self, val_dict) -> None: """Update camera focus radius""" self._widget_value = val_dict['new'] self._focus_radius = self._widget_value self._update_camera() def update_aperture(self, val_dict) -> None: """Update camera aperture""" self._widget_value = val_dict['new'] self._aperture = self._widget_value self._update_camera() def update_x(self, val_dict) -> None: """Update camera normalized horizontal focus location""" self._widget_value = val_dict['new'] self._x = self._widget_value self._update_camera() def update_y(self, val_dict) -> None: """Update camera normalized vertical focus location""" self._widget_value = val_dict['new'] self._y = self._widget_value self._update_camera() def _get_focal_distance(self, coordinates=(0.5, 0.5)): """ Return the focal distance for the specified normalized coordinates in the image :param list coordinates: Coordinates in the image :return: The focal distance :rtype: float """ target = self._client.inspect(array=coordinates)['position'] origin = self._client.camera.position.data vector = [0, 0, 0] for k in range(3): vector[k] = float(target[k]) - float(origin[k]) return math.sqrt(vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2]) def _get_preview(self, update_image): viewport = self._client.get_application_parameters( )['viewport'] ratio = viewport[1] / viewport[0] size = [256, int(256.0 * ratio)] if update_image: self._snapshot = self._client.image(size=size, samples_per_pixel=4) if self._snapshot is None: return x = self._x * size[0] y = (1.0 - self._y) * size[1] rx = self._focus_radius * size[0] ry = self._focus_radius * size[1] byte_io = io.BytesIO() snapshot = self._snapshot.copy() draw = ImageDraw.Draw(snapshot) draw.ellipse((x - rx, y - ry, x + rx, y + ry)) draw.ellipse((x - 5, y - 5, x + 5, y + 5)) snapshot.save(byte_io, 'png') preview.width = size[0] preview.height = size[1] preview.value = byte_io.getvalue() update_class = Updated(self._client, with_preview) def update_x(value): update_class.update_x(value) def update_y(value): update_class.update_y(value) def update_aperture(value): update_class.update_aperture(value) def update_focus_radius(value): update_class.update_focus_radius(value) def update_button(_): update_class.update() def update_target(_): update_class.update_target() x_slider.observe(update_x, 'value') y_slider.observe(update_y, 'value') a_slider.observe(update_aperture, 'value') f_slider.observe(update_focus_radius, 'value') f_button.on_click(update_button) f_target.on_click(update_target) position_box = VBox([x_slider, y_slider, f_button, f_target]) parameters_box = VBox([a_slider, f_slider, d_slider]) horizontal_box = HBox([position_box, parameters_box], layout=DEFAULT_GRID_LAYOUT) display(horizontal_box) if with_preview: byte_io = io.BytesIO() preview = Image(value=byte_io.getvalue(), format='png', width=1, height=1) display(preview)