def update(self): scores = self.pred_scores[self.vis_image_index] im = self.dataset[self.vis_image_index][0] # fastai Image object _, sort_order = self._list_sort(scores, reverse=True) pred_labels_str = "" for i in sort_order: pred_labels_str += f"{self.labels[i]} ({scores[i]:3.2f})\n" self.w_pred_labels.value = str(pred_labels_str) self.w_image_header.value = f"Image index: {self.vis_image_index}" self.w_img.value = im._repr_png_() # Fix the width of the image widget and adjust the height self.w_img.layout.height = ( f"{int(self.IM_WIDTH * (im.size[1]/im.size[0]))}px") self.w_gt_label.value = str( self.labels[self.dataset[self.vis_image_index][1]]) self.w_filename.value = str( self.dataset.items[self.vis_image_index].name) self.w_path.value = str( self.dataset.items[self.vis_image_index].parent) bqpyplot.clear() bqpyplot.bar( self.labels, scores, align="center", alpha=1.0, color=np.abs(scores), scales={"color": bqplot.ColorScale(scheme="Blues", min=0)}, )
def init_plot(self): self.xscale = bq.LinearScale() self.yscale = bq.LinearScale() self.zscale = bq.ColorScale(scheme='Reds') self.heat = bq.HeatMap( x=self.x, y=self.y, color=self.z, scales=dict( x=self.xscale, y=self.yscale, color=self.zscale ) ) self.xax = bq.Axis( scale=self.xscale, label=self.labels['x'] ) self.yax = bq.Axis( scale=self.yscale, label=self.labels['y'], orientation='vertical' ) self.zax = bq.Axis(scale=self.zscale) super().__init__( marks=[self.heat], axes=[self.xax, self.yax, self.zax], )
def __init__(self, view, viewer_state, layer, layer_state): super(BqplotImageLayerArtist, self).__init__(layer) self.view = view self.state = layer_state or self._layer_state_cls( viewer_state=viewer_state, layer=self.layer) self._viewer_state = viewer_state if self.state not in self._viewer_state.layers: self._viewer_state.layers.append(self.state) # self._update_compatibility() self.scale_image = bqplot.ColorScale() self.scales = { 'x': self.view.scale_x, 'y': self.view.scale_y, 'image': self.scale_image } self.image_mark = bqplot.Image(image=[[1, 2], [3, 4]], scales=self.scales) self.color_axis = bqplot.ColorAxis(side='right', scale=self.scale_image, orientation='vertical') self.view.figure.axes = list(self.view.figure.axes) + [self.color_axis] self.view.figure.marks = list( self.view.figure.marks) + [self.image_mark] viewer_state.add_callback('x_att', self._update_xy_att) viewer_state.add_callback('y_att', self._update_xy_att)
def init_bq_fig(self): self.bq_xscale = bq.LinearScale() self.bq_yscale = bq.LinearScale() self.bq_colorscale = bq.ColorScale(min=-1, max=1) self.bq_xax = bq.Axis(scale=self.bq_xscale) self.bq_yax = bq.Axis(scale=self.bq_yscale, orientation='vertical') self.bq_colorax = bq.ColorAxis(scale=self.bq_colorscale) self.bq_heat = bq.HeatMap( x=self.x, y=self.z, color=zeros_like(self.cY), scales={ 'x': self.bq_xscale, 'y': self.bq_yscale, 'color': self.bq_colorscale } ) self.bq_fig = bq.Figure( marks=[self.bq_heat], axes=[ self.bq_xax, self.bq_yax, self.bq_colorax ] )
def __init__(self, scheme, count=None, **options): colors = self.palettes[scheme] super().__init__(scheme, count or len(colors)) self.colors = self.mkpal(colors, self.count) self.opt = opt = getopt(options, fig_title=self.scheme, fig_width=960, fig_height=150) data = np.arange(0, len(self.colors)) cs = bq.ColorScale(colors=self.colors) hm = bq.HeatMap(color=np.array([data, data]), scales={"color": cs}) self.figure = bq.Figure(marks=[hm], layout=ipw.Layout( width="%spx" % opt.fig["width"], height="%spx" % opt.fig["height"]), padding_x=0.0, padding_y=0.0, fig_margin={ "top": 60, "bottom": 0, "left": 0, "right": 0 }, title=opt.fig["title"]) self.vbox = ipw.VBox([self.figure, bq.Toolbar(figure=self.figure)])
def __init__(self, **kwargs): super(VizHeatmapBqplot, self).__init__(**kwargs) self.fig.padding_y = 0 self.fig.fig_margin = {'bottom': 80, 'left': 60, 'right': 10, 'top': 60} grid = self.state.grid if self.state.grid_sliced is not None: grid = self.state.grid_sliced if self.normalize: grid = grid/grid.sum() self.color_scale = bqplot.ColorScale(scheme='Blues') self.color_axis = bqplot.ColorAxis(scale=self.color_scale, label='counts', scheme='Blues') self.fig.axes = self.fig.axes + [self.color_axis] self.scales = {'row': self.y_scale, 'column': self.x_scale, 'color': self.color_scale} # self.scales = {'row': bqplot.OrdinalScale(), 'column': bqplot.OrdinalScale(), 'color': self.color_scale} self.heatmap = bqplot.GridHeatMap(color=grid.T[:,::], scales=self.scales) self.update_heatmap() self.fig.marks = self.fig.marks + [self.heatmap] self.state.observe(self.update_heatmap, 'grid') widgets.dlink((self.state, 'x_expression'), (self.x_axis, 'label')) widgets.dlink((self.state, 'y_expression'), (self.y_axis, 'label')) @self.output.capture() # @vaex.jupyter.debounced(DEBOUNCE_SLICE) def on_bar_hover(bar, event): # print(event) #set_transparancy(event['data']['sub_index'], event['data']['index']) #print(event['data']['index']) self.state.y_slice = event['data']['row'] self.state.x_slice = event['data']['column'] self.set_transparancy() #print(viz_state.grid.sum()) self.heatmap.on_hover(on_bar_hover)
def __init__(self, view, viewer_state, layer, layer_state): super(BqplotScatterLayerArtist, self).__init__(layer) self.view = view self.state = layer_state or self._layer_state_cls(viewer_state=viewer_state, layer=self.layer) self._viewer_state = viewer_state if self.state not in self._viewer_state.layers: self._viewer_state.layers.append(self.state) self.scale_size = bqplot.LinearScale() self.scale_color = bqplot.ColorScale() self.scale_size_quiver = bqplot.LinearScale(min=0, max=1) self.scale_rotation = bqplot.LinearScale(min=0, max=1) self.scales = dict(self.view.scales, size=self.scale_size, rotation=self.scale_rotation, color=self.scale_color) self.scales_quiver = dict(self.view.scales, size=self.scale_size_quiver, rotation=self.scale_rotation) self.scatter = bqplot.ScatterMega(scales=self.scales, x=[0, 1], y=[0, 1]) self.quiver = bqplot.ScatterMega(scales=self.scales_quiver, x=[0, 1], y=[0, 1], visible=False, marker='arrow') self.view.figure.marks = list(self.view.figure.marks) + [self.scatter, self.quiver] link((self.state, 'color'), (self.scatter, 'colors'), lambda x: [x], lambda x: x[0]) link((self.state, 'color'), (self.quiver, 'colors'), lambda x: [x], lambda x: x[0]) self.scatter.observe(self._workaround_unselected_style, 'colors') self.quiver.observe(self._workaround_unselected_style, 'colors') on_change([(self.state, 'cmap_mode', 'cmap_att')])(self._on_change_cmap_mode_or_att) on_change([(self.state, 'cmap')])(self._on_change_cmap) link((self.state, 'cmap_vmin'), (self.scale_color, 'min')) link((self.state, 'cmap_vmax'), (self.scale_color, 'max')) on_change([(self.state, 'size', 'size_scaling', 'size_mode', 'size_vmin', 'size_vmax')])(self._update_size) viewer_state.add_callback('x_att', self._update_xy_att) viewer_state.add_callback('y_att', self._update_xy_att) self._update_size() # set initial values for the colormap self._on_change_cmap()
def update_ui(self): pred_label = self.pred_labels[self.vis_image_index] img_obj = self.dataset.images[self.vis_image_index] scores = self.pred_scores[self.vis_image_index] self.w_image_header.value = "Image index: {}".format( self.vis_image_index) self.w_img.value = wImread(img_obj, self.context) self.w_gt_label.value = self.dataset.get_labels_for_image( img_obj)[0].name self.w_pred_label.value = str(pred_label) self.w_pred_score.value = str( self.pred_scores[self.vis_image_index, self.label_to_id[pred_label]]) self.w_index.value = str(self.vis_image_index) self.w_filename.value = img_obj.name self.w_path.value = img_obj.storage_path bqPyplot.clear() bqPyplot.bar( self.labels, scores, align='center', alpha=1.0, color=np.abs(scores), scales={'color': bqplot.ColorScale(scheme='Blues', min=0)})
def gui_graph (self) : ncs = bq.ColorScale(colors=self.nodes_palette) graph = bq.Graph(node_data=self.node_data, link_data=self.link_data, link_type="line", directed=self.opt.graph.directed, color=self.nodes_color, scales={"x": self._x_scale, "y": self._y_scale, "color": ncs}, x=self.nodes_x, y=self.nodes_y) return graph
def gui_tips (self) : sc_r = bq.LinearScale(min=0, max=np.pi) sc_c = bq.ColorScale(colors=Palette.mkpal(["#000000", "#FFFFFF"])) tips = {} for shape in self._tips_shapes : for end in ("src", "dst") : edges = self.edges[self.edges["_shape_" + end] == shape] scatt = bq.Scatter(x=edges["_x_" + end], y=edges["_y_" + end], marker=shape, rotation=edges["_angle_" + end], color=edges["_color_" + end], stroke="#000000", scales={"x" : self._x_scale, "y" : self._y_scale, "color" : sc_c, "rotation" : sc_r, }) tips[end,shape] = scatt return tips
def updateUI(self): predLabel = self.predLabels[self.visImageIndex] imgObj = self.dataset.images[self.visImageIndex] scores = self.predScores[self.visImageIndex] self.wImageHeader.value = "Image index: {}".format(self.visImageIndex) self.wImg.value = wImread(imgObj, self.imgOrigDir) self.wGtLabel.value = imgObj.label self.wPredLabel.value = str(self.lutId2Label[predLabel]) self.wPredScore.value = str(self.predScores[self.visImageIndex, predLabel]) self.wIndex.value = str(self.visImageIndex) self.wFilename.value = imgObj.filename bqPyplot.clear() bqPyplot.bar( self.labels, scores, align='center', alpha=1.0, color=np.abs(scores), scales={'color': bqplot.ColorScale(scheme='Blues', min=0)})
def gui_marks (self) : sc_s = bq.LinearScale(min=5, max=10) sc_o = bq.LinearScale(min=0, max=1) sc_c = bq.ColorScale(colors=self.marks_palette) marks = {} for shape in self._marks_shapes : nodes = self.nodes[self.nodes["_marks_shape"] == shape] scatt = bq.Scatter(x=nodes["_marks_x"], y=nodes["_marks_y"], size=nodes["_marks_size"], opacity=nodes["_marks_opacity"], color=nodes["_marks_color"], marker=shape, stroke=self.opt.marks.stroke, scales={"x" : self._x_scale, "y" : self._y_scale, "size" : sc_s, "opacity" : sc_o, "color" : sc_c}) marks[shape] = scatt return marks
import pandas as pd import bqplot import us names = [ "date", "city", "state", "country", "shape", "duration_seconds", "duration_reported", "description", "report_date", "latitude", "longitude" ] fn = "/srv/nbgrader/data/ufo-scrubbed-geocoded-time-standardized.csv", ufo = pd.read_csv(fn, names=names, parse_dates=["date", "report_date"]) abbr_to_fits = us.states.mapping('abbr', 'fips') ufo["fips"] = ufo["state"].apply( lambda a: int(abbr_to_fits.get(str(a).upper(), -1))) map_styles = { 'scales': { 'projection': bqplot.AlbersUSA(), 'color': bqplot.ColorScale(colors=["red", "blue"]) }, 'color': fips_count.to_dict() } states_map = bqplot.Map(map_data=bqplot.topo_load('map_data/USStatesMap.json'), **map_styles) map_fig = bqplot.Figure(marks=[states_map], title='USA')
def test_astro_image(): data = np.zeros((2, 3)) color_scale = bqplot.ColorScale() scale_x = bqplot.LinearScale() scale_y = bqplot.LinearScale() ImageGL(image=data, scales={'image': color_scale, 'x': scale_x, 'y': scale_y})
def _gen_series_tab(self): """Creates widgets for selecting timeseries data. - Dropdown to select column from dataframe. - Interactive bqplot with BrushIntervalSelector. Returns ------- widget : tab content widget """ scales = { 'x': bqp.DateScale(), 'y': bqp.LinearScale(), 'color': bqp.ColorScale(scheme='oranges') } axes = [ bqp.Axis(scale=scales['x'], label='Date', num_ticks=int(len(self._data.index) / 2)), bqp.Axis(scale=scales['y'], label='Value', orientation='vertical') ] mark = bqp.Lines(scales=scales) feature_selector = widgets.Dropdown(options=self._data.columns, description='Feature:') def feature_selection_callback(change): """Callback to update graph when new data has been selected Parameters ---------- change : dict Widget and changed values. """ self._selected_feature = change.new fig.title = f'Feature: {change.new}' series = self._data[change.new] mark.x = series.index mark.y = series.values # register callback for dropdown value-change events feature_selector.observe(feature_selection_callback, ['value']) def brush_sel_dt_callback(change): """Callback to update graph when new data has been selected Parameters ---------- change : dict Widget and changed values. """ tstamps = selector.selected if isinstance(tstamps, np.ndarray): tstamps = tstamps.tolist() if not selector.brushing and tstamps: # extract year and month from timestamp string: e.g. 2000-03-11T06:51:50.089000 -> 2000-03 dates = [ pd.to_datetime(re.split(r'-\d\dT', str(ts))[0]) for ts in tstamps ] self._selected_dates = dates selector = bqpi.BrushIntervalSelector(scale=scales['x'], color='blue') # register callback for BrushIntervalSelector brushing events selector.observe(brush_sel_dt_callback, ['brushing']) fig = bqp.Figure(marks=[mark], axes=axes, interaction=selector, layout=widgets.Layout(width='880px', height='380px'), animation_duration=1000) def reset_btn_click(b): """Reset selector and update instance properties accordingly. Parameters ---------- b : Button Button instance. """ selector.reset() self.reset() reset_btn = widgets.Button(description='reset') reset_btn.on_click(reset_btn_click) return widgets.VBox(children=[ widgets.HBox(children=[feature_selector, reset_btn]), fig ])
def __init__(self, view, viewer_state, layer_state=None, layer=None): super(BqplotScatterLayerArtist, self).__init__(viewer_state, layer_state=layer_state, layer=layer) self.view = view self.scale_size = bqplot.LinearScale() self.scale_color = bqplot.ColorScale() self.scale_size_quiver = bqplot.LinearScale(min=0, max=1) self.scale_rotation = bqplot.LinearScale(min=0, max=1) self.scales = dict(self.view.scales, size=self.scale_size, rotation=self.scale_rotation, color=self.scale_color) self.scale_image = bqplot.ColorScale() self.scales_quiver = dict(self.view.scales, size=self.scale_size_quiver, rotation=self.scale_rotation) self.scales_image = dict(self.view.scales, image=self.scale_image) self.scatter = bqplot.ScatterGL(scales=self.scales, x=[0, 1], y=[0, 1]) self.quiver = bqplot.ScatterGL(scales=self.scales_quiver, x=[0, 1], y=[0, 1], visible=False, marker='arrow') self.counts = None self.image = AstroImage(scales=self.scales_image) on_change([(self.state, 'density_map')])(self._on_change_density_map) on_change([(self.state, 'bins')])(self._update_scatter) self._viewer_state.add_global_callback(self._update_scatter) self.view.figure.marks = list( self.view.figure.marks) + [self.image, self.scatter, self.quiver] dlink((self.state, 'color'), (self.scatter, 'colors'), lambda x: [x]) dlink((self.state, 'color'), (self.quiver, 'colors'), lambda x: [x]) self.scatter.observe(self._workaround_unselected_style, 'colors') self.quiver.observe(self._workaround_unselected_style, 'colors') on_change([(self.state, 'cmap_mode', 'cmap_att') ])(self._on_change_cmap_mode_or_att) on_change([(self.state, 'cmap')])(self._on_change_cmap) dlink((self.state, 'cmap_vmin'), (self.scale_color, 'min'), float_or_none) dlink((self.state, 'cmap_vmax'), (self.scale_color, 'max'), float_or_none) on_change([(self.state, 'size', 'size_scaling', 'size_mode', 'size_vmin', 'size_vmax')])(self._update_size) viewer_state.add_callback('x_att', self._update_xy_att) viewer_state.add_callback('y_att', self._update_xy_att) self._update_size() # set initial values for the colormap self._on_change_cmap() self.state.add_callback('visible', self._update_visibility) self.state.add_callback('vector_visible', self._update_visibility) self.state.add_callback('density_map', self._update_visibility) dlink((self.state, 'visible'), (self.scatter, 'visible')) dlink((self.state, 'visible'), (self.image, 'visible')) dlink((self.state, 'alpha'), (self.scatter, 'default_opacities'), lambda x: [x]) dlink((self.state, 'alpha'), (self.quiver, 'default_opacities'), lambda x: [x]) dlink((self.state, 'alpha'), (self.image, 'opacity')) on_change([(self.state, 'vector_visible', 'vx_att', 'vy_att') ])(self._update_quiver) dlink((self.state, 'vector_visible'), (self.quiver, 'visible'))
class NetworkViewBase(ipyw.VBox): """An interactive, navigable display of the network. The NetworkViewBase class simply generates an interactive figure, without ipywidget buttons and dropdown menus. The NetworkModel extends this class, adding widget controls. Parameters ---------- case : PSSTCase An instance of a PSST case. model : NetworkModel An instance of NetworkModel can be passed instead of a case. (Should not pass both.) Attributes ---------- model : NetworkModel An instance of NetworkModel, containing state information for network. show_gen : Bool Display the points representing generators and connected lines. show_load : Bool Display the points representing loads and connected lines. show_bus_names : Bool Display names next to buses. show_gen_names : Bool Display names next to generators. show_load_names : Bool Display names next to loads. """ model = t.Instance(NetworkModel) show_gen = t.Bool(default_value=True) show_load = t.Bool(default_value=True) show_background_lines = t.Bool(default_value=True) show_bus_names = t.Bool(default_value=True) show_gen_names = t.Bool(default_value=True) show_load_names = t.Bool(default_value=True) def __init__(self, case=None, model=None, *args, **kwargs): super(NetworkViewBase, self).__init__(*args, **kwargs) ################## # Load and Store Model ################## if model and case: warnings.warn( 'You should pass a case OR a model, not both. The case argument you passed is being ignored.' ) if not model: self.model = NetworkModel(case) else: self.model = model ################## # Scale Marks ################## self._scale_x = bq.LinearScale(min=self.model.x_min_view, max=self.model.x_max_view) self._scale_y = bq.LinearScale(min=self.model.y_min_view, max=self.model.y_max_view) self._scales = { 'x': self._scale_x, 'y': self._scale_y, } # Temp/experimental. self._my_scales = { 'x': self._scale_x, 'y': self._scale_y, 'color': bq.ColorScale(colors=['Red', 'Green']), } ################## # Scatter Marks ################## # Tooltip scatter_tooltip = bq.Tooltip(fields=['name']) # Create Bus Scatter self._bus_scatter = bq.Scatter( x=self.model.bus_x_vals, y=self.model.bus_y_vals, scales=self._scales, names=self.model.bus_names, marker='rectangle', default_size=180, colors=[style.graph_main_1], default_opacities=[0.6], selected_style={ 'opacity': 0.8, 'fill': style.graph_selected_1, 'stroke': style.graph_accent_1 }, selected=self._get_indices_view_buses(), tooltip=scatter_tooltip, ) # Create Gen Scatter self._gen_scatter = bq.Scatter( x=self.model.gen_x_vals, y=self.model.gen_y_vals, scales=self._scales, names=self.model.gen_names, marker='circle', default_size=150, colors=[style.graph_main_2], default_opacities=[0.6], selected_style={ 'opacity': 0.8, 'fill': style.graph_selected_2, 'stroke': style.graph_accent_2 }, tooltip=scatter_tooltip, ) # Create Load Scatter self._load_scatter = bq.Scatter( x=self.model.load_x_vals, y=self.model.load_y_vals, scales=self._scales, names=self.model.load_names, marker='triangle-up', default_size=140, colors=[style.graph_main_3], default_opacities=[0.6], selected_style={ 'opacity': 0.8, 'fill': style.graph_selected_3, 'stroke': style.graph_accent_3 }, tooltip=scatter_tooltip, ) ################## # Line Marks ################## # import numpy as np # self.vals = np.random.randint(0, 2, size=len(self.model.bus_x_edges)) # Create Bus Lines self._bus_lines = bq.Lines( x=self.model.bus_x_edges, y=self.model.bus_y_edges, scales=self._scales, # colors=vals. colors=[style.graph_line_1], stroke_width=2, line_style='solid', opacities=[0.8], ) # Create Gen Lines self._gen_lines = bq.Lines( x=self.model.gen_x_edges, y=self.model.gen_y_edges, scales=self._scales, # colors=['black'], colors=[style.graph_line_2], stroke_width=1.5, line_style='solid', opacities=[0.8]) # Create Load Lines self._load_lines = bq.Lines( x=self.model.load_x_edges, y=self.model.load_y_edges, scales=self._scales, # colors=['black'], colors=[style.graph_line_3], stroke_width=1.5, line_style='solid', opacities=[0.8], ) # All lines, in background self._background_lines = bq.Lines( x=self.model.x_edges, y=self.model.y_edges, scales=self._scales, colors=['gray'], stroke_width=1, line_style='dotted', opacities=[0.05], marker='circle', marker_size=30, ) ################## # Bqplot Figure ################## self._all_marks = OrderedDict({ 'background_lines': self._background_lines, 'bus_lines': self._bus_lines, 'gen_lines': self._gen_lines, 'load_lines': self._load_lines, 'bus_scatter': self._bus_scatter, 'gen_scatter': self._gen_scatter, 'load_scatter': self._load_scatter, }) fig_margin = {'top': 0, 'bottom': 0, 'left': 0, 'right': 0} self._figure = bq.Figure( marks=list(self._all_marks.values()), animation_duration=0, fig_margin=fig_margin, ) # Set as children of VBox self.children = [self._figure] # Set defaults, triggering callback functions (setting proper children) self.show_background_lines = False self.show_gen_names = False self.show_load_names = False ################## # Link Traits ################## # Link Scales t.link((self.model, 'x_min_view'), (self._scale_x, 'min')) t.link((self.model, 'x_max_view'), (self._scale_x, 'max')) t.link((self.model, 'y_min_view'), (self._scale_y, 'min')) t.link((self.model, 'y_max_view'), (self._scale_y, 'max')) # Link Bus Scatter t.link((self.model, 'bus_x_vals'), (self._bus_scatter, 'x')) t.link((self.model, 'bus_y_vals'), (self._bus_scatter, 'y')) t.link((self.model, 'bus_names'), (self._bus_scatter, 'names')) # Link Gen Scatter t.link((self.model, 'gen_x_vals'), (self._gen_scatter, 'x')) t.link((self.model, 'gen_y_vals'), (self._gen_scatter, 'y')) t.link((self.model, 'gen_names'), (self._gen_scatter, 'names')) # Link Load Scatter t.link((self.model, 'load_x_vals'), (self._load_scatter, 'x')) t.link((self.model, 'load_y_vals'), (self._load_scatter, 'y')) t.link((self.model, 'load_names'), (self._load_scatter, 'names')) # Link Bus Lines t.link((self.model, 'bus_x_edges'), (self._bus_lines, 'x')) t.link((self.model, 'bus_y_edges'), (self._bus_lines, 'y')) # Link Gen Lines t.link((self.model, 'gen_x_edges'), (self._gen_lines, 'x')) t.link((self.model, 'gen_y_edges'), (self._gen_lines, 'y')) # Link Load Lines t.link((self.model, 'load_x_edges'), (self._load_lines, 'x')) t.link((self.model, 'load_y_edges'), (self._load_lines, 'y')) # Link names to show t.link((self, 'show_bus_names'), (self._bus_scatter, 'display_names')) t.link((self, 'show_gen_names'), (self._gen_scatter, 'display_names')) t.link((self, 'show_load_names'), (self._load_scatter, 'display_names')) # Set callbacks for clicking a bus # Click -> updates `model.view_buses` -> updates `bus_scatter.selected` self._bus_scatter.on_element_click(self._callback_bus_clicked) self.model.observe(self._callback_view_buses_change, names='view_buses') # Callbacks for clicking a load/gen node (Simply flashes selected) self._gen_scatter.on_element_click(self._callback_nonebus_clicked) self._load_scatter.on_element_click(self._callback_nonebus_clicked)