def modify_doc(doc): plot = Plot(plot_height=400, plot_width=400, x_range=Range1d(0, 1), y_range=Range1d(0, 1), min_border=0) slider = Slider(start=0, end=10, value=1, title="bar", css_classes=["foo"], width=300) def cb(attr, old, new): slider.title = "baz" slider.on_change('value', cb) doc.add_root(column(slider, plot))
def modify_doc(doc): plot = Plot(plot_height=400, plot_width=400, x_range=Range1d(0, 1), y_range=Range1d(0, 1), min_border=0) slider = Slider(start=0, end=10, value=1, title="bar", css_classes=["foo"], width=300, callback_policy="mouseup") def cbv(attr, old, new): junk['v'] += 1 def cbvt(attr, old, new): junk['vt'] += 1 slider.on_change('value', cbv) slider.on_change('value_throttled', cbvt) doc.add_root(column(slider, plot))
def main(options, args): #logger = log.get_logger("ginga", options=options) logger = log.get_logger("ginga", level=20, log_file="/tmp/ginga.log") #TOOLS = "pan,wheel_zoom,box_select,tap" TOOLS = "box_select" # create a new plot with default tools, using figure fig = figure(x_range=[0, 600], y_range=[0, 600], plot_width=600, plot_height=600, tools=TOOLS) viewer = ib.CanvasView(logger) viewer.set_figure(fig) bd = viewer.get_bindings() bd.enable_all(True) ## box_select_tool = fig.select(dict(type=BoxSelectTool)) ## box_select_tool.select_every_mousemove = True #tap_tool = fig.select_one(TapTool).renderers = [cr] # open a session to keep our local document in sync with server #session = push_session(curdoc()) #curdoc().add_periodic_callback(update, 50) def load_file(path): image = load_data(path, logger=logger) viewer.set_image(image) def load_file_cb(attr_name, old_val, new_val): #print(attr_name, old_val, new_val) load_file(new_val) def zoom_ctl_cb(attr_name, old_val, new_val): if new_val >= 0: new_val += 2 viewer.zoom_to(int(new_val)) scale = viewer.get_scale() logger.info("%f" % scale) viewer.onscreen_message("%f" % (scale), delay=0.3) # add a entry widget and configure with the call back #dstdir = options.indir dstdir = "" path_w = TextInput(value=dstdir, title="File:") path_w.on_change('value', load_file_cb) slide = Slider(start=-20, end=20, step=1, value=1) slide.on_change('value', zoom_ctl_cb) layout = column(fig, path_w, slide) curdoc().add_root(layout) if len(args) > 0: load_file(args[0])
def modify_doc(doc): source = ColumnDataSource(dict(x=[1, 2], y=[1, 1], val=["a", "b"])) plot = Plot(plot_height=400, plot_width=400, x_range=Range1d(0, 1), y_range=Range1d(0, 1), min_border=0) plot.add_glyph(source, Circle(x='x', y='y', size=20)) plot.add_tools(CustomAction(callback=CustomJS(args=dict(s=source), code=RECORD("data", "s.data")))) slider = Slider(start=0, end=10, value=1, title="bar", css_classes=["foo"], width=300) def cb(attr, old, new): source.data['val'] = [old, new] slider.on_change('value', cb) doc.add_root(column(slider, plot))
def modify_doc(doc): x = np.linspace(0, 10, 1000) y = np.log(x) * np.sin(x) source = ColumnDataSource(data=dict(x=x, y=y)) plot = figure(title="Simple plot with slider") plot.line('x', 'y', source=source) slider = Slider(start=1, end=10, value=1, step=0.1) def callback(attr, old, new): y = np.log(x) * np.sin(x*new) source.data = dict(x=x, y=y) slider.on_change('value', callback) doc.add_root(row(widgetbox(slider), plot))
def modify_doc(doc): df = sea_surface_temperature.copy() source = ColumnDataSource(data=df) plot = figure(x_axis_type='datetime', y_range=(0, 25), y_axis_label='Temperature (Celsius)', title="Sea Surface Temperature at 43.18, -70.43") plot.line('time', 'temperature', source=source) def callback(attr, old, new): if new == 0: data = df else: data = df.rolling('{0}D'.format(new)).mean() source.data = ColumnDataSource(data=data).data slider = Slider(start=0, end=30, value=0, step=1, title="Smoothing by N Days") slider.on_change('value', callback) doc.add_root(column(slider, plot)) doc.theme = Theme(filename="theme.yaml")
def modify_doc(doc): data_url = "http://www.neracoos.org/erddap/tabledap/B01_sbe37_all.csvp?time,temperature&depth=1&temperature_qc=0&time>=2016-02-15&time<=2017-03-22" df = pd.read_csv(data_url, parse_dates=True, index_col=0) df = df.rename(columns={'temperature (celsius)': 'temperature'}) df.index.name = 'time' source = ColumnDataSource(data=df) plot = figure(x_axis_type='datetime', y_range=(0, 25), y_axis_label='Temperature (Celsius)', title="Sea Surface Temperature at 43.18, -70.43") plot.line('time', 'temperature', source=source) def callback(attr, old, new): if new == 0: data = df else: data = df.rolling('{0}D'.format(new)).mean() source.data = ColumnDataSource(data=data).data slider = Slider(start=0, end=30, value=0, step=1, title="Smoothing by N Days") slider.on_change('value', callback) doc.add_root(column(slider, plot)) doc.theme = Theme(json=yaml.load(""" attrs: Figure: background_fill_color: "#DDDDDD" outline_line_color: white toolbar_location: above height: 500 width: 800 Grid: grid_line_dash: [6, 4] grid_line_color: white """))
def create_layout(self): # create figure self.x_range = Range1d(start=self.model.map_extent[0], end=self.model.map_extent[2], bounds=None) self.y_range = Range1d(start=self.model.map_extent[1], end=self.model.map_extent[3], bounds=None) self.fig = Figure(tools='wheel_zoom,pan', x_range=self.x_range, y_range=self.y_range) self.fig.plot_height = 560 self.fig.plot_width = 800 self.fig.axis.visible = False # add tiled basemap self.tile_source = WMTSTileSource(url=self.model.basemap) self.tile_renderer = TileRenderer(tile_source=self.tile_source) self.fig.renderers.append(self.tile_renderer) # add datashader layer self.image_source = ImageSource(url=self.model.service_url, extra_url_vars=self.model.shader_url_vars) self.image_renderer = DynamicImageRenderer(image_source=self.image_source) self.fig.renderers.append(self.image_renderer) # add label layer self.label_source = WMTSTileSource(url=self.model.labels_url) self.label_renderer = TileRenderer(tile_source=self.label_source) self.fig.renderers.append(self.label_renderer) # add ui components axes_select = Select.create(name='Axes', options=self.model.axes) axes_select.on_change('value', self.on_axes_change) field_select = Select.create(name='Field', options=self.model.fields) field_select.on_change('value', self.on_field_change) aggregate_select = Select.create(name='Aggregate', options=self.model.aggregate_functions) aggregate_select.on_change('value', self.on_aggregate_change) transfer_select = Select.create(name='Transfer Function', options=self.model.transfer_functions) transfer_select.on_change('value', self.on_transfer_function_change) basemap_select = Select.create(name='Basemap', value='Toner', options=self.model.basemaps) basemap_select.on_change('value', self.on_basemap_change) image_opacity_slider = Slider(title="Opacity", value=100, start=0, end=100, step=1) image_opacity_slider.on_change('value', self.on_image_opacity_slider_change) basemap_opacity_slider = Slider(title="Basemap Opacity", value=100, start=0, end=100, step=1) basemap_opacity_slider.on_change('value', self.on_basemap_opacity_slider_change) show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0]) show_labels_chk.on_click(self.on_labels_change) controls = [axes_select, field_select, aggregate_select, transfer_select] map_controls = [basemap_select, basemap_opacity_slider, image_opacity_slider, show_labels_chk] self.controls = VBox(width=200, height=600, children=controls) self.map_controls = HBox(width=self.fig.plot_width, children=map_controls) self.map_area = VBox(width=self.fig.plot_width, children=[self.map_controls, self.fig]) self.layout = HBox(width=1024, children=[self.controls, self.map_area])
w, h = image.shape source = ColumnDataSource(data=dict(image=[image])) p = figure(x_range=(0, w), y_range=(0, h)) p.image('image', x=0, y=0, dw=w, dh=h, palette=gray(256), source=source) @njit def blur(outimage, image, amt): for i in range(amt, w - amt): for j in range(amt, h - amt): px = 0. for iw in range(-amt // 2, amt // 2): for jh in range(-amt // 2, amt // 2): px += image[i + iw, j + jh] outimage[i, j] = px / (amt * amt) def update(attr, old, new): out = image.copy() blur(out, image, 2 * new + 1) source.data.update(image=[out]) slider = Slider(title="Blur Factor", start=0, end=10, value=0) slider.on_change('value', update) curdoc().add_root(column(p, slider)) curdoc().title = "Image Blur"
predictors=cluster_fields, cluster_column=cfc) df_rfm, clf, clf_tree, c_acc = res_set # now update only cluster column cds.data[cfc] = np.array(df_rfm[cfc]) update_texts(text1, text2, c_acc, nr_sample, c_clust, clf.inertia_) update_png('tree.png') print("Done from cluster:{} to cluster:{}".format(old, new)) # Attach the callback to the 'value' property of slider slider.on_change('value', update_plot) slider_tree = Slider(start=2, end=4, step=1, value=nr_tree_lvl, title='Numarul de nivele arbore:', width=200) def update_tree_lvl(attr, old, new): nr_tree_lvl = new train_tree(df_rfm, predictors=origin_fields, label_column=cfc, nr_lvl=nr_tree_lvl)
class Collimator(object): """ Manage the Orientation of a Nano """ #__slots__ = [''] # add legal instance variables # (setq properties `("" "")) brre = re.compile(r'\n') # used to convert newline to <br/> def __init__(self, flexname: str = "Default", name: str = "Collimator", display=fakedisplay, position: str = "0.0", maxrange: float = 1.5, width: int = 200): # Collimator::__init__() """Initialize this class.""" #super().__init__() # (wg-python-property-variables) self.flexname = flexname self.name = name self.display = display self.wwidth = width self.position = float(position) self.speed = 0.10 self.maxrange = float(maxrange) self.direction = 1 self.homestate = 0 self.spacer = Spacer(width=self.wwidth, height=5, background='black') #None # self.collimator = Slider(title=f"Collimator Position", bar_color='firebrick', value=self.position, start=0, end=self.maxrange, step=0.01, format="0.000f", width=self.wwidth) self.collimatorspeed = Slider(title=f"Collimator Speed", bar_color='firebrick', value=self.speed, start=0, end=1, step=.01, width=self.wwidth) self.stepin = Button(label="Step In", disabled=False, button_type="warning", width=self.wwidth // 2) self.stepout = Button(label="Step Out", disabled=False, button_type="warning", width=self.wwidth // 2) self.homebutton = Button(label="Home", disabled=False, button_type="danger", width=self.wwidth) self.collimator.on_change( 'value', lambda attr, old, new: self.update_collimator(attr, old, new)) self.collimatorspeed.on_change( 'value', lambda attr, old, new: self.update_speed(attr, old, new)) self.stepin.on_click(lambda: self.update_stepin()) self.stepout.on_click(lambda: self.update_stepout()) self.homebutton.on_click(lambda: self.update_homebutton()) ### Collimator.__init__() def debug(self, msg="", skip=[], os=sys.stderr): # Collimator::debug() """Help with momentary debugging, file to fit. msg -- special tag for this call skip -- the member variables to ignore os -- output stream: may be IOStream etc. """ import pprint print("Collimator - %s " % msg, file=os) for key, value in self.__dict__.items(): if (key in skip): continue print(f'{key:20s} =', file=os, end='') pprint.pprint(value, stream=os, indent=4) return self ### Collimator.debug() def update_collimator(self, attr, old, new): # Collimator::update_collimator() """Update the parallactic angle. Disabled in interface""" self.position = float(new) ### Collimator.update_collimator() def update_speed(self, attr, old, new): # Collimator::update_speed() """Update the parallactic angle. Disabled in interface""" self.speed = float(new) ### Collimator.update_speed() def update_stepin(self): # Collimator::update_stepin() """Update the parallactic angle. Disabled in interface""" self.direction = 0 newposition = self.position - (self.speed * self.collimator.step) if (newposition >= 0): self.position = newposition self.collimator.value = newposition self.send_state() ### Collimator.update_stepin() def update_stepout(self): # Collimator::update_stepout() """Update the parallactic angle. Disabled in interface""" self.direction = 1 newposition = self.position + (self.speed * self.collimator.step) if (newposition < self.maxrange): self.position = newposition self.collimator.value = newposition self.send_state() ### Collimator.update_stepout() def update_homebutton(self): # Collimator::update_homebutton() """Send a home command""" self.send_home() ### Collimator.update_homebutton() def send_home(self): # Collimator::send_home() """Send a Home Command""" self.home = 1 self.send_state() self.homestate = 0 ### Collimator.send_home() def send_state(self): # Collimator::send_state() """Several ways to send things""" devstate = dict([("position", f"{self.position:7.4f}"), ("direction", int(self.direction)), ("speed", self.speed), ("home", self.homestate)]) slitcmd = dict([("Process", devstate), ("Receipt", 0)]) slitcmd['Receipt'] = 1 # set the receipt as desired d2 = dict([(f"{self.name}", slitcmd)]) d3 = dict([(f"{self.flexname}", d2)]) jdict = json.dumps(d3) self.display.display(f'{jdict}') ### Collimator.send_state() def layout(self): # Collimator::layout() """Create the layout""" return (row( column(self.collimator, self.collimatorspeed, row(self.stepin, self.stepout), self.homebutton)))
source_overlay = ColumnDataSource(data=dict(x=[], y=[], y_neg=[], y_pos=[])) # initialize properties update_is_enabled = True # initialize controls # dropdown menu for sample functions function_type = Dropdown(label="choose a sample function pair or enter one below", menu=convolution_settings.sample_function_names) function_type.on_click(function_pair_input_change) # slider controlling the evaluated x value of the convolved function x_value_input = Slider(title="x value", name='x value', value=convolution_settings.x_value_init, start=convolution_settings.x_value_min, end=convolution_settings.x_value_max, step=convolution_settings.x_value_step) x_value_input.on_change('value', input_change) # text input for the first function to be convolved function1_input = TextInput(value=convolution_settings.function1_input_init, title="my first function:") function1_input.on_change('value', input_change) # text input for the second function to be convolved function2_input = TextInput(value=convolution_settings.function1_input_init, title="my second function:") function2_input.on_change('value', input_change) # initialize plot toolset = "crosshair,pan,reset,resize,save,wheel_zoom" # Generate a figure container plot = Figure(plot_height=400, plot_width=400, tools=toolset, title="Convolution of two functions", x_range=[convolution_settings.x_min_view, convolution_settings.x_max_view], y_range=[convolution_settings.y_min_view, convolution_settings.y_max_view])
# 1. europa / świat opcje = ["Europa", "poza Europa"] checkbox_button_group = CheckboxButtonGroup(labels=opcje, active=[]) checkbox_button_group.on_change('active', update_x) # 2. button - najwięcej zgonów button = Button(label='The highest number of deaths') button.on_click(deaths) # 3. slider po liczebności slider = Slider(start=0, end=10, step=1, value=0, title='Change the range of the x axis') slider.on_change('value', x_range) # 4.select okres select = Select(title='Choose a period:', value='latest', options=[ 'latest', '2020-10-01', '2020-09-01', '2020-08-01', '2020-07-01', '2020-06-01', '2020-05-01', '2020-04-01', '2020-03-01', '2020-02-01' ]) select.on_change('value', period) html_1 = """ <h3> Covid incidence in individual countries </h><b><i></>""" sup_title_1 = Div(text=html_1, width=800) layout_1 = gridplot([[select], [slider], [plt], [checkbox_button_group],
# #def on_dist_change(obj, attr, old, new): # print "Max Node Dist (km)", new # global max_node_dist_km # max_node_dist_km = int(new) # #select_dist.on_change('value', on_dist_change) select_dist = Slider(title="Max GDELT Distance to Road (km)", start=1, end=10, value=5, step=1) def on_dist_change(obj, attr, old, new): print "Max Node Dist (km)", new global max_node_dist_km max_node_dist_km = int(new) select_dist.on_change('value', on_dist_change) ############## ############## # set max aug distance #select_dist.on_change('value', on_dist_change) slider_rkm = Slider(title="Control Inference Distance (km)", start=0, end=10, value=r_km, step=0.5) def on_rkm_change(obj, attr, old, new): print "Max Aug Dist (km)", new global r_km r_km = new slider_rkm.on_change('value', on_rkm_change)
bin_width=bin_width, lat=lat, lon=lon) # python callbacks map_fig.x_range.on_change('start', update_histogram) map_fig.x_range.on_change('end', update_histogram) map_fig.y_range.on_change('start', update_histogram) map_fig.y_range.on_change('end', update_histogram) map_fig.on_event(events.Tap, move_click_marker) map_fig.on_event(events.Press, move_click_marker) select_day.on_change('value', update_models) select_model.on_change('value', update_file) select_fxtime.on_change('value', update_data) # layout the document lay = column( row([select_day, select_model, select_fxtime]), gridplot( [map_fig], [tseries_fig, hist_fig], toolbar_location='left', ), info_div) doc = curdoc() doc.add_root(lay) doc.add_next_tick_callback(partial(_update_models, True)) doc.add_timeout_callback(_update_data, 1000) doc.title = config.TITLE doc.template_variables.update({
plot.y_range.end = max(source_cut.data['importance']) def update_slider(attrname, old, new): n_samples = int(samples_slider.value) newdata = get_ends(n_samples) source_cut.data = dict(newdata.to_dict('list')) plot.x_range.factors = newdata['aspects'].tolist() # this was missing plot.y_range.start = min(source_cut.data['importance']) plot.y_range.end = max(source_cut.data['importance']) data_table = DataTable(source=source_cut, columns=columns, width=700, height=500) dataset_select.on_change('value', update_dataset) exponent_slider.on_change('value', update_dataset) ratings_box.on_change('value', update_dataset) samples_slider.on_change('value', update_slider) # Set up layout selects = row(dataset_select) inputs = column(selects, widgetbox(exponent_slider, ratings_box, samples_slider)) table = widgetbox(data_table) tab1 = Panel(child=table, title="Data") tab2 = Panel(child=plot, title="Bar Plot") tabs = Tabs(tabs=[tab1, tab2]) lay = layout([[inputs,tabs],]) # Add to document curdoc().add_root(lay)
def create_layout(self): # create figure self.x_range = Range1d(start=self.model.map_extent[0], end=self.model.map_extent[2], bounds=None) self.y_range = Range1d(start=self.model.map_extent[1], end=self.model.map_extent[3], bounds=None) self.fig = Figure(tools='wheel_zoom,pan', x_range=self.x_range, lod_threshold=None, plot_width=self.model.plot_width, plot_height=self.model.plot_height, background_fill_color='black', y_range=self.y_range) self.fig.min_border_top = 0 self.fig.min_border_bottom = 10 self.fig.min_border_left = 0 self.fig.min_border_right = 0 self.fig.axis.visible = False self.fig.xgrid.grid_line_color = None self.fig.ygrid.grid_line_color = None # add tiled basemap self.tile_source = WMTSTileSource(url=self.model.basemap) self.tile_renderer = TileRenderer(tile_source=self.tile_source) self.fig.renderers.append(self.tile_renderer) # add datashader layer self.image_source = ImageSource( url=self.model.service_url, extra_url_vars=self.model.shader_url_vars) self.image_renderer = DynamicImageRenderer( image_source=self.image_source) self.fig.renderers.append(self.image_renderer) # add label layer self.label_source = WMTSTileSource(url=self.model.labels_url) self.label_renderer = TileRenderer(tile_source=self.label_source) self.fig.renderers.append(self.label_renderer) # Add placeholder for legends (temporarily disabled) # self.model.legend_side_vbox = VBox() # self.model.legend_bottom_vbox = VBox() # add ui components controls = [] axes_select = Select(name='Axes', options=list(self.model.axes.keys())) axes_select.on_change('value', self.on_axes_change) controls.append(axes_select) self.field_select = Select(name='Field', options=list(self.model.fields.keys())) self.field_select.on_change('value', self.on_field_change) controls.append(self.field_select) self.aggregate_select = Select( name='Aggregate', options=list(self.model.aggregate_functions.keys())) self.aggregate_select.on_change('value', self.on_aggregate_change) controls.append(self.aggregate_select) transfer_select = Select(name='Transfer Function', options=list( self.model.transfer_functions.keys())) transfer_select.on_change('value', self.on_transfer_function_change) controls.append(transfer_select) color_ramp_select = Select(name='Color Ramp', options=list(self.model.color_ramps.keys())) color_ramp_select.on_change('value', self.on_color_ramp_change) controls.append(color_ramp_select) spread_size_slider = Slider(title="Spread Size (px)", value=0, start=0, end=10, step=1) spread_size_slider.on_change('value', self.on_spread_size_change) controls.append(spread_size_slider) hover_size_slider = Slider(title="Hover Size (px)", value=8, start=4, end=30, step=1) hover_size_slider.on_change('value', self.on_hover_size_change) controls.append(hover_size_slider) # legends (temporarily disabled) # controls.append(self.model.legend_side_vbox) # add map components basemap_select = Select(name='Basemap', value='Imagery', options=list(self.model.basemaps.keys())) basemap_select.on_change('value', self.on_basemap_change) image_opacity_slider = Slider(title="Opacity", value=100, start=0, end=100, step=1) image_opacity_slider.on_change('value', self.on_image_opacity_slider_change) basemap_opacity_slider = Slider(title="Basemap Opacity", value=100, start=0, end=100, step=1) basemap_opacity_slider.on_change('value', self.on_basemap_opacity_slider_change) show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0]) show_labels_chk.on_click(self.on_labels_change) map_controls = [ basemap_select, basemap_opacity_slider, image_opacity_slider, show_labels_chk ] self.controls = VBox(height=600, children=controls) self.map_controls = HBox(width=self.fig.plot_width, children=map_controls) # legends (temporarily disabled) self.map_area = VBox(width=900, height=600, children=[self.map_controls, self.fig]) self.layout = HBox(width=1300, height=600, children=[self.controls, self.map_area]) self.model.fig = self.fig self.model.update_hover()
def create_layout(self): # create figure self.x_range = Range1d(start=self.model.map_extent[0], end=self.model.map_extent[2], bounds=None) self.y_range = Range1d(start=self.model.map_extent[1], end=self.model.map_extent[3], bounds=None) self.fig = Figure(tools='wheel_zoom,pan', x_range=self.x_range, y_range=self.y_range) self.fig.plot_height = 560 self.fig.plot_width = 800 self.fig.axis.visible = False # add tiled basemap self.tile_source = WMTSTileSource(url=self.model.basemap) self.tile_renderer = TileRenderer(tile_source=self.tile_source) self.fig.renderers.append(self.tile_renderer) # add datashader layer self.image_source = ImageSource( url=self.model.service_url, extra_url_vars=self.model.shader_url_vars) self.image_renderer = DynamicImageRenderer( image_source=self.image_source) self.fig.renderers.append(self.image_renderer) # add label layer self.label_source = WMTSTileSource(url=self.model.labels_url) self.label_renderer = TileRenderer(tile_source=self.label_source) self.fig.renderers.append(self.label_renderer) # add ui components axes_select = Select.create(name='Axes', options=self.model.axes) axes_select.on_change('value', self.on_axes_change) field_select = Select.create(name='Field', options=self.model.fields) field_select.on_change('value', self.on_field_change) aggregate_select = Select.create( name='Aggregate', options=self.model.aggregate_functions) aggregate_select.on_change('value', self.on_aggregate_change) transfer_select = Select.create(name='Transfer Function', options=self.model.transfer_functions) transfer_select.on_change('value', self.on_transfer_function_change) basemap_select = Select.create(name='Basemap', value='Toner', options=self.model.basemaps) basemap_select.on_change('value', self.on_basemap_change) image_opacity_slider = Slider(title="Opacity", value=100, start=0, end=100, step=1) image_opacity_slider.on_change('value', self.on_image_opacity_slider_change) basemap_opacity_slider = Slider(title="Basemap Opacity", value=100, start=0, end=100, step=1) basemap_opacity_slider.on_change('value', self.on_basemap_opacity_slider_change) show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0]) show_labels_chk.on_click(self.on_labels_change) controls = [ axes_select, field_select, aggregate_select, transfer_select ] map_controls = [ basemap_select, basemap_opacity_slider, image_opacity_slider, show_labels_chk ] self.controls = VBox(width=200, height=600, children=controls) self.map_controls = HBox(width=self.fig.plot_width, children=map_controls) self.map_area = VBox(width=self.fig.plot_width, children=[self.map_controls, self.fig]) self.layout = HBox(width=1024, children=[self.controls, self.map_area])
class Distribution(object): def __init__( self, name, xmin, xmax, mu, sigma, pdf, gp_callback, throttle, ): # Store self.pdf = pdf self.gp_callback = gp_callback # Arrays x = np.linspace(xmin, xmax, 300) y = self.pdf(x, mu["value"], sigma["value"]) self.source = ColumnDataSource(data=dict(x=x, y=y)) # Plot them dx = (xmax - xmin) * 0.01 self.plot = figure( plot_width=400, plot_height=400, sizing_mode="stretch_height", toolbar_location=None, x_range=(xmin - dx, xmax + dx), title="{} distribution".format(name), ) self.plot.title.align = "center" self.plot.title.text_font_size = "14pt" self.plot.line("x", "y", source=self.source, line_width=3, line_alpha=0.6) self.plot.xaxis.axis_label = name self.plot.xaxis.axis_label_text_font_style = "normal" self.plot.xaxis.axis_label_text_font_size = "12pt" self.plot.yaxis[0].formatter = FuncTickFormatter(code="return ' ';") self.plot.yaxis.axis_label = "probability" self.plot.yaxis.axis_label_text_font_style = "normal" self.plot.yaxis.axis_label_text_font_size = "12pt" self.plot.outline_line_width = 1 self.plot.outline_line_alpha = 1 self.plot.outline_line_color = "black" # Sliders self.slider_mu = Slider( start=mu["start"], end=mu["stop"], step=mu["step"], value=mu["value"], orientation="vertical", format="0.3f", css_classes=["custom-slider"], callback_policy="throttle", callback_throttle=throttle, ) self.slider_mu.on_change("value_throttled", self.callback) self.slider_sigma = Slider( start=sigma["start"], end=sigma["stop"], step=sigma["step"], value=sigma["value"], orientation="vertical", format="0.3f", css_classes=["custom-slider"], name="sigma", callback_policy="throttle", callback_throttle=throttle, ) self.slider_sigma.on_change("value_throttled", self.callback) # Show mean and std. dev. self.mean_vline = Span( location=self.slider_mu.value, dimension="height", line_color="black", line_width=1, line_dash="dashed", ) self.std_vline1 = Span( location=self.slider_mu.value - self.slider_sigma.value, dimension="height", line_color="black", line_width=1, line_dash="dotted", ) self.std_vline2 = Span( location=self.slider_mu.value + self.slider_sigma.value, dimension="height", line_color="black", line_width=1, line_dash="dotted", ) self.plot.renderers.extend( [self.mean_vline, self.std_vline1, self.std_vline2]) # Full layout self.layout = row( self.plot, column(svg_mu(), self.slider_mu, margin=(10, 10, 10, 10)), column(svg_sigma(), self.slider_sigma, margin=(10, 10, 10, 10)), ) def callback(self, attr, old, new): try: # Update the distribution self.source.data["y"] = self.pdf( self.source.data["x"], self.slider_mu.value, self.slider_sigma.value, ) self.slider_mu.bar_color = "white" self.slider_sigma.bar_color = "white" self.plot.background_fill_color = "white" self.plot.background_fill_alpha = 1 # Update the mean and std. dev. lines self.mean_vline.location = self.slider_mu.value self.std_vline1.location = (self.slider_mu.value - self.slider_sigma.value) self.std_vline2.location = (self.slider_mu.value + self.slider_sigma.value) except AssertionError as e: # A param is out of bounds! if "std" in str(e): self.slider_sigma.bar_color = "firebrick" elif "mean" in str(e): self.slider_mu.bar_color = "firebrick" else: self.slider_sigma.bar_color = "firebrick" self.slider_mu.bar_color = "firebrick" self.plot.background_fill_color = "firebrick" self.plot.background_fill_alpha = 0.2 finally: try: # Update the GP samples self.gp_callback(attr, old, new) except AssertionError as e: pass
def fun_change(attrname, old, new): f_str = f_input.value f_fun, f_sym = string_to_function_parser(f_str, ['x']) print der.value df_sym = diff(f_sym, 'x', int(der.value)) df_fun = sym_to_function_parser(df_sym,['x']) x = np.linspace(-5, 5, 100) y = f_fun(x) dy = df_fun(x) line_source.data = dict(x=x, y=y, dy=dy) def init_data(): fun_change(None,None,None) # Plotting plot = Figure(title="function plotter", x_range=[-5,5], y_range=[-5,5]) plot.line(x='x', y='y', source=line_source, color='red', legend='f(x)') plot.line(x='x', y='dy', source=line_source, color='blue', legend='df^n(x)') #Callback f_input.on_change('value', fun_change) derivative_input.on_change('value', fun_change) init_data() #Layout curdoc().add_root(row(plot,column(f_input,derivative_input)))
# initialize data source plot_data_num = ColumnDataSource(data=dict(x=[], u=[])) plot_data_ana = ColumnDataSource(data=dict(x=[], u=[])) mesh_data = ColumnDataSource(data=dict()) pde_specs = ColumnDataSource(data=dict(h=[], k=[])) ana_sol = ColumnDataSource(data=dict()) # initialize controls # slider for going though time time_slider = Slider(title="time", name='time', value=pde_settings.t_init, start=pde_settings.t_min, end=pde_settings.t_max, step=pde_settings.t_step) time_slider.on_change('value', time_change) # slider controlling spatial stepsize of the solver h_slider = Slider(title="spatial meshwidth", name='spatial meshwidth', value=pde_settings.h_init, start=pde_settings.h_min, end=pde_settings.h_max, step=pde_settings.h_step) h_slider.on_change('value', mesh_change) # slider controlling spatial stepsize of the solver k_slider = Slider(title="temporal meshwidth", name='temporal meshwidth', value=pde_settings.k_init, start=pde_settings.k_min, end=pde_settings.k_max, step=pde_settings.k_step)
def create_layout(self): # create figure self.x_range = Range1d(start=self.model.map_extent[0], end=self.model.map_extent[2], bounds=None) self.y_range = Range1d(start=self.model.map_extent[1], end=self.model.map_extent[3], bounds=None) self.fig = Figure( tools="wheel_zoom,pan", x_range=self.x_range, lod_threshold=None, plot_width=self.model.plot_width, plot_height=self.model.plot_height, background_fill_color="black", y_range=self.y_range, ) self.fig.min_border_top = 0 self.fig.min_border_bottom = 10 self.fig.min_border_left = 0 self.fig.min_border_right = 0 self.fig.axis.visible = False self.fig.xgrid.grid_line_color = None self.fig.ygrid.grid_line_color = None # add tiled basemap self.tile_source = WMTSTileSource(url=self.model.basemap) self.tile_renderer = TileRenderer(tile_source=self.tile_source) self.fig.renderers.append(self.tile_renderer) # add datashader layer self.image_source = ImageSource(url=self.model.service_url, extra_url_vars=self.model.shader_url_vars) self.image_renderer = DynamicImageRenderer(image_source=self.image_source) self.fig.renderers.append(self.image_renderer) # add label layer self.label_source = WMTSTileSource(url=self.model.labels_url) self.label_renderer = TileRenderer(tile_source=self.label_source) self.fig.renderers.append(self.label_renderer) # Add placeholder for legends (temporarily disabled) # self.model.legend_side_vbox = VBox() # self.model.legend_bottom_vbox = VBox() # add ui components controls = [] axes_select = Select.create(name="Axes", options=self.model.axes) axes_select.on_change("value", self.on_axes_change) controls.append(axes_select) self.field_select = Select.create(name="Field", options=self.model.fields) self.field_select.on_change("value", self.on_field_change) controls.append(self.field_select) self.aggregate_select = Select.create(name="Aggregate", options=self.model.aggregate_functions) self.aggregate_select.on_change("value", self.on_aggregate_change) controls.append(self.aggregate_select) transfer_select = Select.create(name="Transfer Function", options=self.model.transfer_functions) transfer_select.on_change("value", self.on_transfer_function_change) controls.append(transfer_select) color_ramp_select = Select.create(name="Color Ramp", options=self.model.color_ramps) color_ramp_select.on_change("value", self.on_color_ramp_change) controls.append(color_ramp_select) spread_size_slider = Slider(title="Spread Size (px)", value=0, start=0, end=10, step=1) spread_size_slider.on_change("value", self.on_spread_size_change) controls.append(spread_size_slider) hover_size_slider = Slider(title="Hover Size (px)", value=8, start=4, end=30, step=1) hover_size_slider.on_change("value", self.on_hover_size_change) controls.append(hover_size_slider) # legends (temporarily disabled) # controls.append(self.model.legend_side_vbox) # add map components basemap_select = Select.create(name="Basemap", value="Imagery", options=self.model.basemaps) basemap_select.on_change("value", self.on_basemap_change) image_opacity_slider = Slider(title="Opacity", value=100, start=0, end=100, step=1) image_opacity_slider.on_change("value", self.on_image_opacity_slider_change) basemap_opacity_slider = Slider(title="Basemap Opacity", value=100, start=0, end=100, step=1) basemap_opacity_slider.on_change("value", self.on_basemap_opacity_slider_change) show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0]) show_labels_chk.on_click(self.on_labels_change) map_controls = [basemap_select, basemap_opacity_slider, image_opacity_slider, show_labels_chk] self.controls = VBox(height=600, children=controls) self.map_controls = HBox(width=self.fig.plot_width, children=map_controls) # legends (temporarily disabled) self.map_area = VBox(width=900, height=600, children=[self.map_controls, self.fig]) self.layout = HBox(width=1300, height=600, children=[self.controls, self.map_area]) self.model.fig = self.fig self.model.update_hover()
] p.add_layout(legend) def update(): try: expr = sy.sympify(text.value, dict(x=xs)) except Exception as exception: errbox.text = str(exception) else: errbox.text = "" x, fy, ty = taylor(expr, xs, slider.value, (-2*sy.pi, 2*sy.pi), 200) p.title.text = "Taylor (n=%d) expansion comparison for: %s" % (slider.value, expr) legend.items[0].label = value("%s" % expr) legend.items[1].label = value("taylor(%s)" % expr) source.data = dict(x=x, fy=fy, ty=ty) slider = Slider(start=1, end=20, value=1, step=1, title="Order") slider.on_change('value', lambda attr, old, new: update()) text = TextInput(value=str(expr), title="Expression:") text.on_change('value', lambda attr, old, new: update()) errbox = PreText() update() inputs = column(text, slider, errbox, width=400) curdoc().add_root(column(inputs, p))
height="height", fill_color="LightSeaGreen")) centroids = kmeans_viz.add_glyph( source, Circle(x="longitude", y="latitude", size=10, fill_alpha=1)) hover = kmeans_viz.select_one(HoverTool) hover.point_policy = "follow_mouse" hover.tooltips = [ ("Count", "@count"), ("(Long, Lat)", "($x.2, $y.2)"), ("Width", "@width"), ("Height", "@height"), ] iter_slider = Slider(start=0, end=len(cluster_hist) - 5, value=0, step=1, title="Iteration") def update(attr, old, new): clusters.data_source.data = cluster_hist[str(iter_slider.value)] centroids.data_source.data = cluster_hist[str(iter_slider.value)] iter_slider.on_change("value", update) # output_file("sample_clusters_visualization.html", title='K-Means Visualization', mode='inline') show(layout([[kmeans_viz, iter_slider]])) curdoc().add_root(layout([[kmeans_viz, iter_slider]]))
other_source.data = gen_dict(other) else: other_source.data = empty_dict if 1 in button_group.active: speed_source.data = gen_dict(speed) else: speed_source.data = empty_dict if 2 in button_group.active: drunk_source.data = gen_dict(drunk) else: drunk_source.data = empty_dict slider.on_change('value', update_hour) toggle.on_change('active', update_hour) button_group.on_change('active', update_hour) callback = CustomJS(args=dict(other=other_circles, speed=speed_circles, drunk=drunk_circles), code=""" other.glyph.radius = { value: cb_obj.get('value')*125 } other.data_source.trigger('change') speed.glyph.radius = { value: cb_obj.get('value')*125 } speed.data_source.trigger('change') drunk.glyph.radius = { value: cb_obj.get('value')*125 } drunk.data_source.trigger('change') """) size_slider = Slider(title="Dot Size", start=1, end=100, orientation="horizontal",
def gapminder_plot_bokeh(datos_e, datos_pca, year_i, X_data_df, grad_per, etiquetas_glo, periodos_incluir, k, imp_periods_var, centroids_ite, scaler_es, title='Titulo', xlabel='Eje x', ylabel='Eje y'): ### Lista years years_plot = [] for o in periodos_incluir: years_plot.append(o) ### Dataframes necesarias pca1 = pd.DataFrame(columns=years_plot) pca2 = pd.DataFrame(columns=years_plot) ### PCA de cada year for year in years_plot: filtro = datos_e['periodo'] == year ### Los que usare para el PCA seran X_data_pca_y = np.array(datos_pca[filtro]) pca1[year] = X_data_pca_y[:, 0] pca2[year] = X_data_pca_y[:, 1] ### Nombres de los individuos pca1.index = X_data_df.cliente pca2.index = X_data_df.cliente ### Grados de pertenencia grados_pert = pd.DataFrame(columns=years_plot) ##### Grados de pertenencia de cada year coun = 0 for year in years_plot: grados_pert[year] = np.max( grad_per[coun], axis=1) * 40 ### Aumento escala para que se vean bien coun = coun + 1 grados_pert.index = X_data_df.cliente ##### Cluster al que pertenece cada dato en cada periodo de tiempo etiqs_plot = [] couu = 0 for year in years_plot: eti = pd.DataFrame() eti['region'] = [str(i)[0] for i in list(etiquetas_glo[couu]) ] ### Solo 1 caracter eti.index = X_data_df.cliente etiqs_plot.append(eti) couu = couu + 1 ##### Regions_list son los id de los cluster regions_list = [] for cu in range(k): regions_list.append(str(cu)) ### fertility df seria componente principal 1 ### life expectancy df seria componente principal 2 ### population_df_size es el maximo grado de pertenencia ### regions_df es el cluster id al que se asigno cada uno ### years es la lista de years a modelar ### regions list seria el "nombre " de cada cluster (top variables mas importantes) ### Consolidar data df = pd.concat( { 'Componente_1': pca1, 'Componente_2': pca2, 'Grado_Pertenencia': grados_pert }, axis=1) ### Construir data data = {} counta = 0 for year in years_plot: df_year = df.iloc[:, df.columns.get_level_values(1) == year] df_year.columns = df_year.columns.droplevel(1) data[year] = df_year.join( etiqs_plot[counta].region).reset_index().to_dict('series') counta = counta + 1 source = ColumnDataSource(data=data[years_plot[0]]) ############### Para las labels ######################## #### Numero de variables a plotear num_v_plot = 4 #### Nombres variables nomb_v = datos_e.columns[2:] #### Desestandarizar centroides centroids_ito = scaler_es.inverse_transform(centroids_ite) #### Consolidar strings de las legends de cada iteracion strings_legends = [] c = 0 for y in years_plot: esta_iter = [] estas_imp = imp_periods_var[c] cc = 0 for clu in estas_imp: ### Variables mas importantes orden_v = np.argsort(clu)[::-1][:num_v_plot] ### Construir string stri = '' ### Numero observaciones cluster stri = stri + 'Num_obs: ' + str( len(np.where(etiquetas_glo[c] == cc)[0])) + ', ' ### Variables importantes for i in orden_v: stri = stri + nomb_v[i][:12] + ': ' + str( np.around(centroids_ito[c][cc][i], 2)) + ', ' stri = stri[:-2] esta_iter.append(stri) cc = cc + 1 strings_legends.append(esta_iter) c = c + 1 #### PLoteos global plot plot = figure(title=title, y_range=(-5, 7), plot_height=520, plot_width=900) plot.xaxis.ticker = SingleIntervalTicker(interval=1) plot.xaxis.axis_label = xlabel plot.yaxis.ticker = SingleIntervalTicker(interval=20) plot.yaxis.axis_label = ylabel label = Label(x=1.1, y=18, text=str(years_plot[0]), text_font_size='70pt', text_color='#eeeeee') plot.add_layout(label) color_mapper = CategoricalColorMapper(palette=Spectral6, factors=regions_list) global r r = plot.circle( x='Componente_1', y='Componente_2', size='Grado_Pertenencia', source=source, fill_color={ 'field': 'region', 'transform': color_mapper }, fill_alpha=0.8, line_color='#7c7e71', line_width=0.5, line_alpha=0.5, # legend_group='region', ) from bokeh.models import Legend, LegendItem global legend items_son = [] co = 0 for a in strings_legends[0]: color_ = list(etiquetas_glo[0]).index(co) items_son.append(LegendItem(label=a, renderers=[r], index=color_)) co = co + 1 legend = Legend(items=items_son) plot.add_layout(legend) plot.add_tools( HoverTool(tooltips="@cliente", show_arrow=False, point_policy='follow_mouse')) def animate_update(): global plot posi = (int(slider.value) + 1) % len( years_plot) ### En este ejemplo, q no pase de 12 year = years_plot[posi] plot.title.text = str(year)[:].replace('.', '-Q') if year > years_plot[-1]: year = years_plot[0] slider.value = posi def slider_update(attrname, old, new): year = years_plot[int(slider.value)] label.text = str(year) source.data = data[year] pos = years_plot.index(year) global legend global r global plot plot.title.text = str(year)[:].replace('.', '-Q') items_son = [] bo = 0 for a in strings_legends[pos]: color_ = list(etiquetas_glo[pos]).index(bo) items_son.append(LegendItem(label=a, renderers=[r], index=color_)) bo = bo + 1 legend.items = items_son plot.add_layout(legend) slider = Slider(start=0, end=11, value=0, step=1, title="periodo") slider.on_change('value', slider_update) callback_id = None def animate(): global callback_id if button.label == '► Play': button.label = '❚❚ Pause' callback_id = curdoc().add_periodic_callback(animate_update, 1000) else: button.label = '► Play' curdoc().remove_periodic_callback(callback_id) button = Button(label='► Play', width=60) button.on_click(animate) layout_plot = layout([ [plot], [slider, button], ]) curdoc().add_root(layout_plot) curdoc().title = "Transactional" return None
source=source, line_width=3, line_alpha=0.6) ticker = SingleIntervalTicker(interval=1, num_minor_ticks=0) xaxis = LinearAxis(ticker=ticker, axis_label='y index') plot.add_layout(xaxis, 'below') samples_slider = Slider(start=3, end=20, value=10, step=1, title="Number of points") given_slider = Slider(start=0, end=1, value=.1, step=.1, title="% of given points") theta1_slider = Slider(start=0.01, end=1, value=.12, step=.01, title="Theta_1") resample_Button = Button(label="Resample unknowns") samples_slider.on_change('value', lambda attr, old, new: new_givens()) given_slider.on_change('value', lambda attr, old, new: given_wrapper(old, new)) theta1_slider.on_change('value', lambda attr, old, new: resample_wrapper()) resample_Button.on_click(lambda: resample_wrapper()) controls = [samples_slider, given_slider, theta1_slider, resample_Button] inputs = widgetbox(*controls, sizing_mode='fixed') l = gridplot([[inputs], [plot]]) resample_wrapper() curdoc().add_root(l)
def fun_change(attrname, old, new): f_str = f_input.value f_fun, f_sym = string_to_function_parser(f_str, ['x']) print(derivative_input.value) df_sym = diff(f_sym, 'x', int(derivative_input.value)) df_fun = sym_to_function_parser(df_sym, ['x']) x = np.linspace(-5, 5, 100) y = f_fun(x) dy = df_fun(x) line_source.data = dict(x=x, y=y, dy=dy) def init_data(): fun_change(None, None, None) # Plotting plot = Figure(title="function plotter", x_range=[-5, 5], y_range=[-5, 5]) plot.line(x='x', y='y', source=line_source, color='red', legend='f(x)') plot.line(x='x', y='dy', source=line_source, color='blue', legend='df^n(x)') #Callback f_input.on_change('value', fun_change) derivative_input.on_change('value', fun_change) init_data() #Layout curdoc().add_root(row(plot, column(f_input, derivative_input)))
def produce_scatter_on_background(self, context, doc): # Interesting error, background doesn't seem to update after running multiple instances # to the latest version and starts off with the data the first instance was given. # Need to figure out why! # Port to connect to master port = 5000 #socket = context.socket(zmq.SUB) socket = context.socket(zmq.REQ) # MUST BE FROM SAME MACHINE, CHANGE IF NECESSARY!!! socket.connect("tcp://localhost:%d" % port) #socket.setsockopt(zmq.SUBSCRIBE, b"") # Dynamic Map dmapBackground = hv.DynamicMap(gen_background, streams=[self.streamContour]) dmapScatter = hv.DynamicMap(gen_scatter, streams=[self.streamScatter]) overlay = (dmapBackground*dmapScatter).options(show_legend=False).opts(norm=dict(axiswise=True)) # Render plot with bokeh hvplot = renderer.get_plot(overlay, doc) def scatter_tick(): """ Push new scatter points into stream to plot. """ # Still has the freezing points error, though, it seems to come more frequently. # This may be a bigger problem now #if socket.poll(timeout=0): socket.send_string("Hello") print("Oof") data_dict = socket.recv_pyobj() peakDict = data_dict['peakDict'] peakTSDict = data_dict['peakTSDict'] self.ipm2_plot = list(peakDict['peak_8']) self.ipm3_plot = list(peakDict['peak_9']) self.ebeam_plot = list(peakDict['peak_10']) self.ipm2TS_plot = list(peakTSDict['peak_8_TS']) self.ipm3TS_plot = list(peakTSDict['peak_9_TS']) self.ebeamTS_plot = list(peakTSDict['peak_10_TS']) ipm2Data = pd.Series(self.ipm2_plot[-self.limit:], index=self.ipm2TS_plot[-self.limit:]) ipm3Data = pd.Series(self.ipm3_plot[-self.limit:], index=self.ipm3TS_plot[-self.limit:]) ebeamData = pd.Series(self.ebeam_plot[-self.limit:], index=self.ebeamTS_plot[-self.limit:]) zipped = basic_event_builder(ipm2=ipm2Data, ipm3=ipm3Data, ebeam=ebeamData) scatterList = zipped data = scatterList[['ebeam', self.switch_key]] self.paused_list = scatterList self.streamScatter.event(df=data) def limit_update(attr, old, new): """ Update limit slider value """ self.limit = limitSlider.value def switch(attr, old, new): """ Update drop down menu value """ self.switch_key = select.value def switch_background(attr, old, new): """ Switch background when drop down menu value is updated """ data = self.curBackData[['ebeam', self.switch_key]] self.streamContour.event(df=data) def switch_on_pause(attr, old, new): if startButton.label == '► Play': self.streamScatter.event(df=self.paused_list[['ebeam', self.switch_key]]) # Scatter plot may freeze when update background occurs? def update_background(): """ Update background with most updated data when update button is pressed """ newData = pd.read_csv('data_class.csv', index_col='Unnamed: 0') self.curBackData = newData data = newData[['ebeam', self.switch_key]] self.streamContour.event(df=data) def play_graph(): """ Provide play and pause functionality to the graph """ if startButton.label == '► Play': startButton.label = '❚❚ Pause' self.callback_id_scatter = doc.add_periodic_callback(scatter_tick, 1000) else: startButton.label = '► Play' doc.remove_periodic_callback(self.callback_id_scatter) # Continuously update scatter plot self.callback_id_scatter = doc.add_periodic_callback(scatter_tick, 1000) # Create widgets limitSlider = Slider(start=10, end=1000, value=50, step=1, title="Number of Events") limitSlider.on_change('value', limit_update) startButton = Button(label='❚❚ Pause') startButton.on_click(play_graph) select = Select(title="ipm value:", value="ipm2", options=["ipm2", "ipm3"]) select.on_change('value', switch) select.on_change('value', switch_background) select.on_change('value', switch_on_pause) updateButton = Button(label='Update', width=60) updateButton.on_click(update_background) plot = layout([[hvplot.state], widgetbox([limitSlider, select, updateButton, startButton], sizing_mode='stretch_both')]) doc.title = "Reference Graph" doc.add_root(plot)
def create_interact_ui(doc): fig_tpf, stretch_slider = self._make_echelle_elements( dnu, maximum_frequency=maximum_frequency, minimum_frequency=minimum_frequency, **kwargs ) maxdnu = self.periodogram.frequency.max().value / 5 # Interactive slider widgets dnu_slider = Slider( start=0.01, end=maxdnu, value=dnu.value, step=0.01, title="Delta Nu", width=290, ) r_button = Button(label=">", button_type="default", width=30) l_button = Button(label="<", button_type="default", width=30) rr_button = Button(label=">>", button_type="default", width=30) ll_button = Button(label="<<", button_type="default", width=30) def update(attr, old, new): """Callback to take action when dnu slider changes""" dnu = SeismologyQuantity( quantity=dnu_slider.value * u.microhertz, name="deltanu", method="echelle", ) ep, _, _ = self._clean_echelle( deltanu=dnu, minimum_frequency=minimum_frequency, maximum_frequency=maximum_frequency, **kwargs ) fig_tpf.select("img")[0].data_source.data["image"] = [ep.value] fig_tpf.xaxis.axis_label = r"Frequency / {:.3f} Mod. 1".format(dnu) def go_right_by_one_small(): """Step forward in time by a single cadence""" existing_value = dnu_slider.value if existing_value < maxdnu: dnu_slider.value = existing_value + 0.002 def go_left_by_one_small(): """Step back in time by a single cadence""" existing_value = dnu_slider.value if existing_value > 0: dnu_slider.value = existing_value - 0.002 def go_right_by_one(): """Step forward in time by a single cadence""" existing_value = dnu_slider.value if existing_value < maxdnu: dnu_slider.value = existing_value + 0.01 def go_left_by_one(): """Step back in time by a single cadence""" existing_value = dnu_slider.value if existing_value > 0: dnu_slider.value = existing_value - 0.01 dnu_slider.on_change("value", update) r_button.on_click(go_right_by_one_small) l_button.on_click(go_left_by_one_small) rr_button.on_click(go_right_by_one) ll_button.on_click(go_left_by_one) widgets_and_figures = layout( [fig_tpf, [Spacer(height=20), stretch_slider]], [ ll_button, Spacer(width=30), l_button, Spacer(width=25), dnu_slider, Spacer(width=30), r_button, Spacer(width=23), rr_button, ], ) doc.add_root(widgets_and_figures)
hour1 = Slider(title="hour", value=0, start=0, end=96, step=1) # Set up callbacks def update_title(attrname, old, new): plot.title.text = text.value text.on_change('value', update_title) def update_data(attrname, old, new): # Get the current slider values # a = amplitude.value h = hour1.value # Generate the new plot x = hourwise[h]['source'] y = hourwise[h]['number'] source.data = dict(x=x, y=y) hour1.on_change('value', update_data) # Set up layouts and add to document inputs = column(hour1, text) curdoc().add_root(row(inputs, plot, width=800)) curdoc().title = "Sliders"
source_views.data = new_data_views # Make a slider object: slider min_timestamp = min(df_tx['ttimestamp'].min(), df_views['ttimestamp'].min()) max_timestamp = max(df_tx['ttimestamp'].max(), df_views['ttimestamp'].max()) slider_time = Slider(start=0, end=max_timestamp - min_timestamp, step=3600, value=0, title='Timestamp', format="{://360}") # Attach the callback to the 'value' property of slider slider_time.on_change('value', update_plot_time) tab1 = Panel(child=p1, title="Map") p2 = figure(plot_width=500, plot_height=500) bin_number = (lambda x: 96 * (x - min_timestamp) // (max_timestamp - min_timestamp)) df_tx['bin'] = df_tx['ttimestamp'].apply(bin_number) df_tx_binned = df_tx.groupby('bin').count() p2.line(df_tx_binned.index, df_tx_binned['ttimestamp'], legend="transactions", color="blue") df_views['bin'] = df_views['ttimestamp'].apply(bin_number)
def update_data(attrname, old, new): k = gsmooth.value print("Gaussian filter : ", k) img = cv2.imread('../../Bokeh/server_folder/static/image1.jpeg') gaussian = cv2.GaussianBlur(img, (k, k), 0) os.chdir(directory) cv2.imwrite('gaussian.jpeg', gaussian) cv2.imwrite('image1.jpeg', gaussian) os.chdir(directory1) img_path = 'server_folder/static/gaussian.jpeg' url = img_path source.data = dict(url=[url]) gsmooth.on_change('value', update_data) ######################################################################################################## ################################Median Filter########################################################### def callback1(event): image = cv2.imread('../../Bokeh/server_folder/static/image1.jpeg') median = cv2.medianBlur(image, 5) os.chdir(directory) cv2.imwrite('median.jpeg', median) cv2.imwrite('image1.jpeg', median) os.chdir(directory1) img_path = 'server_folder/static/median.jpeg' url = img_path
def create_interact_ui(doc): # The data source includes metadata for hover-over tooltips lc_source = prepare_lightcurve_datasource(lc) tpf_source = prepare_tpf_datasource(tpf, aperture_mask) # Create the lightcurve figure and its vertical marker fig_lc, vertical_line = make_lightcurve_figure_elements(lc, lc_source) # Create the TPF figure and its stretch slider pedestal = np.nanmin(tpf.flux) fig_tpf, stretch_slider = make_tpf_figure_elements(tpf, tpf_source, pedestal=pedestal) # Helper lookup table which maps cadence number onto flux array index. tpf_index_lookup = {cad: idx for idx, cad in enumerate(tpf.cadenceno)} # Interactive slider widgets and buttons to select the cadence number cadence_slider = Slider(start=np.min(tpf.cadenceno), end=np.max(tpf.cadenceno), value=np.min(tpf.cadenceno), step=1, title="Cadence Number", width=490) r_button = Button(label=">", button_type="default", width=30) l_button = Button(label="<", button_type="default", width=30) export_button = Button(label="Save Lightcurve", button_type="success", width=120) message_on_save = Div(text=' ', width=600, height=15) # Callbacks def update_upon_pixel_selection(attr, old, new): """Callback to take action when pixels are selected.""" # Check if a selection was "re-clicked", then de-select if ((sorted(old) == sorted(new)) & (new != [])): # Trigger recursion tpf_source.selected.indices = new[1:] if new != []: selected_indices = np.array(new) selected_mask = np.isin(pixel_index_array, selected_indices) lc_new = tpf.to_lightcurve(aperture_mask=selected_mask) lc_source.data['flux'] = lc_new.flux ylims = get_lightcurve_y_limits(lc_source) fig_lc.y_range.start = ylims[0] fig_lc.y_range.end = ylims[1] else: lc_source.data['flux'] = lc.flux * 0.0 fig_lc.y_range.start = -1 fig_lc.y_range.end = 1 message_on_save.text = " " export_button.button_type = "success" def update_upon_cadence_change(attr, old, new): """Callback to take action when cadence slider changes""" if new in tpf.cadenceno: frameno = tpf_index_lookup[new] fig_tpf.select('tpfimg')[0].data_source.data['image'] = \ [tpf.flux[frameno, :, :] - pedestal] vertical_line.update(location=tpf.time[frameno]) else: fig_tpf.select('tpfimg')[0].data_source.data['image'] = \ [tpf.flux[0, :, :] * np.NaN] lc_source.selected.indices = [] def go_right_by_one(): """Step forward in time by a single cadence""" existing_value = cadence_slider.value if existing_value < np.max(tpf.cadenceno): cadence_slider.value = existing_value + 1 def go_left_by_one(): """Step back in time by a single cadence""" existing_value = cadence_slider.value if existing_value > np.min(tpf.cadenceno): cadence_slider.value = existing_value - 1 def save_lightcurve(): """Save the lightcurve as a fits file with mask as HDU extension""" if tpf_source.selected.indices != []: selected_indices = np.array(tpf_source.selected.indices) selected_mask = np.isin(pixel_index_array, selected_indices) lc_new = tpf.to_lightcurve(aperture_mask=selected_mask) lc_new.to_fits(exported_filename, overwrite=True, aperture_mask=selected_mask.astype(np.int), SOURCE='lightkurve interact', NOTE='custom mask', MASKNPIX=np.nansum(selected_mask)) if message_on_save.text == " ": text = '<font color="black"><i>Saved file {} </i></font>' message_on_save.text = text.format(exported_filename) export_button.button_type = "success" else: text = '<font color="gray"><i>Saved file {} </i></font>' message_on_save.text = text.format(exported_filename) else: text = '<font color="gray"><i>No pixels selected, no mask saved</i></font>' export_button.button_type = "warning" message_on_save.text = text def jump_to_lightcurve_position(attr, old, new): if new != []: cadence_slider.value = lc.cadenceno[new[0]] # Map changes to callbacks r_button.on_click(go_right_by_one) l_button.on_click(go_left_by_one) tpf_source.selected.on_change('indices', update_upon_pixel_selection) lc_source.selected.on_change('indices', jump_to_lightcurve_position) export_button.on_click(save_lightcurve) cadence_slider.on_change('value', update_upon_cadence_change) # Layout all of the plots sp1, sp2, sp3, sp4 = (Spacer(width=15), Spacer(width=30), Spacer(width=80), Spacer(width=60)) widgets_and_figures = layout([fig_lc, fig_tpf], [ l_button, sp1, r_button, sp2, cadence_slider, sp3, stretch_slider ], [export_button, sp4, message_on_save]) doc.add_root(widgets_and_figures)
# Création du set de donnée à afficher displaySet = select_data(dataCities,ogCity,dist) ### Construction du front-end ### # Ajout d'un slider pour choisir l'année slider_yr = Slider(title = 'Année', start = data_yr[0], end = data_yr[-1], step = 1, value = data_yr[-1], default_size = 250 ) slider_yr.on_change('value', update_yr) # Ajout d'un slider pour choisir la distance d'affichage slider_dst = Slider(title = 'Distance d\'affichage (km)', start = 0, end = 100, step = 5, value = dist, default_size = 250 ) slider_dst.on_change('value', update_dst) # Ajout d'un sélecteur pour choisir l'impot à afficher select_imp = Select(title="Impôt:", value="Taxe d'habitation", options=["Taxe d'habitation", "Taxe foncière"]
return b # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def update(attr, old, new): print(attr, "**", old, "**", new) layout.children[0].children[0] = create_map() layout.children[1].children[0] = create_chart() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # WIDGETS # Position Control zoom = Slider(start=10, end=15, value=11, step=1, title="Zoom") zoom.on_change('value', update) lat = Slider(start=36, end=36.24, value=36.1200, step=.02, title="Lat Position") lat.on_change('value', update) lon = Slider(start=-115.30, end=-115.06, value=-115.18, step=.02, title="Lon Position") lon.on_change('value', update) # Time Control days_options = RadioButtonGroup(
def init(): t = slider.value m = .5 x = np.linspace(0,1) y = m*x+t plot_data.data = dict(x=x.tolist(),y=y.tolist()) # initialize data source plot_data = ColumnDataSource(data=dict(x=[], y=[])) # initialize controls slider = Slider(title="a", name='a', value=.5, start=0, end=1, step=.1) slider.on_change('value', callback_function) # initialize plot toolset = "crosshair,pan,reset,resize,wheel_zoom,box_zoom" # Generate a figure container plot = Figure(plot_height=400, plot_width=400, tools=toolset, title="Time dependent PDEs", x_range=[0,1], y_range=[0,1] ) # Plot the numerical solution at time=t by the x,u values in the source property plot.line('x', 'y', source=plot_data, line_width=.5,
def gen_bokeh( df, il_center=(3879662.3653308493, 3694724.561061665), marg_x=2.0e5, marg_y=2.0e5, init_date=datetime.datetime(year=2021, month=5, day=10), MAX_W=1000, MAX_H=800, ): # main figure with world map tile_provider = get_provider(CARTODBPOSITRON) p = figure(x_range=(il_center[0] - marg_x, il_center[0] + marg_x), y_range=(il_center[1] - marg_y, il_center[1] + marg_y), x_axis_type="mercator", y_axis_type="mercator") p.plot_height = MAX_H // 2 p.plot_width = MAX_W p.add_tile(tile_provider) # process df for plotting df['mydate'] = pd.to_datetime(df['date']) df = df.loc[df['mydate'] > init_date] merc = longlat2mercator.transform(df['lat'].values, df['long'].values) df['x'] = merc[0] df['y'] = merc[1] df['name'] = df['location'] df[['x', 'y', 'mydate_f', 'name']] = df[['x', 'y', 'mydate', 'name']].fillna('') df['fill_alpha'] = .5 df['line_alpha'] = .0 df['fill_color'] = df['eta'].apply(eta2color) src_cols = [ 'x', 'y', 'mydate_f', 'name', 'fill_alpha', 'line_alpha', 'fill_color' ] source0 = df[src_cols].to_dict('list') source = ColumnDataSource(data=source0) # add alarms on map p.circle(x="x", y="y", size=4, fill_color="fill_color", fill_alpha='fill_alpha', line_alpha='line_alpha', source=source) p.add_tools( HoverTool( tooltips=[ ('time', '@mydate_f{%H:%M}'), ('date', '@mydate_f{%d/%m/%Y}'), ('name', '@name'), ], formatters={'@mydate_f': 'datetime'}, )) # build other elements date_slider = DateSlider(start=df['mydate'].min(), end=date.today(), step=24, value=date.today(), title='Date', width=int(MAX_W * .9)) dur_slider = Slider(start=0, end=168, step=1, value=24, title='Hour duration', width=MAX_W // 2) delay_slider = Slider(start=0, end=1000, step=10, value=200, title='Animation delay (ms)', width=MAX_W // 2) label_xy = longlat2mercator.transform(31., 34) label_src = ColumnDataSource(data=dict(text=['Hello, use the sliders'])) label = LabelSet(text='text', x=label_xy[0], y=label_xy[1], source=label_src) p.add_layout(label) button = Button(label="Play", button_type="success", width=MAX_W // 10) # add plot for number of alarms per day ff = figure(x_range=(df['mydate_f'].min(), df['mydate_f'].max()), x_axis_type="datetime") df['day'] = df['mydate_f'].dt.day agg = df.groupby('day').agg('count') agg['date'] = agg.index.to_series().apply( lambda x: df.loc[df['mydate_f'].dt.day == x, 'mydate_f'].iloc[0]) ff.scatter(agg['date'], agg['Unnamed: 0'], size=10) ff.plot_height = MAX_H // 3 ff.plot_width = MAX_W ff.title = 'alarms per day' # callback functions callback_id = None def update_map_callback(attr, old, new): st, en = date_slider.value, date_slider.value + dur_slider.value * 60 * 60 * 1000 st = datetime.datetime.fromtimestamp(st / 1000.) en = datetime.datetime.fromtimestamp(en / 1000.) ddf = df.loc[(df['mydate_f'] >= st) & (df['mydate_f'] < en)] source.data = ddf[src_cols].to_dict('list') sts = st.strftime("%d/%m, %H:%M") ens = en.strftime("%d/%m, %H:%M") label_src.data = dict( text=[f'Range: {sts} to {ens}, total: {len(ddf)}']) def restart_animation(attr, old, new): global callback_id if button.label == 'Stop': curdoc().remove_periodic_callback(callback_id) callback_id = curdoc().add_periodic_callback( adv_slider, delay_slider.value) def adv_slider(): date_slider.value += 1 * 1000 * 60 * 60 if date_slider.value >= date_slider.end: date_slider.value = date_slider.start def button_callback(): global callback_id if button.label == 'Play': button.label = 'Stop' callback_id = curdoc().add_periodic_callback( adv_slider, delay_slider.value) else: button.label = 'Play' curdoc().remove_periodic_callback(callback_id) # callback assignment delay_slider.on_change('value', restart_animation) date_slider.on_change('value', update_map_callback) dur_slider.on_change('value', update_map_callback) button.on_click(button_callback) lay = column(p, row(date_slider, button), row(dur_slider, delay_slider), ff) return lay
def create_layout(self): # create figure self.x_range = Range1d(start=self.model.map_extent[0], end=self.model.map_extent[2], bounds=None) self.y_range = Range1d(start=self.model.map_extent[1], end=self.model.map_extent[3], bounds=None) self.fig = Figure(tools='wheel_zoom,pan', x_range=self.x_range, lod_threshold=None, plot_width=self.model.plot_width, plot_height=self.model.plot_height, y_range=self.y_range) self.fig.min_border_top = 0 self.fig.min_border_bottom = 10 self.fig.min_border_left = 0 self.fig.min_border_right = 0 self.fig.axis.visible = False self.fig.xgrid.grid_line_color = None self.fig.ygrid.grid_line_color = None # add tiled basemap self.tile_source = WMTSTileSource(url=self.model.basemap) self.tile_renderer = TileRenderer(tile_source=self.tile_source) self.fig.renderers.append(self.tile_renderer) # add datashader layer self.image_source = ImageSource(url=self.model.service_url, extra_url_vars=self.model.shader_url_vars) self.image_renderer = DynamicImageRenderer(image_source=self.image_source) self.fig.renderers.append(self.image_renderer) # add label layer self.label_source = WMTSTileSource(url=self.model.labels_url) self.label_renderer = TileRenderer(tile_source=self.label_source) self.fig.renderers.append(self.label_renderer) # Add a hover tool self.invisible_square = Square(x='x', y='y', fill_color=None, line_color=None, size=self.model.hover_size) self.visible_square = Square(x='x', y='y', fill_color='#79DCDE', fill_alpha=.5, line_color='#79DCDE', line_alpha=1, size=self.model.hover_size) cr = self.fig.add_glyph(self.model.hover_source, self.invisible_square, selection_glyph=self.visible_square, nonselection_glyph=self.invisible_square) code = "source.set('selected', cb_data['index']);" callback = CustomJS(args={'source': self.model.hover_source}, code=code) self.model.hover_tool = HoverTool(tooltips=[(self.model.fields.keys()[0], "@value")], callback=callback, renderers=[cr], mode='mouse') self.fig.add_tools(self.model.hover_tool) self.model.legend_side_vbox = VBox() self.model.legend_bottom_vbox = VBox() # add ui components controls = [] axes_select = Select.create(name='Axes', options=self.model.axes) axes_select.on_change('value', self.on_axes_change) controls.append(axes_select) self.field_select = Select.create(name='Field', options=self.model.fields) self.field_select.on_change('value', self.on_field_change) controls.append(self.field_select) self.aggregate_select = Select.create(name='Aggregate', options=self.model.aggregate_functions) self.aggregate_select.on_change('value', self.on_aggregate_change) controls.append(self.aggregate_select) transfer_select = Select.create(name='Transfer Function', options=self.model.transfer_functions) transfer_select.on_change('value', self.on_transfer_function_change) controls.append(transfer_select) color_ramp_select = Select.create(name='Color Ramp', options=self.model.color_ramps) color_ramp_select.on_change('value', self.on_color_ramp_change) controls.append(color_ramp_select) spread_size_slider = Slider(title="Spread Size (px)", value=0, start=0, end=10, step=1) spread_size_slider.on_change('value', self.on_spread_size_change) controls.append(spread_size_slider) hover_size_slider = Slider(title="Hover Size (px)", value=8, start=4, end=30, step=1) hover_size_slider.on_change('value', self.on_hover_size_change) controls.append(hover_size_slider) controls.append(self.model.legend_side_vbox) # add map components basemap_select = Select.create(name='Basemap', value='Imagery', options=self.model.basemaps) basemap_select.on_change('value', self.on_basemap_change) image_opacity_slider = Slider(title="Opacity", value=100, start=0, end=100, step=1) image_opacity_slider.on_change('value', self.on_image_opacity_slider_change) basemap_opacity_slider = Slider(title="Basemap Opacity", value=100, start=0, end=100, step=1) basemap_opacity_slider.on_change('value', self.on_basemap_opacity_slider_change) show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0]) show_labels_chk.on_click(self.on_labels_change) map_controls = [basemap_select, basemap_opacity_slider, image_opacity_slider, show_labels_chk] self.controls = VBox(width=200, height=600, children=controls) self.map_controls = HBox(width=self.fig.plot_width, children=map_controls) self.map_area = VBox(width=self.fig.plot_width, children=[self.map_controls, self.fig, self.model.legend_bottom_vbox]) self.layout = HBox(width=1366, children=[self.controls, self.map_area])
def create_layout(self): # create figure self.x_range = Range1d(start=self.model.map_extent[0], end=self.model.map_extent[2], bounds=None) self.y_range = Range1d(start=self.model.map_extent[1], end=self.model.map_extent[3], bounds=None) self.fig = Figure(tools='wheel_zoom,pan', x_range=self.x_range, lod_threshold=None, plot_width=self.model.plot_width, plot_height=self.model.plot_height, y_range=self.y_range) self.fig.min_border_top = 0 self.fig.min_border_bottom = 10 self.fig.min_border_left = 0 self.fig.min_border_right = 0 self.fig.axis.visible = False self.fig.xgrid.grid_line_color = None self.fig.ygrid.grid_line_color = None # add tiled basemap self.tile_source = WMTSTileSource(url=self.model.basemap) self.tile_renderer = TileRenderer(tile_source=self.tile_source) self.fig.renderers.append(self.tile_renderer) # add datashader layer self.image_source = ImageSource(url=self.model.service_url, extra_url_vars=self.model.shader_url_vars) self.image_renderer = DynamicImageRenderer(image_source=self.image_source) self.fig.renderers.append(self.image_renderer) # add label layer self.label_source = WMTSTileSource(url=self.model.labels_url) self.label_renderer = TileRenderer(tile_source=self.label_source) self.fig.renderers.append(self.label_renderer) # Add a hover tool hover_layer = HoverLayer() hover_layer.field_name = self.model.field_title hover_layer.is_categorical = self.model.field in self.model.categorical_fields self.fig.renderers.append(hover_layer.renderer) self.fig.add_tools(hover_layer.tool) self.model.hover_layer = hover_layer self.model.legend_side_vbox = VBox() self.model.legend_bottom_vbox = VBox() # add ui components controls = [] axes_select = Select.create(name='Axes', options=self.model.axes) axes_select.on_change('value', self.on_axes_change) controls.append(axes_select) self.field_select = Select.create(name='Field', options=self.model.fields) self.field_select.on_change('value', self.on_field_change) controls.append(self.field_select) self.aggregate_select = Select.create(name='Aggregate', options=self.model.aggregate_functions) self.aggregate_select.on_change('value', self.on_aggregate_change) controls.append(self.aggregate_select) transfer_select = Select.create(name='Transfer Function', options=self.model.transfer_functions) transfer_select.on_change('value', self.on_transfer_function_change) controls.append(transfer_select) color_ramp_select = Select.create(name='Color Ramp', options=self.model.color_ramps) color_ramp_select.on_change('value', self.on_color_ramp_change) controls.append(color_ramp_select) spread_size_slider = Slider(title="Spread Size (px)", value=0, start=0, end=10, step=1) spread_size_slider.on_change('value', self.on_spread_size_change) controls.append(spread_size_slider) hover_size_slider = Slider(title="Hover Size (px)", value=8, start=4, end=30, step=1) hover_size_slider.on_change('value', self.on_hover_size_change) controls.append(hover_size_slider) controls.append(self.model.legend_side_vbox) # add map components basemap_select = Select.create(name='Basemap', value='Imagery', options=self.model.basemaps) basemap_select.on_change('value', self.on_basemap_change) image_opacity_slider = Slider(title="Opacity", value=100, start=0, end=100, step=1) image_opacity_slider.on_change('value', self.on_image_opacity_slider_change) basemap_opacity_slider = Slider(title="Basemap Opacity", value=100, start=0, end=100, step=1) basemap_opacity_slider.on_change('value', self.on_basemap_opacity_slider_change) show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0]) show_labels_chk.on_click(self.on_labels_change) map_controls = [basemap_select, basemap_opacity_slider, image_opacity_slider, show_labels_chk] self.controls = VBox(width=200, height=600, children=controls) self.map_controls = HBox(width=self.fig.plot_width, children=map_controls) self.map_area = VBox(width=self.fig.plot_width, children=[self.map_controls, self.fig, self.model.legend_bottom_vbox]) self.layout = HBox(width=1366, children=[self.controls, self.map_area])
import pandas as pd import numpy as np from bokeh.io import curdoc from bokeh.plotting import Figure, output_file, show from bokeh.models import ColumnDataSource, Slider from bokeh.layouts import column COUNT = 10 df = pd.DataFrame({"x": np.random.rand(COUNT), "y": np.random.rand(COUNT), "radius": 0.05}) source = ColumnDataSource(df) fig = Figure() fig.circle(source=source, x="x", y="y", fill_color="red", line_color="black", radius="radius") slider = Slider(start=1, end=10, step=0.1, value=5) def update_size(attrname, old, new): source.data["radius"] = [slider.value / 100.0] * COUNT slider.on_change("value", update_size) curdoc().add_root(column(fig, slider))
updata_analytical_solution() update_mesh(h, k) # initialize data source plot_data_num = ColumnDataSource(data=dict(x=[], u=[])) plot_data_ana = ColumnDataSource(data=dict(x=[],u=[])) mesh_data = ColumnDataSource(data=dict()) pde_specs = ColumnDataSource(data=dict(h=[], k=[])) ana_sol = ColumnDataSource(data=dict()) # initialize controls # slider for going though time time_slider = Slider(title="time", name='time', value=pde_settings.t_init, start=pde_settings.t_min, end=pde_settings.t_max, step=pde_settings.t_step) time_slider.on_change('value', time_change) # slider controlling spatial stepsize of the solver h_slider = Slider(title="spatial meshwidth", name='spatial meshwidth', value=pde_settings.h_init, start=pde_settings.h_min, end=pde_settings.h_max, step=pde_settings.h_step) h_slider.on_change('value', mesh_change) # slider controlling spatial stepsize of the solver k_slider = Slider(title="temporal meshwidth", name='temporal meshwidth', value=pde_settings.k_init, start=pde_settings.k_min, end=pde_settings.k_max, step=pde_settings.k_step) k_slider.on_change('value', mesh_change) # radiobuttons controlling pde type pde_type = RadioButtonGroup(labels=['Heat', 'Wave'], active=0) pde_type.on_change('active', pde_type_change) # radiobuttons controlling solver type solver_type = RadioButtonGroup(labels=['Explicit', 'Implicit'], active=0) solver_type.on_change('active', mesh_change) # text input for IC
p.line('t', 'i', source=source) p.xaxis.axis_label='Time [s]' p.yaxis.axis_label='Current [A]' m=figure(plot_width=600, plot_height=400, title='Voltages') m.line('t', 'usupp', source=source, legend='Line voltage', color='orange') m.line('t', 'uc', source=source, legend='Capacitor voltage', color='green') m.xaxis.axis_label='Time [s]' m.yaxis.axis_label='Voltage[V]' m.legend.location = "bottom_left" # widgets Slider_C = Slider(start=0.0001, end=0.01, value=0.01, step=.00001, title="Capacitance [F]") Slider_R = Slider(start=1, end=50, value=5, step=1, title="Resistance [Ohm]") Slider_L = Slider(start=0.001, end=1, value=0.1, step=0.001, title="Inductance [H]") #Slider_Uo = Slider(start=10e3, end=100e3, value=20e3, step=10e3, title="Charging voltage [V]") layout = row(widgetbox(Slider_C, Slider_R, Slider_L), column(p,m)) def callback(attr, old, new): new_C = Slider_C.value new_R = Slider_R.value new_L = Slider_L.value ib, uc2, ub = calRLCcir(R=new_R, L=new_L, C=new_C, alpha=0) source.data = {'t': t, 'i': ib, 'uc': uc2, 'usupp': ub} Slider_C.on_change('value', callback) Slider_R.on_change('value', callback) Slider_L.on_change('value', callback) curdoc().add_root(layout)
plot.xaxis.axis_label_text_font_size = '10pt' plot.yaxis.axis_label="Current [A]" plot.yaxis.axis_label_text_font_size = '10pt' plot.line('t', 'ia', source=source, line_width=3, line_alpha=0.6, legend="Circuit current") plot.line('t', 'iadc', source=source, line_width=2, line_alpha=0.6, color="orange", legend="DC component") plot.line('t', 'iau', source=source, line_width=2, line_alpha=0.6, color="green", legend="AC component") # slider slider = Slider(start=0, end=phi, value=0, step=.1, title="Voltage closing angle [rad]", name="slider") #callback part def callback(attr, old, new): new_alpha = slider.value #Current response ia = [(sqrt(2)*u/(sqrt(R**2+XL**2))*(sin(omega*k+new_alpha-phi)-sin(new_alpha-phi)*exp(-R/L*k))) for k in t] #DC component of the current iadc = [(sqrt(2)*u/(sqrt(R**2+XL**2))*-sin(new_alpha-phi)*(exp(-R/L*k))) for k in t] #AC steady state current iau = [(sqrt(2)*u/(sqrt(R**2+XL**2))*sin(omega*k+new_alpha-phi)) for k in t] # source data update source.data = {'t': t, 'ia': ia, 'iadc': iadc, 'iau': iau} slider.on_change('value', callback) layout = row(slider, plot) curdoc().add_root(layout)
# Add the layout to the current document curdoc().add_root(layout) # Define a callback function: callback def callback(attr, old, new): # Read the current value of the slider: scale scale = slider.value # Compute the updated y using np.sin(scale/x): new_y new_y = np.sin(scale / x) # Update source with the new data values source.data = {'x': x, 'y': new_y} # Attach the callback to the 'value' property of slider slider.on_change('value', callback) # Create layout and add to current document layout = column(widgetbox(slider), plot) curdoc().add_root(layout) # Perform necessary imports from bokeh.models import ColumnDataSource, Select # Create ColumnDataSource: source source = ColumnDataSource(data={'x': fertility, 'y': female_literacy}) # Create a new plot: plot plot = figure() # Add circles to the plot
width=250) def update_k_clusters(attrname, old, new): k_cluster = int(k_slider.value) brc = Birch(branching_factor=50, n_clusters=k_cluster, threshold=0.5, compute_labels=True) brc.fit(tweet_vecs) predictions = brc.predict(tweet_vecs) colors = get_colors(predictions) brc_data.data = dict(colors=colors, x=tsne_vecs[:, 0], y=tsne_vecs[:, 1]) k_slider.on_change('value', update_k_clusters) def update_s_clusters(attrname, old, new): k_cluster = int(k_slider.value) km = KMeans(n_clusters=k_cluster, random_state=0) km.fit(tweet_vecs) predictions = km.predict(tweet_vecs) colors = get_colors(predictions) km_data.data = dict(colors=colors, x=tsne_vecs[:, 0], y=tsne_vecs[:, 1]) s_slider.on_change('value', update_s_clusters) inputs = widgetbox(k_slider) l = layout([row(column(brc_plot, k_slider), column(km_plot, s_slider))])
doc = curdoc() x = np.linspace(0, 2, 1000) y = 1 - (x-1)**2 source = ColumnDataSource(data=dict(x=x, y=y)) p = figure(title="initial title") p.circle(x=1, y=list(range(0, 11))) p.line('x', 'y', color="orange", source=source) slider = Slider(start=0, end=10, step=0.1, value=1) def scb(attr, old, new): source.data['y'] = new * y slider.on_change('value', scb) combine = Button(label="hold combine") combine.on_event(ButtonClick, lambda event: doc.hold("combine")) collect = Button(label="hold collect") collect.on_event(ButtonClick, lambda event: doc.hold("collect")) unhold = Button(label="unhold") unhold.on_event(ButtonClick, lambda event: doc.unhold()) doc.add_root(column(p, slider, combine, collect, unhold)) @repeat(np.linspace(0, 10, 100)) def update(v): slider.value = v
text='Your score for {} dataset {} is: {} pts!'.format(diff,datasetNum,score) ) difficultySelect.on_change('value',on_dataSelect) easySelect.on_change('value',on_dataSelect) mediumSelect.on_change('value',on_dataSelect) hardSelect.on_change('value',on_dataSelect) modelTypeSelect.on_change('value',on_modelChange) noiseSelect.on_change('value',on_modelChange) monoSelect.on_change('value',on_modelChange) coalSelect.on_change('value',on_modelChange) burstSelect.on_change('value',on_modelChange) xSlider.on_change('value',on_modelChange) goButton.on_click(on_goButton) #Layout of webpage------------------------------------------------------------ layoutList = [ [description], [fig], [[difficultySelect,easySelect],[modelTypeSelect,noiseSelect],[xSlider,goButton, results]], [endBits] ]
plot.title = algorithm def update_samples_or_dataset(attrname, old, new): global X, y dataset = dataset_select.value algorithm = algorithm_select.value n_clusters = int(clusters_slider.value) n_samples = int(samples_slider.value) X, y = get_dataset(dataset, n_samples) X, y_pred = clustering(X, algorithm, n_clusters) colors = [spectral[i] for i in y_pred] source.data['x'] = X[:, 0] source.data['y'] = X[:, 1] source.data['colors'] = colors algorithm_select.on_change('value', update_algorithm_or_clusters) clusters_slider.on_change('value', update_algorithm_or_clusters) dataset_select.on_change('value', update_samples_or_dataset) samples_slider.on_change('value', update_samples_or_dataset) # set up layout selects = HBox(dataset_select, algorithm_select) inputs = VBox(samples_slider, clusters_slider, selects) # add to document curdoc().add_root(HBox(inputs, plot))
value=0, step=10, title="Land Cost Adjustment") sorghum_c2_slider = Slider(start=-50, end=40, value=0, step=10, title="Nitrogen Fertilizer Cost Adjustment") sorghum_p_slider = Slider(start=-50, end=40, value=0, step=10, title="Crop Price Adjustment") # Get the values from the sliders cassava_c1_slider.on_change('value', update_data) cassava_c2_slider.on_change('value', update_data) cassava_p_slider.on_change('value', update_data) groundnuts_c1_slider.on_change('value', update_data) groundnuts_c2_slider.on_change('value', update_data) groundnuts_p_slider.on_change('value', update_data) maize_c1_slider.on_change('value', update_data) maize_c2_slider.on_change('value', update_data) maize_p_slider.on_change('value', update_data) sesame_c1_slider.on_change('value', update_data) sesame_c2_slider.on_change('value', update_data) sesame_p_slider.on_change('value', update_data)
Attach the callback to the 'value' property of slider. This can be done using on_change() and passing in 'value' and update_plot. Make a row layout of widgetbox(slider) and plot and add it to the current document. ''' # Import the necessary modules from bokeh.layouts import widgetbox, row from bokeh.models import Slider # Define the callback function: update_plot def update_plot(attr, old, new): # set the `yr` name to `slider.value` and `source.data = new_data` yr = slider.value new_data = { 'x' : data.loc[yr].fertility, 'y' : data.loc[yr].life, 'country' : data.loc[yr].Country, 'pop' : (data.loc[yr].population / 20000000) + 2, 'region' : data.loc[yr].region, } source.data = new_data # Make a slider object: slider slider = Slider(start=1970, end=2010, step=1, value=1970, title='Year') # Attach the callback to the 'value' property of slider slider.on_change('value',update_plot) # Make a row layout of widgetbox(slider) and plot and add it to the current document layout = row(widgetbox(slider), plot) curdoc().add_root(layout)
class Document: def __init__(self, time1, granularity, dark_mode): self.time1 = time1 # datetime.datetime(2020, 4, 1) self.time2 = datetime.datetime.now() # utcnow() self.granularity = granularity # '5m' self.dark_mode = dark_mode if self.dark_mode: self.color_green = '#75bb36' self.color_red = '#dd4a4a' self.color_blue = 'light blue' self.color_black = 'white' self.color_gray = 'gray' else: self.color_green = 'green' self.color_red = 'red' self.color_blue = 'blue' self.color_black = 'black' self.color_gray = 'gray' self.days = self.time2 - self.time1 print('days', self.days.days) self.day_slider = Slider(start=0, end=self.days.days, value=self.days.days, step=1, title='Day Selector') self.day_slider.on_change('value', self.select_data) self.raw_data = get_data_bitfinex(self.time1, self.time2, self.granularity) self.time_step = (self.raw_data[1][0] - self.raw_data[0][0]) / 1000 self.day_length = 86400 / self.time_step print('delta (s): ', self.time_step) print('day length: ', self.day_length) print('raw data length: ', len(self.raw_data)) print('actual data start: ', self.day_slider.value * self.day_length) self.green_candles = ColumnDataSource(data={ 'timestamps': [], 'candles_bottom': [], 'candles_top': [] }) self.red_candles = ColumnDataSource(data={ 'timestamps': [], 'candles_bottom': [], 'candles_top': [] }) self.blue_volumes = ColumnDataSource(data={'bins': [], 'volumes': []}) self.actual_line = ColumnDataSource(data={ 'timestamps': [], 'values': [], 'name': [] }) self.gray_volumes = ColumnDataSource(data={ 'timestamps': [], 'volumes': [] }) self.create_candles() self.select_data('value', self.day_slider.value, self.day_slider.value) self.create_candles_plot() self.create_volumes_plot() def create_candles(self): self.segment_y0_green = [] self.segment_y1_green = [] self.segment_y0_red = [] self.segment_y1_red = [] self.vbar_green_x = [] self.vbar_green_top = [] self.vbar_green_bottom = [] self.vbar_red_x = [] self.vbar_red_top = [] self.vbar_red_bottom = [] self.vbar_gray_x = [] self.vbar_gray = [] for each in self.raw_data: self.vbar_gray_x.append(each[0]) self.vbar_gray.append(each[5]) if each[1] < each[2]: self.vbar_green_x.append(each[0]) self.vbar_green_top.append(each[2]) self.vbar_green_bottom.append(each[1]) self.segment_y0_green.append(each[4]) self.segment_y1_green.append(each[3]) else: self.vbar_red_x.append(each[0]) self.vbar_red_top.append(each[2]) self.vbar_red_bottom.append(each[1]) self.segment_y0_red.append(each[4]) self.segment_y1_red.append(each[3]) def select_data_(self): """ initial data select function currently not used :return: """ start_timestamp = self.raw_data[int(self.day_slider.value * self.day_length)][0] print('searchin for timestamp ', start_timestamp) for i in range(len(self.vbar_green_x)): if self.vbar_green_x[i] >= start_timestamp: break print('timestamp found ', self.vbar_green_x[i]) self.green_candles.data = { 'timestamps': self.vbar_green_x[i:-1], 'candles_bottom': self.vbar_green_bottom[i:-1], 'candles_top': self.vbar_green_top[i:-1] } def create_candles_plot(self): self.candles = figure(x_axis_type='datetime') print('volumes: ', max(self.gray_volumes.data['volumes'])) y_start = min(min(self.green_candles.data['segment_min']), min(self.red_candles.data['segment_min'])) y_end = max(max(self.green_candles.data['segment_max']), max(self.red_candles.data['segment_max'])) self.candles.y_range.start = y_start - (y_end - y_start) * 0.15 self.candles.y_range.end = y_end + (y_end - y_start) * 0.05 self.candles.extra_y_ranges = { 'volume_y': Range1d( start=0, end=max(self.gray_volumes.data['volumes']) * 5, ), 'candles_y': Range1d( start=y_start - (y_end - y_start) * 0.15, end=y_end + (y_end - y_start) * 0.05, ) } self.candles.yaxis.visible = False self.candles.add_layout(LinearAxis(y_range_name='candles_y'), 'left') self.candles.vbar( x='timestamps', width=self.time_step * 1000 * 0.7, # 900000, top='volumes', bottom=0, source=self.gray_volumes, fill_color=self.color_gray, line_color=self.color_gray, fill_alpha=0.4, y_range_name='volume_y', ) self.candles.segment( x0='timestamps', y0='segment_min', x1='timestamps', y1='segment_max', source=self.green_candles, color=self.color_green, y_range_name='candles_y', ) self.candles.segment( x0='timestamps', y0='segment_min', x1='timestamps', y1='segment_max', source=self.red_candles, color=self.color_red, y_range_name='candles_y', ) self.candles.vbar( x='timestamps', width=self.time_step * 1000 * 0.7, # 900000, top='candles_top', bottom='candles_bottom', source=self.green_candles, fill_color=self.color_green, line_color=self.color_green, fill_alpha=0.4, y_range_name='candles_y', ) self.candles.vbar( x='timestamps', width=self.time_step * 1000 * 0.7, # 900000, top='candles_top', bottom='candles_bottom', source=self.red_candles, fill_color=self.color_red, line_color=self.color_red, fill_alpha=0.4, y_range_name='candles_y', ) self.candles.line( x='timestamps', y='values', source=self.actual_line, line_color=self.color_black, line_dash='dashed', name='actual_value', legend_field='values', y_range_name='candles_y', ) hover_tool = HoverTool( tooltips=[('time', '@timestamps{%Y-%m-%d %H:%M}'), ('open', '@candles_bottom{(0.0)}'), ('close', '@candles_top{(0.0)}'), ('high', '@segment_max{(0.0)}'), ('low', '@segment_min{(0.0)}'), ('volume', '@volumes{(0.0)}')], formatters={'@timestamps': 'datetime'}, # mode='vline' ) self.candles.add_tools(hover_tool) # self.candles.output_backend = "webgl" print(self.candles.border_fill_color) print(self.candles.background_fill_color) print(self.candles.yaxis[0].major_label_text_color) if self.dark_mode: self.candles.border_fill_color = 'dimgray' self.candles.background_fill_color = '#060606' # '#1f1f1f' # 'dimgray' self.candles.grid.grid_line_color = '#4a4a4a' # 'black' self.candles.yaxis[0].major_label_text_color = 'white' self.candles.yaxis[1].major_label_text_color = 'white' self.candles.xaxis[0].major_label_text_color = 'white' else: self.candles.border_fill_color = '#ffffff' self.candles.background_fill_color = '#ffffff' self.candles.grid.grid_line_color = '#e5e5e5' self.candles.yaxis[0].major_label_text_color = '#444444' self.candles.yaxis[1].major_label_text_color = '#444444' self.candles.xaxis[0].major_label_text_color = '#444444' def create_volumes_plot(self): self.volume_plot = figure() self.volume_plot.hbar( y='bins', height=self.bin_height * 0.7, left=0, right='volumes', source=self.blue_volumes, fill_alpha=0.4, ) hover_tool = HoverTool( tooltips=[('price: ', '@bins{(0)}'), ('volume: ', '@volumes{(0)}')]) self.volume_plot.add_tools(hover_tool) self.volume_plot.sizing_mode = 'stretch_height' if self.dark_mode: self.volume_plot.border_fill_color = 'dimgray' self.volume_plot.background_fill_color = '#060606' # 'dimgray' self.volume_plot.grid.grid_line_color = '#4a4a4a' # 'black' self.volume_plot.yaxis[0].major_label_text_color = 'white' self.volume_plot.xaxis[0].major_label_text_color = 'white' else: self.volume_plot.border_fill_color = '#ffffff' self.volume_plot.background_fill_color = '#ffffff' self.volume_plot.grid.grid_line_color = '#e5e5e5' self.volume_plot.yaxis[0].major_label_text_color = '#444444' self.volume_plot.xaxis[0].major_label_text_color = '#444444' def select_data(self, attr, old, new): """ day_slider value change callback function :param attr: :param old: :param new: :return: """ print('slider value changed: ', new) start_timestamp = self.raw_data[int(self.day_slider.value * self.day_length)][0] try: stop_timestamp = self.raw_data[int( (self.day_slider.value + 1) * self.day_length)][0] except IndexError: stop_timestamp = self.raw_data[-1][0] for i in range(len(self.vbar_green_x)): if self.vbar_green_x[i] >= start_timestamp: break # if self.day_slider.value < self.day_slider.end: for j in range(len(self.vbar_green_x)): if self.vbar_green_x[j] >= stop_timestamp: break self.green_candles.data = { 'timestamps': self.vbar_green_x[i:j + 1], 'candles_bottom': self.vbar_green_bottom[i:j + 1], 'candles_top': self.vbar_green_top[i:j + 1], 'segment_min': self.segment_y0_green[i:j + 1], 'segment_max': self.segment_y1_green[i:j + 1], } for k in range(len(self.vbar_red_x)): if self.vbar_red_x[k] >= start_timestamp: break # if self.day_slider.value < self.day_slider.end: for l in range(len(self.vbar_red_x)): if self.vbar_red_x[l] >= stop_timestamp: break self.red_candles.data = { 'timestamps': self.vbar_red_x[k:l + 1], 'candles_bottom': self.vbar_red_bottom[k:l + 1], 'candles_top': self.vbar_red_top[k:l + 1], 'segment_min': self.segment_y0_red[k:l + 1], 'segment_max': self.segment_y1_red[k:l + 1], } raw_data_start = int(self.day_slider.value * self.day_length) raw_data_stop = int(raw_data_start + self.day_length) self.gray_volumes.data = { 'timestamps': self.vbar_gray_x[raw_data_start:raw_data_stop], 'volumes': self.vbar_gray[raw_data_start:raw_data_stop], } self.bin_height = 5 bins, volumes = generate_volumes( self.raw_data[raw_data_start:raw_data_stop], self.bin_height) self.bins = bins self.volumes = volumes self.blue_volumes.data = { 'bins': self.bins, 'volumes': self.volumes, } self.update_ranges() def update_last_value(self): url2 = f'https://api-pub.bitfinex.com/v2/candles/trade:{self.granularity}:tBTCUSD/last' r2 = requests.get(url2) print('last data: ', datetime.datetime.fromtimestamp(r2.json()[0] / 1000), r2.json()) # x = [self.raw_data[0][0], self.raw_data[-1][0]] x = [ min(self.green_candles.data['timestamps'][0], self.red_candles.data['timestamps'][0]), max(self.green_candles.data['timestamps'][-1], self.red_candles.data['timestamps'][-1]) ] y = [round(r2.json()[2], 1), round(r2.json()[2], 1)] # self.actual_line.data = {'timestamps': x, 'values': y, 'name': [str(y[0]), str(y[-1])]} self.actual_line.data = { 'timestamps': x, 'values': y } # , 'name': str(y[0])} def update_everything(self): self.raw_data = get_data_bitfinex(self.time1, datetime.datetime.now(), self.granularity) self.create_candles() # self.select_data_() self.select_data('value', self.day_slider.value, self.day_slider.value) def update_ranges(self): try: print('updating ranges') y_start = min(min(self.green_candles.data['segment_min']), min(self.red_candles.data['segment_min'])) y_end = max(max(self.green_candles.data['segment_max']), max(self.red_candles.data['segment_max'])) self.candles.y_range.start = y_start - (y_end - y_start) * 0.15 self.candles.y_range.end = y_end + (y_end - y_start) * 0.05 self.candles.extra_y_ranges['candles_y'].start = y_start - ( y_end - y_start) * 0.15 self.candles.extra_y_ranges['candles_y'].end = y_end + ( y_end - y_start) * 0.05 print('min: ', y_start, self.candles.y_range.start) print('max: ', y_end, self.candles.y_range.end) self.candles.extra_y_ranges['volume_y'].end = max( self.gray_volumes.data['volumes']) * 5 except AttributeError: print('ranges not updated')
partial_hist, _ = np.histogram(selected.data['dist'], bins=edges) histogram.data_source.data['right'] = partial_hist # Recompute n, median and rms n = len(selected.data['dist']) median = np.median(selected.data['dist']) rms = np.sqrt(np.mean(np.square(selected.data['dist']))) # Update spans span1.location = snr_cut span2.location = rms # Update labels label1.text = 'SNR > {:3.2f}'.format(snr_cut) label2.text = 'Median = {:3.2f} marcsec'.format(median) label3.text = 'RMS = {:3.2f} marcsec'.format(rms) label4.text = 'N = {}'.format(n) snr_slider.on_change('value', update) # Arrange plots and widgets layout layout = row(column(widgetbox(title, width=900), widgetbox(snr_slider, width=900), row(plot, hist))) curdoc().add_root(layout) curdoc().title = "SQuaSH"
plot.title.text = algorithm def update_samples_or_dataset(attrname, old, new): global X, y dataset = dataset_select.value algorithm = algorithm_select.value n_clusters = int(clusters_slider.value) n_samples = int(samples_slider.value) X, y = get_dataset(dataset, n_samples) X, y_pred = clustering(X, algorithm, n_clusters) colors = [spectral[i] for i in y_pred] source.data = dict(colors=colors, x=X[:, 0], y=X[:, 1]) algorithm_select.on_change('value', update_algorithm_or_clusters) clusters_slider.on_change('value_throttled', update_algorithm_or_clusters) dataset_select.on_change('value', update_samples_or_dataset) samples_slider.on_change('value_throttled', update_samples_or_dataset) # set up layout selects = row(dataset_select, algorithm_select, width=420) inputs = column(selects, samples_slider, clusters_slider) # add to document curdoc().add_root(row(inputs, plot)) curdoc().title = "Clustering"
plot_width=950, toolbar_location=None, tools=[hover]) p.xgrid.grid_line_color = None p.ygrid.grid_line_color = None p.patches('xs', 'ys', source=geosource, fill_color={ 'field': 'per_cent_obesity', 'transform': color_mapper }, line_color='black', line_width=0.25, fill_alpha=1) p.add_layout(color_bar, 'below') def update_plot(attr, old, new): yr = slider.value new_data = json_data(yr) geosource.geojson = new_data p.title.text = 'Share of adults who are obese, %d' % yr slider = Slider(title='Year', start=1975, end=2016, step=1, value=2016) slider.on_change('value', update_plot) layout = column(p, widgetbox(slider)) curdoc().add_root(layout) show(layout)
# Read the current value of the slider: scale scale = slider.value # Compute the updated y using np.cos(scale/x): new_y new_y = np.sin(scale / x) # Update source with the new data values source.data = {'x': x, 'y': new_y} # Dataset x = np.arange(0, 10, 0.1) y = np.sin(x) # Create ColumnDataSource: source source = ColumnDataSource(data={'x': x, 'y': y}) # Create a figure p = figure(x_axis_label='x values', y_axis_label='Sin(x)') # Add a line to the plot p.line('x', 'y', source=source) # Create first slider: slider1 slider = Slider(title='slider1', start=0, end=10, step=0.1, value=2) # Attach the callback to the 'value' property of slider slider.on_change('value', callback) # Create layout and add to current document layout = column(widgetbox(slider), p) curdoc().add_root(layout)
def animate_update(): year = slider.value + 1 if year > years[-1]: year = years[0] slider.value = year def slider_update(attrname, old, new): year = slider.value label.text = str(year) source.data = data[year] slider = Slider(start=years[0], end=years[-1], value=years[0], step=1, title="Year") slider.on_change('value', slider_update) callback_id = None def animate(): global callback_id if button.label == '► Play': button.label = '❚❚ Pause' callback_id = curdoc().add_periodic_callback(animate_update, 200) else: button.label = '► Play' curdoc().remove_periodic_callback(callback_id) button = Button(label='► Play', width=60) button.on_click(animate)
geo_source.geojson = states_view.to_json() def save_to_shapefile(): states_view.to_file('fout.shp') def on_slider_change(attr, old, new): simplify_tolerance = new simplify_features(simplify_tolerance) # let's read some shapefile metadata crs = states.crs simplify_slider = Slider(title='Simplify Tolerance', value=0, start=0, end=1, step=.01) simplify_slider.on_change('value', on_slider_change) save_button = Button(label='Save') save_button.on_click(save_to_shapefile) p = Figure(plot_height=600, plot_width=900, x_range=(bounds[0], bounds[2]), y_range=(bounds[1], bounds[3])) polys = p.patches(xs='xs', ys='ys', alpha=0.9, source=geo_source) controls = HBox(width=p.plot_width, children=[simplify_slider, save_button]) layout = VBox(width=p.plot_width, children=[controls, p]) curdoc().add_root(layout)