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")))) group = RadioButtonGroup(labels=LABELS, css_classes=["foo"]) def cb(active): source.data['val'] = [active, "b"] group.on_click(cb) doc.add_root(column(group, plot))
def test_js_on_change_executes(self, bokeh_model_page): group = RadioButtonGroup(labels=LABELS, css_classes=["foo"]) group.js_on_click(CustomJS(code=RECORD("active", "cb_obj.active"))) page = bokeh_model_page(group) el = page.driver.find_element_by_css_selector('.foo .bk-btn:nth-child(3)') el.click() results = page.results assert results['active'] == 2 el = page.driver.find_element_by_css_selector('.foo .bk-btn:nth-child(1)') el.click() results = page.results assert results['active'] == 0 assert page.has_no_console_errors()
def home(): #Open file and create sources dictionary = open_file_into_dictionary('SampleCSV2.csv') keys = list(key.title() for key in dictionary.keys()) values = [value for value in dictionary.values()] xy_source = ColumnDataSource(data=dict(xs=[values[0]], ys=[values[1]], labels = [keys[1]], colors = ['red', 'green', 'blue', 'purple', 'brown', 'aqua'])) variables_source = ColumnDataSource(data = dict(keys = keys, values = values)) #Create general plot plot = figure(plot_width=800, plot_height=600, toolbar_location = 'left') plot.title.text_font= 'helvetica' plot.title.text_font_size = '24pt' plot.title.align = 'center' plot.title.text_font_style = 'normal' plot.multi_line(xs = 'xs', ys = 'ys', legend = 'labels', line_color = 'colors', source = xy_source) #Define callbacks x_axis_callback = CustomJS(args=dict(xy_source = xy_source, variables_source = variables_source, axis = plot.xaxis[0]), code=""" var xy_data = xy_source.data; var variables_data = variables_source.data; var index = cb_obj.active; var values = variables_data.values; var y_length = xy_data['ys'].length; if (y_length == 0){ y_length = 1} var new_list = []; for (i = 0; i < y_length; i++) { new_list.push(values[index])} xy_data['xs'] = new_list; xy_source.change.emit(); var keys = variables_data.keys; var label = keys[index]; axis.axis_label = label; """) y_axis_callback = CustomJS(args=dict(xy_source = xy_source, variables_source = variables_source, axis = plot.yaxis[0]), code=""" var xy_data = xy_source.data; var variables_data = variables_source.data; var index_list = cb_obj.active; var values = variables_data.values; var index_length = index_list.length; var keys = variables_data.keys; var new_ys = []; var new_labels = []; for (i = 0; i < index_length; i++) { new_ys.push(values[index_list[i]]); new_labels.push(keys[index_list[i]])} xy_data['labels'] = new_labels; xy_data['ys'] = new_ys; if (index_length > 0){ var x_variable = xy_data['xs'][0]; var new_x = []; for (i = 0; i < index_length; i++) { new_x.push(x_variable)} xy_data['xs'] = new_x;} xy_source.change.emit(); var y_axis_name = keys[[index_list[0]]]; for (i = 1; i < index_length; i++) { y_axis_name += ", " + keys[[index_list[i]]];} axis.axis_label = y_axis_name; """) title_callback = CustomJS(args= dict(title = plot.title), code=""" var title_text = cb_obj.value; title.text = title_text; """) x_name_callback = CustomJS(args=dict(axis = plot.xaxis[0]), code=""" var label_text = cb_obj.value; axis.axis_label = label_text; """) y_name_callback = CustomJS(args=dict(axis = plot.yaxis[0]), code=""" var label_text = cb_obj.value; axis.axis_label = label_text; """) #Create toolbox label_x = Div(text="""X-Axis""", width=200) x_axis = RadioButtonGroup(labels=keys, active=0, callback = x_axis_callback) label_y = Div(text="""Y-Axis""", width=200) y_axis = CheckboxButtonGroup(labels=keys, active=[1], callback = y_axis_callback) label_axes = Div(text="""<br />Modify Labels""", width=200) title_name = TextInput(title="Title", value='Default Title') plot.title.text = title_name.value title_name.js_on_change('value', title_callback) x_name = TextInput(title="X-Axis", value='Default X Label') plot.xaxis.axis_label = keys[0] x_name.js_on_change('value', x_name_callback) y_name = TextInput(title="Y-Axis", value='Default Y Label') plot.yaxis.axis_label = keys[1] y_name.js_on_change('value', y_name_callback) toolbox = widgetbox(label_x, x_axis, label_y, y_axis, label_axes, title_name, x_name, y_name) #Integrate with html parts = dict(toolbox = toolbox, plot = plot) script, div = components(parts, INLINE) return render_template('plotpage.html', script=script, toolbox_div=div['toolbox'], plot_div=div['plot'], js_resources=INLINE.render_js(), css_resources=INLINE.render_css())
from bokeh.io import show from bokeh.models import CustomJS, RadioButtonGroup LABELS = ["Option 1", "Option 2", "Option 3"] radio_button_group = RadioButtonGroup(labels=LABELS, active=0) radio_button_group.js_on_event( "button_click", CustomJS(args=dict(btn=radio_button_group), code=""" console.log('radio_button_group: active=' + radio_button_group.active, this.toString()) """)) show(radio_button_group)
def button_group(level): choice = RadioButtonGroup(labels=['None'], visible=False, active=None) set_callback(choice, level) return choice
def __init__(self, n_nodes): self.i = 0 kps = [crypto_sign_keypair() for _ in range(n_nodes)] stake = {kp[0]: 1 for kp in kps} network = {} self.nodes = [Node(kp, network, n_nodes, stake) for kp in kps] for n in self.nodes: network[n.pk] = n.ask_sync self.ids = {kp[0]: i for i, kp in enumerate(kps)} self.main_its = [n.main() for n in self.nodes] for m in self.main_its: next(m) def toggle(): if play.label == '► Play': play.label = '❚❚ Pause' curdoc().add_periodic_callback(self.animate, 50) else: play.label = '► Play' curdoc().remove_periodic_callback(self.animate) play = Button(label='► Play', width=60) play.on_click(toggle) def sel_node(new): self.active = new node = self.nodes[new] self.tbd = {} self.tr_src.data, self.links_src.data = self.extract_data( node, bfs((node.head, ), lambda u: node.hg[u].p), 0) for u, j in tuple(self.tbd.items()): self.tr_src.data['line_alpha'][j] = 1 if node.famous.get( u) else 0 if u in node.idx: self.tr_src.data['round_color'][j] = idx_color(node.idx[u]) self.tr_src.data['idx'][j] = node.idx.get(u) if u in node.idx and u in node.famous: del self.tbd[u] print('updated') self.tr_src.trigger('data', None, self.tr_src.data) selector = RadioButtonGroup( labels=['Node %i' % i for i in range(n_nodes)], active=0, name='Node to inspect') selector.on_click(sel_node) plot = figure( plot_height=700, plot_width=900, y_range=(0, 30), tools=[ PanTool(dimensions=['height']), HoverTool(tooltips=[('round', '@round'), ( 'hash', '@hash'), ('timestamp', '@time'), ('payload', '@payload'), ('number', '@idx')]) ]) plot.xgrid.grid_line_color = None plot.xaxis.minor_tick_line_color = None plot.ygrid.grid_line_color = None plot.yaxis.minor_tick_line_color = None self.links_src = ColumnDataSource(data={ 'x0': [], 'y0': [], 'x1': [], 'y1': [], 'width': [] }) #self.links_rend = plot.add_layout( # Arrow(end=NormalHead(fill_color='black'), x_start='x0', y_start='y0', x_end='x1', # y_end='y1', source=self.links_src)) self.links_rend = plot.segment(color='#777777', x0='x0', y0='y0', x1='x1', y1='y1', source=self.links_src, line_width='width') self.tr_src = ColumnDataSource( data={ 'x': [], 'y': [], 'round_color': [], 'idx': [], 'line_alpha': [], 'round': [], 'hash': [], 'payload': [], 'time': [] }) self.tr_rend = plot.circle(x='x', y='y', size=20, color='round_color', line_alpha='line_alpha', source=self.tr_src, line_width=5) sel_node(0) curdoc().add_root( row([widgetbox(play, selector, width=300), plot], sizing_mode='fixed'))
def wohngeld(plot_dict, data): def make_dataset(sel_year, hh_size, wg_dict): dataset = wg_dict[sel_year][hh_size] heatmap_source = pd.DataFrame(dataset.stack(), columns=["Wohngeld"]).reset_index() heatmap_source.columns = ["Miete", "Einkommen", "Wohngeld"] return ColumnDataSource(heatmap_source) def update_plot(attr, old, new): sel_year = [1992, 2001, 2009, 2016, 2020, 2021][year_selection.active] hh_size = hh_size_selection.value new_src = make_dataset(sel_year, hh_size, wg_dict) src.data.update(new_src.data) def setup_plot(src): """ Create the heatmap plot. src: ColumnDataSource """ # Prepare a color pallete and color mapper mapper = LinearColorMapper( # force 0 to be mapped with white color palette=tuple( itertools.chain(["#FFFFFF"], tuple(reversed(Viridis256[1:])))), low=0, high=1000, ) # Actual figure setup p = figure( plot_width=800, plot_height=400, x_range=(src.data["Miete"].min(), src.data["Miete"].max()), y_range=(src.data["Einkommen"].min(), src.data["Einkommen"].max()), tools="hover", tooltips="Housing Benefit: @Wohngeld{0.0f}€", ) p.rect( x="Miete", y="Einkommen", width=25, height=src.data["Einkommen"][1] - src.data["Einkommen"][0], source=src, line_color=transform("Wohngeld", mapper), fill_color=transform("Wohngeld", mapper), ) color_bar = ColorBar( color_mapper=mapper, location=(0, 0), ticker=BasicTicker(desired_num_ticks=20), formatter=NumeralTickFormatter(format="0€"), label_standoff=12, ) p.add_layout(color_bar, "right") plot = plotstyle(p, plot_dict) return plot wg_dict = data year_selection = RadioButtonGroup( labels=[str(i) for i in [1992, 2001, 2009, 2016, 2020, 2021]], active=5) year_selection.on_change("active", update_plot) hh_size_selection = Slider(start=1, end=12, value=4, step=1, title="Household Size") hh_size_selection.on_change("value", update_plot) src = make_dataset(2021, 4, wg_dict) p = setup_plot(src) description = Div( text=plot_dict["description"], width=1000, ) year_label = Div(text="Year") layout = column(description, year_label, year_selection, hh_size_selection, p) tab = Panel(child=layout, title="Housing benefits") return tab
def change_range(attrname, old, new): low, high = rangeslider.value for i, lead in enumerate(StandardHeader): leads[i].x_range.start = low * 100 leads[i].x_range.end = (high - rs_width) * 100 # Set widgets rangeslider = RangeSlider(start=0, end=10000, step=1, value=(0, rs_width + 30), title="X range") file_selector = Select(value=None, options=nix(None, files)) waveselector = RadioButtonGroup(labels=["P wave", "QRS wave", "T wave"], active=0) textboxnew = PreText(text="New points: \t[]") retrievebutton = Button(label='Retrieve Segmentation') storebutton = Button(label='Store Segmentation') writebutton = Button(label='Write to File') # Set callbacks file_selector.on_change('value', file_change) source.selected.on_change('indices', selection_change) retrievebutton.on_click(retrieve_segmentation) storebutton.on_click(save_segmentation) writebutton.on_click(write_segmentation) rangeslider.on_change('value', change_range) waveselector.on_change('active', wave_change) # set up layout
data_counties = pd.concat([data_counties, raw_df], axis=1) # getting quantile values for categorising counties top_qtl = raw_df.quantile(0.66) middle_qtl = raw_df.quantile(0.33) session = Session() document = Document() session.use_doc('python_project') session.load_document(document) source = ColumnDataSource(data=dict(x=[], y=[], c=[], i=[])) inf_source = ColumnDataSource(data=dict(facs=[])) # radio buttons intialization radio = RadioButtonGroup(labels=['Cancer Deaths', 'Heart Disease Deaths', 'Respiratory Disease Deaths', 'Diabetes Deaths'], active=0) radio.on_click(update) # calling update function to intialize the plot update(0) if __name__ == '__main__': link = session.object_link(document.context) print("Please visit %s to see the plots" % link) view(link) session.poll_document(document)
def add_controllers(self): titles = {'npeople': 'Number of people', 'sensorinterval': 'Interval', 'sensortpr': 'True positive rate', 'sensorexfp': 'Expected num of FP', 'sensorrange': 'Sensor range', 'sensorsnum': 'Fleet size', 'sensorspeed': 'Fleet speed'} idx0 = 1 stacked = [] #Create a controller for the scaling def on_scaling_changed(_, _old, _new): self.scaling = _new self.update_plot() self.scalingwidget = Select(title='Scaling', value='linear', options=['linear', 'log']) self.scalingwidget.on_change('value', on_scaling_changed) stacked.append(self.scalingwidget) # Create a controller for each param for k in titles.keys(): def on_radio_changed(attr, old, new, kk): if self.blocked: return newvalue = self.config[kk][new-1] if new != FIXEDIDX else -1 print('Changed ' + str(kk) + ' to ' + str(newvalue)) self.currparams[kk] = newvalue if new == FIXEDIDX: self.blocked = True for param in self.contr.keys(): if param == kk or self.contr[param].active != FIXEDIDX: continue self.contr[param].active = 1 self.currparams[param] = self.config[param][0] self.var = kk varyingparam = False for kkk, vvv in self.currparams.items(): if vvv == -1: varyingparam = True break if not varyingparam: self.var = None self.update_plot() if self.blocked: self.blocked = False my_radio_changed = partial(on_radio_changed, kk=k) params = ['varying'] + list(map(str, self.config[k])) buttonisactive = FIXEDIDX if self.var == k else idx0 self.contr[k] = RadioButtonGroup(labels=params, active=buttonisactive) self.contr[k].on_change('active', my_radio_changed) self.currparams[k] = params[idx0] r = Row(widgetbox(Div(text='{}:'.format(titles[k]))), self.contr[k]) stacked.append(r) self.currparams[self.var] = -1 adjwidget = Column(*stacked) self.guirow.children[0] = adjwidget
source1.change.emit(); // update the arrays source2.change.emit(); // update phis """) # define widgets modes_slider = Slider( start=2, end=maxMode, value=100, step=1, title="Number of Modes, $N$", callback=callback1, # callback_policy="mouseup" ) lock_toggle = RadioButtonGroup(labels=["Modelocking", "No Modelocking"], active=0, callback=callback2) callback1.args["modes"] = modes_slider callback1.args["locking"] = lock_toggle callback2.args["modes"] = modes_slider callback2.args["locking"] = lock_toggle maxI = np.amax(y) meanI = np.mean(y) print(meanI) div1 = Div( text=""" <div> Peak intensity of the current plot: </div> <div id="maxInfo" class="valueDiv"></div> """
def show_cells_on_stack(data, stack, X='X', Y='Y', channelNames=None, group='group', hue='hue', palette='Spectral11', default=0, alpha=.5, plot_width=500, plot_height=500, vmin=0, vmax=3, znorm=True): ''' stack: np. array of shape (nchannels,height,width) ''' from bokeh.models import CheckboxGroup, RadioButtonGroup, Legend, LegendItem if not channelNames: channelNames = ['Channel ' + str(i) for i in range(len(stack))] print(channelNames) s1 = ColumnDataSource(data=data) p1 = figure(plot_width=plot_width, plot_height=plot_height, tools="pan,wheel_zoom,reset") channels = {} for i, channel in enumerate(channelNames): img = stack[i] if znorm: img = (img - img.mean()) / img.std() channels[i] = p1.image(image=[img], x=[0], y=[0], dw=[plot_width], dh=[plot_height], color_mapper=LogColorMapper(palette=palette, low=vmin, high=vmax), global_alpha=alpha, visible=(i == default)) plots = {} #scaled_coordinates to fit in stack_dw,stack_dh dh_ratio = plot_height / img.shape[0] dw_ratio = plot_width / img.shape[1] data['warped_X'] = data[X] * dw_ratio data['warped_Y'] = data[Y] * dh_ratio groups = list(data[group].unique()) for g_id in groups: s2 = ColumnDataSource(data=data[data[group] == g_id]) scatter = p1.circle('warped_X', 'warped_Y', source=s2, alpha=1, color='hue') #,legend_label = str(g_id)) scatter.visible = False plots[g_id] = scatter select_celltype = CheckboxGroup(labels=groups, active=[], width=100) select_channel = RadioButtonGroup(labels=channelNames, active=default, width=100, orientation='horizontal') select_celltype.callback = CustomJS(args={ 'plots': plots, 'groups': groups, 'msel': select_celltype, 'fig': p1 }, code=""" //fig.title.text = 'new Title' for (var i =0; i<groups.length;i++){ plots[groups[i]].visible = msel.active.indexOf(i)>-1 } """) select_channel.callback = CustomJS(args={ 'channels': channels, 'sel': select_channel, 'fig': p1 }, code=""" //fig.title.text = Object.keys(channels).length.toString() for (var i =0; i<Object.keys(channels).length;i++){ channels[i].visible = false } var val = sel.active channels[val].visible = true /** if (val==0){ fig.title.text = 'confirm upper' chan1.visible = true chan2.visible = false //bg_channel = [z[0]] }else if (val==1){ fig.title.text = 'confirm lower' chan1.visible = false chan2.visible = true //bg_channel = [z[1]] } **/ """) layout = column(p1, select_celltype, select_channel) show(layout)
step=1, title="% Female") slider62.on_change('value', update) # 7) Etnicity slider7 = RangeSlider(start=0, end=100, value=(0, 100), step=1, title="Diversity Index") slider7.on_change('value', update) # 8) #Rent div81 = Div(text="<b> Housing Rent per Sqft </b>") radio_button81 = RadioButtonGroup( labels=["No preference", "< 20 $", "20-30$", ">30 $"], active=0) radio_button81.on_change('active', update) #Crime div82 = Div(text="<b>Felonies per 100.000 </b>") radio_button82 = RadioButtonGroup( labels=["No preference", "< 30", "30-60", "> 60"], active=0) radio_button82.on_change('active', update) table, m, div0 = create_plot() #Combine all controls to get in column col1 = row(table, m, height=200, width=1180) col2 = column(div1, select1, slider21, slider22, slider3, slider4, width=210) col3 = column(div5,
click_button = Button(label="Button still has click event", button_type="success") disabled_button = Button(label="Button (disabled) - still has click event", button_type="primary", disabled=True) toggle = Toggle(label="Toggle button", button_type="success") menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"), None, ("Item 3", "item_3_value")] dropdown = Dropdown(label="Dropdown button", button_type="warning", menu=menu) dropdown_split = Dropdown(label="Split button", button_type="danger", menu=menu, split=True) checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1]) radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0) checkbox_button_group = CheckboxButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1]) radio_button_group = RadioButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=0) text_input = TextInput(placeholder="Enter value ...") completions = ["aaa", "aab", "aac", "baa", "caa"] autocomplete_input = AutocompleteInput(placeholder="Enter value (auto-complete) ...", completions=completions) select = Select(options=["Option 1", "Option 2", "Option 3"]) multi_select = MultiSelect(options=["Option %d" % (i+1) for i in range(16)], size=6) slider = Slider(value=10, start=0, end=100, step=0.5) range_slider = RangeSlider(value=[10, 90], start=0, end=100, step=0.5) date_slider = DateSlider(value=date(2016, 1, 1), start=date(2015, 1, 1), end=date(2017, 12, 31))
def load_data(): curdoc().clear() button_1 = Button(label="Load data") button_1.on_click(load_data) button_2 = Button(label="Advanced options") button_2.on_click(Advanced_options) curdoc().add_root(button_1) curdoc().add_root(button_2) datapath=filedialog.askopenfilename() global Dsource, Csource, Isource, Ssource, data_new_masked, data3, CX2, CY2, data, YY, XX,SelectedIon, mzlabs mz=pd.read_csv(datapath,sep='\t',skiprows=(0,1,2),header=None, nrows=1) mz=mz.drop(columns=[0,1,2]) #lastmz=mz.columns[-1] #mz=mz.drop(columns=[lastmz-1,lastmz]) data = pd.read_csv(datapath,sep='\t',skiprows=(0,1,2,3),header=None) Xpixels=data[1].tolist() Ypixels=data[2].tolist() last=data.columns[-1] data = data.drop(data.columns[[0, 1, 2,last-1,last]], axis=1) ScanNum=data.index.tolist() TotalScan=len(ScanNum) mzlabs=mz.loc[0].values.tolist() data.columns=mzlabs data = data.reindex(sorted(data.columns), axis=1) mzlabs.sort() peakNum=len(mzlabs) # Work out pixel dimensions- need to do try/ catch here a=Xpixels[1] Ypix=Xpixels.count(a) Xpix=np.round(TotalScan/Ypix) print(Ypix) print(Xpix) # Make sure Ypix * Xpix = total pix # Do sum normalisation.. this will have multiple options # This is not the real sum normalisation # data_new = data.div(data.sum(axis=1), axis=0) # This is a crude method for clearing background pixels based on lipid vs non-lipid #low1=int(peakNum/2) #low2=int(peakNum/2) #high2=int(peakNum) low1=min(range(len(mzlabs)), key=lambda x:abs(mzlabs[x]-50)) high1=min(range(len(mzlabs)), key=lambda x:abs(mzlabs[x]-200)) low2=min(range(len(mzlabs)), key=lambda x:abs(mzlabs[x]-750)) high2=min(range(len(mzlabs)), key=lambda x:abs(mzlabs[x]-900)) D1=data.iloc[:,low1:high1] D2=data.iloc[:,low2:high2] D1s = D1.sum(axis=1) D1s=D1s+1 D2s = D2.sum(axis=1) Ratio=D2s/D1s Ratio.tolist() del D1,D1s,D2,D2s # This may be possible to do with only one copy of the data data2=data data2.loc[Ratio<2,:]=0 data3=data2.loc[~(data2==0).all(axis=1)] del data2 data_new_masked = data3.div(data3.sum(axis=1), axis=0) data_new_masked=data_new_masked.fillna(0) # Do PCA data reduction #Data_reduced=PCA(n_components=10).fit_transform(data_new) Data_reduced=PCA(n_components=10).fit_transform(data_new_masked) # Perform the UMAP - these paramaters will be adjustable reducer = umap.UMAP(n_neighbors=10,min_dist=0.1,n_components=2,metric='euclidean') embedding = reducer.fit_transform(Data_reduced) # This can be replaced using the Xpix Ypix from above YY=int(Ypix) XX=int(Xpix) CX=[] for y in range(YY): for x in range(XX): CX.append(x) CY=[] for y in range(YY): for x in range(XX): CY.append(y) idx=data3.index CX2 = [CX[i] for i in idx] CY2 = [CY[i] for i in idx] # CX2=reverse(CX2) # CY2=reverse(CY2) #CX2=CX2[::-1] #CY2=CY2[::-1] # This defines the UMAP output as columns for the plotting tools x2=embedding[:, 0] y2=embedding[:, 1] x3=x2-np.min(x2) y3=y2-np.min(y2) scannum= np.arange(0,TotalScan).tolist() spectra=scannum spectra2 = [spectra[i] for i in idx] ColX=(x3/np.max(x3))*255 ColY=(y3/np.max(y3))*255 CV1 = ["#%02x%02x%02x" % (int(r), int(g), 0) for r, g in zip(ColX, ColY)] CV2 = ["#%02x%02x%02x" % (0, int(r), int(g)) for r, g in zip(ColX, ColY)] CV3 = ["#%02x%02x%02x" % (int(r), 0, int(g)) for r, g in zip(ColX, ColY)] # Create the data sources required Mean1=np.mean(data3) #.iloc[1,:] Blank=[0]*len(CX2) BlankMap = ["#%02x%02x%02x" % (0, 0, 0) for r in(ColX)] CompData=Mean1/Mean1 Ssource = ColumnDataSource(data=dict(x=mzlabs,y=Mean1)) Dsource = ColumnDataSource(data=dict(x=x2, y=y2, cordsX=CX2,cordsY=CY2,CV=CV1,spectra=spectra2)) Csource = ColumnDataSource(data=dict(x=mzlabs,Region1=Mean1,Region2=Mean1,y=CompData)) Isource = ColumnDataSource(data=dict(cordsX=CX2,cordsY=CY2,Region1=Blank,Region2=Blank,Map=Blank)) # Set up the plot region (need to define min and max for right plot) TOOLS="lasso_select, box_select,pan,wheel_zoom,box_zoom,reset" Right=figure(title="UMAP output",plot_width=500,plot_height=500,x_range=[-15,15], y_range=[-15,15],tools=TOOLS) Left=figure(plot_width=500,plot_height=500,title=None,x_range=[0,XX], y_range=[0,YY],tools=TOOLS) Left.axis.visible = False Results=figure(plot_width=500,plot_height=400,title=None,x_range=[0,1200],tools="pan,wheel_zoom,box_zoom,reset,tap",x_axis_label='m/z',y_axis_label='log2 fold change') Spectrum=figure(plot_width=500,plot_height=400,title=None,x_range=[0,1200],x_axis_label='m/z',y_axis_label='mean intensity') SelectedIon=figure(plot_width=300,plot_height=300,title="Selected ion image",title_location = "below",x_range=[0,XX], y_range=[0,YY]) SelectedIon.axis.visible = False Regions=figure(plot_width=200,plot_height=200,title=None,x_range=[0,Xpix], y_range=[0,Ypix],align="center") Regions.axis.visible = False Results.add_tools(HoverTool( tooltips = [ ("m/z", "@x"), ("fold change", "@y"), ], mode='mouse', point_policy='snap_to_data' )) # Populate the initial plots r=Right.scatter(x='x',y='y',fill_color='CV',line_color=None,source=Dsource,radius=0.1) Left.square(x='cordsX',y='cordsY',fill_color='CV',line_color=None,alpha=1,size=5, source=Dsource) #Spectrum.line(x='x',y='y',source=Ssource) #Results.line(x='x',y='y',source=Csource) Spectrum.vbar(x='x',top='y',source=Ssource,width=0.5) Results.vbar(x='x',top='y',source=Csource,width=0.5) Regions.square(x='cordsX',y='cordsY',fill_color='Map',line_color=None,alpha=1,size=5, source=Isource) callback = CustomJS(args=dict(renderer=r), code=""" renderer.glyph.radius = cb_obj.value; """) slider1 = Slider(start=0.01, end=1, step=0.01, value=0.1,title='circle size') slider1.js_on_change('value', callback) #text = TextInput(title="title", value='Insert experiment name') button_group = RadioButtonGroup(labels=["Red Green", "Red Blue", "Blue Green"], active=0) select = Select(title="Option:", value="foo", options=["Sum normalisation", "No normalisation", "Mean normalisation", "Median normalisation"]) button_1 = Button(label="Load data") button_2 = Button(label="Reset data") button_3 = Button(label="Select region 1") button_4 = Button(label="Select region 2") button_5 = Button(label="Compare") button_6 = Button(label="Output report") # These are the list of actions possible #text.on_change('value', update_title) button_1.on_click(load_data) button_3.on_click(Region_1) button_4.on_click(Region_2) button_5.on_click(Compare_data) button_6.on_click(Output) Dsource.selected.on_change('indices', update_data) #taptool = Results.select(type=TapTool) Csource.selected.on_change('indices',create_ion_map) p = gridplot([[Left,Right,column(slider1,select, button_3,button_4,Regions,button_5,button_6)],[Spectrum,Results,SelectedIon]]) curdoc().add_root(p)
def __init__(self, n_nodes): self.i = 0 kps = [crypto_sign_keypair() for _ in range(n_nodes)] stake = {kp[0]: 1 for kp in kps} network = {} self.nodes = [Node(kp, network, n_nodes, stake) for kp in kps] for n in self.nodes: network[n.pk] = n.ask_sync self.ids = {kp[0]: i for i, kp in enumerate(kps)} self.main_its = [n.main() for n in self.nodes] for m in self.main_its: next(m) def toggle(): if play.label == '► Play': play.label = '❚❚ Pause' curdoc().add_periodic_callback(self.animate, 50) else: play.label = '► Play' curdoc().remove_periodic_callback(self.animate) play = Button(label='► Play', width=60) play.on_click(toggle) def sel_node(new): self.active = new node = self.nodes[new] self.tbd = {} self.tr_src.data, self.links_src.data = self.extract_data( node, bfs((node.head,), lambda u: node.hg[u].p), 0) for u, j in tuple(self.tbd.items()): self.tr_src.data['line_alpha'][j] = 1 if node.famous.get(u) else 0 if u in node.idx: self.tr_src.data['round_color'][j] = idx_color(node.idx[u]) self.tr_src.data['idx'][j] = node.idx.get(u) if u in node.idx and u in node.famous: del self.tbd[u] print('updated') self.tr_src.trigger('data', None, self.tr_src.data) selector = RadioButtonGroup( labels=['Node %i' % i for i in range(n_nodes)], active=0, name='Node to inspect') selector.on_click(sel_node) plot = figure( plot_height=700, plot_width=900, y_range=(0, 30), tools=[PanTool(dimensions=['height']), HoverTool(tooltips=[ ('round', '@round'), ('hash', '@hash'), ('timestamp', '@time'), ('payload', '@payload'), ('number', '@idx')])]) plot.xgrid.grid_line_color = None plot.xaxis.minor_tick_line_color = None plot.ygrid.grid_line_color = None plot.yaxis.minor_tick_line_color = None self.links_src = ColumnDataSource(data={'x0': [], 'y0': [], 'x1': [], 'y1': [], 'width': []}) #self.links_rend = plot.add_layout( # Arrow(end=NormalHead(fill_color='black'), x_start='x0', y_start='y0', x_end='x1', # y_end='y1', source=self.links_src)) self.links_rend = plot.segment(color='#777777', x0='x0', y0='y0', x1='x1', y1='y1', source=self.links_src, line_width='width') self.tr_src = ColumnDataSource( data={'x': [], 'y': [], 'round_color': [], 'idx': [], 'line_alpha': [], 'round': [], 'hash': [], 'payload': [], 'time': []}) self.tr_rend = plot.circle(x='x', y='y', size=20, color='round_color', line_alpha='line_alpha', source=self.tr_src, line_width=5) sel_node(0) curdoc().add_root(row([widgetbox(play, selector, width=300), plot], sizing_mode='fixed'))
def setup_widgets(self): # Generation of selectable items # Dict contains all inspectable runs (maps display strings to timestamps) # The dict structure allows to get the timestamp from the display string # in O(1) self.runs_dict = helper.gen_runs_selection(self.metadata) # Dict maps display strings to column names for the different factors # (var, backend, test) self.factors_dict = { "Variables": "variable", "Backends": "vfc_backend", "Tests": "test" } # Run selection # Contains all options strings runs_display = list(self.runs_dict.keys()) # Will be used when updating plots (contains actual number) self.current_run = self.runs_dict[runs_display[-1]] # Contains the selected option string, used to update current_n_runs current_run_display = runs_display[-1] # This contains only entries matching the run self.run_data = self.data[self.data["timestamp"] == self.current_run] change_run_callback_js = "updateRunMetadata(cb_obj.value, \"\");" self.widgets["select_run"] = Select(name="select_run", title="Run :", value=current_run_display, options=runs_display) self.doc.add_root(self.widgets["select_run"]) self.widgets["select_run"].on_change("value", self.update_run) self.widgets["select_run"].js_on_change( "value", CustomJS( code=change_run_callback_js, args=(dict(metadata=helper.metadata_to_dict( helper.get_metadata(self.metadata, self.current_run)))))) # Factors selection # "Group by" radio self.widgets["groupby_radio"] = RadioButtonGroup( name="groupby_radio", labels=list(self.factors_dict.keys()), active=0) self.doc.add_root(self.widgets["groupby_radio"]) # The functions are defined inside the template to avoid writing too # much JS server side self.widgets["groupby_radio"].on_change("active", self.update_groupby) # "Filter by" radio # Get all possible factors, and remove the one selected in "Group by" filterby_list = list(self.factors_dict.keys()) del filterby_list[self.widgets["groupby_radio"].active] self.widgets["filterby_radio"] = RadioButtonGroup( name="filterby_radio", labels=filterby_list, active=0) self.doc.add_root(self.widgets["filterby_radio"]) # The functions are defined inside the template to avoid writing too # much JS server side self.widgets["filterby_radio"].on_change("active", self.update_filterby) # Filter selector filterby = self.widgets["filterby_radio"].labels[ self.widgets["filterby_radio"].active] filterby = self.factors_dict[filterby] if not self.run_data.empty: options = self.run_data.index\ .get_level_values(filterby).drop_duplicates().tolist() else: options = ["None"] self.widgets["select_filter"] = Select( # We need a different name to avoid collision in the template with # the runs comparison's widget name="select_filter", title="Select a filter :", value=options[0], options=options) self.doc.add_root(self.widgets["select_filter"]) self.widgets["select_filter"]\ .on_change("value", self.update_filter) # Toggle for outliers filtering self.widgets["outliers_filtering_inspect"] = CheckboxGroup( name="outliers_filtering_inspect", labels=["Filter outliers"], active=[]) self.doc.add_root(self.widgets["outliers_filtering_inspect"]) self.widgets["outliers_filtering_inspect"]\ .on_change("active", self.update_outliers_filtering)
'Orange', ] df = pd.DataFrame({'x': x, 'y': y, 'label': label}) source = ColumnDataSource(data=dict(x=df.x, y=df.y, label=df.label)) plot_figure = figure(title='Radio Button Group', plot_height=450, plot_width=600, tools="save,reset", toolbar_location="below") plot_figure.scatter('x', 'y', color='label', source=source, size=10) radio_button_group = RadioButtonGroup(labels=["Red", "Orange"]) def radiogroup_click(attr, old, new): active_radio = radio_button_group.active ##Getting radio button value # filter the dataframe with value in radio-button if active_radio == 0: selected_df = df[df['label'] == 'Red'] elif active_radio == 1: selected_df = df[df['label'] == "Orange"] source.data = dict(x=selected_df.x, y=selected_df.y, label=selected_df.label)
value=selected_dataset) measure_1 = Select(title="Measure", options=[ ('cosine_similarity', 'Cosine Similarity'), ('cosine', 'Cosine Distance'), ('euclidean', 'Euclidean'), ('dot_product', 'Dot product'), ('correlation', 'Correlation'), ], value='cosine_similarity') x_axis = TextInput(title="X Axis Formula", placeholder="formula") y_axis = TextInput(title="Y Axis Formula", placeholder="formula") explicit_tab = Panel(child=column(measure_1, x_axis, y_axis), title="Explicit") filtering_before_after_2 = RadioButtonGroup( labels=["Filter before projection", "Filter after projection"], active=0) pca_tab = Panel(child=filtering_before_after_2, title="PCA") measure_3 = Select(title="Measure", options=[ ('cosine', 'Cosine Distance'), ('euclidean', 'Euclidean'), ('dot_product', 'Dot product'), ('correlation', 'Correlation'), ], value='cosine') filtering_before_after_3 = RadioButtonGroup( labels=["Filter before projection", "Filter after projection"], active=0) tsne_tab = Panel(child=column(measure_3, filtering_before_after_3), title="t-SNE")
def build_lockdown_tab(): # Get data for lockdown tab lockdown_data = get_lockdown_data() lockdown_data = prep_lockdown_data(lockdown_data) source_gantt = ColumnDataSource(lockdown_data.dropna()) source_points = ColumnDataSource(lockdown_data) # Create lockdown figure lockdown_fig = figure( y_range=FactorRange(factors=lockdown_data.Country.unique().tolist()), x_axis_type='datetime', title="Lockdown Status by Nation", x_range=(lockdown_data['start_date'].min() - timedelta(days=3), lockdown_data['end_date'].max() + timedelta(days=3)), outline_line_color=None, width=1000, height=650) # Adding hbar glyph of lockdown dates gantt_plot = lockdown_fig.hbar(y="Country", left='start_date', right='end_date', height=0.4, source=source_gantt, color='color') # Adding start point circle glyph start_point = lockdown_fig.circle(x='start_date', y='Country', source=source_points, size=5, line_color='blue', fill_color='white') # Adding end point circle glyph end_point = lockdown_fig.circle(x='end_date', y='Country', source=source_points, size=5, line_color='blue', fill_color='white') # Formatting x-axis lockdown_fig.xaxis.axis_label = "Date" lockdown_fig.xaxis.formatter = DatetimeTickFormatter(days='%d/%m/%Y') lockdown_fig.xaxis.ticker = DaysTicker(days=np.arange(5, 365, 7)) lockdown_fig.xaxis.major_label_orientation = math.pi / 6 # Formatting y-axis lockdown_fig.yaxis.axis_label = "Country" lockdown_fig.yaxis.major_label_orientation = math.pi / 12 lockdown_fig.yaxis.major_label_text_font_size = "7pt" lockdown_fig.yaxis.major_label_text_font_style = "bold" lockdown_fig.ygrid.grid_line_color = None lockdown_fig.y_range.range_padding = 0.05 # Align grid and axis tickers lockdown_fig.xgrid[0].ticker = lockdown_fig.xaxis[0].ticker # Adding hover tools gantt_hover = HoverTool(renderers=[gantt_plot], tooltips=[('Country', '@Country'), ('Start Date', '@start_date{%d/%m/%Y}'), ('End Date', '@end_date{%d/%m/%Y}'), ('Length', '@length{%d days}')], formatters={ '@start_date': 'datetime', '@end_date': 'datetime', '@length': 'printf' }) start_hover = HoverTool(renderers=[start_point], tooltips=[('Country', '@Country'), ('Start Date', '@start_date{%d/%m/%Y}')], formatters={'@start_date': 'datetime'}) end_hover = HoverTool(renderers=[end_point], tooltips=[('Country', '@Country'), ('End Date', '@end_date{%d/%m/%Y}')], formatters={'@end_date': 'datetime'}) lockdown_fig.add_tools(gantt_hover, start_hover, end_hover) # Adding vertical span for today's date today_date_span = Span(location=datetime.today(), dimension='height', line_color='blue', line_width=3, line_dash=[6, 6]) lockdown_fig.add_layout(today_date_span) # Labelling span span_label = Label(x=datetime.today() + timedelta(hours=12), y=-1.2, y_units='screen', text='Current Date', text_font_size='12pt') lockdown_fig.add_layout(span_label) # Adding CheckboxButtonGroup for continents continents = lockdown_data['continent'].unique().tolist() continent_rbg = RadioButtonGroup(labels=continents, active=None, width=500) def continent_rbg_callback(attr, old, new): if continent_rbg.active != None: selected_continent = continent_rbg.labels[continent_rbg.active] filtered_df = lockdown_data.loc[lockdown_data.continent == selected_continent] gantt_cds = ColumnDataSource(filtered_df.dropna()) points_cds = ColumnDataSource(filtered_df) source_gantt.data.update(gantt_cds.data) source_points.data.update(points_cds.data) lockdown_fig.y_range.factors = filtered_df.Country.unique().tolist( ) # Synchronise country filter country_multiselect.options = filtered_df['Country'].unique( ).tolist() country_multiselect.value = filtered_df['Country'].unique().tolist( ) continent_rbg.on_change('active', continent_rbg_callback) # Adding MultiSelect Widget for filtering by country countries = lockdown_data['Country'].unique().tolist() country_multiselect = MultiSelect(title='Countries:', options=countries, value=countries, height=500) def country_multiselect_callback(attr, old, new): selected_countries = country_multiselect.value filter_condition = lockdown_data.Country.isin(selected_countries) filtered_df = lockdown_data.loc[filter_condition] gantt_cds = ColumnDataSource(filtered_df.dropna()) points_cds = ColumnDataSource(filtered_df) source_gantt.data.update(gantt_cds.data) source_points.data.update(points_cds.data) lockdown_fig.y_range.factors = filtered_df.Country.unique().tolist() # Synchronise continent filter continent_rbg.active = None country_multiselect.on_change('value', country_multiselect_callback) # Creating Clear All, Select All Buttons def clear_button_callback(event): country_multiselect.options = countries country_multiselect.value = [] continent_rbg.active = None lockdown_fig.y_range.factors = lockdown_data.Country.unique().tolist() def select_all_button_callback(event): country_multiselect.options = countries country_multiselect.value = countries continent_rbg.active = None lockdown_fig.y_range.factors = lockdown_data.Country.unique().tolist() clear_button = Button(label="Clear Selection", button_type="success") clear_button.on_click(clear_button_callback) select_all_button = Button(label="Select All", button_type="success") select_all_button.on_click(select_all_button_callback) # Add the plot to the current document and add a title layout = row( widgetbox(clear_button, select_all_button, continent_rbg, country_multiselect), lockdown_fig) layout.sizing_mode = 'scale_width' # Creating lockdown tab lockdown_tab = Panel(child=layout, title='Lockdown') return (lockdown_tab)
def create(): config = pyzebra.AnatricConfig() def _load_config_file(file): config.load_from_file(file) logfile_textinput.value = config.logfile logfile_verbosity_select.value = config.logfile_verbosity filelist_type.value = config.filelist_type filelist_format_textinput.value = config.filelist_format filelist_datapath_textinput.value = config.filelist_datapath filelist_ranges_textareainput.value = "\n".join( map(str, config.filelist_ranges)) crystal_sample_textinput.value = config.crystal_sample lambda_textinput.value = config.crystal_lambda zeroOM_textinput.value = config.crystal_zeroOM zeroSTT_textinput.value = config.crystal_zeroSTT zeroCHI_textinput.value = config.crystal_zeroCHI ub_textareainput.value = config.crystal_UB dataFactory_implementation_select.value = config.dataFactory_implementation dataFactory_dist1_textinput.value = config.dataFactory_dist1 reflectionPrinter_format_select.value = config.reflectionPrinter_format set_active_widgets(config.algorithm) if config.algorithm == "adaptivemaxcog": threshold_textinput.value = config.threshold shell_textinput.value = config.shell steepness_textinput.value = config.steepness duplicateDistance_textinput.value = config.duplicateDistance maxequal_textinput.value = config.maxequal aps_window_textinput.value = str( tuple(map(int, config.aps_window.values()))) elif config.algorithm == "adaptivedynamic": adm_window_textinput.value = str( tuple(map(int, config.adm_window.values()))) border_textinput.value = str( tuple(map(int, config.border.values()))) minWindow_textinput.value = str( tuple(map(int, config.minWindow.values()))) reflectionFile_textinput.value = config.reflectionFile targetMonitor_textinput.value = config.targetMonitor smoothSize_textinput.value = config.smoothSize loop_textinput.value = config.loop minPeakCount_textinput.value = config.minPeakCount displacementCurve_textinput.value = "\n".join( map(str, config.displacementCurve)) else: raise ValueError("Unknown processing mode.") def set_active_widgets(implementation): if implementation == "adaptivemaxcog": mode_radio_button_group.active = 0 disable_adaptivemaxcog = False disable_adaptivedynamic = True elif implementation == "adaptivedynamic": mode_radio_button_group.active = 1 disable_adaptivemaxcog = True disable_adaptivedynamic = False else: raise ValueError( "Implementation can be either 'adaptivemaxcog' or 'adaptivedynamic'" ) threshold_textinput.disabled = disable_adaptivemaxcog shell_textinput.disabled = disable_adaptivemaxcog steepness_textinput.disabled = disable_adaptivemaxcog duplicateDistance_textinput.disabled = disable_adaptivemaxcog maxequal_textinput.disabled = disable_adaptivemaxcog aps_window_textinput.disabled = disable_adaptivemaxcog adm_window_textinput.disabled = disable_adaptivedynamic border_textinput.disabled = disable_adaptivedynamic minWindow_textinput.disabled = disable_adaptivedynamic reflectionFile_textinput.disabled = disable_adaptivedynamic targetMonitor_textinput.disabled = disable_adaptivedynamic smoothSize_textinput.disabled = disable_adaptivedynamic loop_textinput.disabled = disable_adaptivedynamic minPeakCount_textinput.disabled = disable_adaptivedynamic displacementCurve_textinput.disabled = disable_adaptivedynamic upload_div = Div(text="Open XML configuration file:") def upload_button_callback(_attr, _old, new): with io.BytesIO(base64.b64decode(new)) as file: _load_config_file(file) upload_button = FileInput(accept=".xml") upload_button.on_change("value", upload_button_callback) # General parameters # ---- logfile def logfile_textinput_callback(_attr, _old, new): config.logfile = new logfile_textinput = TextInput(title="Logfile:", value="logfile.log", width=520) logfile_textinput.on_change("value", logfile_textinput_callback) def logfile_verbosity_select_callback(_attr, _old, new): config.logfile_verbosity = new logfile_verbosity_select = Select(title="verbosity:", options=["0", "5", "10", "15", "30"], width=70) logfile_verbosity_select.on_change("value", logfile_verbosity_select_callback) # ---- FileList def filelist_type_callback(_attr, _old, new): config.filelist_type = new filelist_type = Select(title="File List:", options=["TRICS", "SINQ"], width=100) filelist_type.on_change("value", filelist_type_callback) def filelist_format_textinput_callback(_attr, _old, new): config.filelist_format = new filelist_format_textinput = TextInput(title="format:", width=490) filelist_format_textinput.on_change("value", filelist_format_textinput_callback) def filelist_datapath_textinput_callback(_attr, _old, new): config.filelist_datapath = new filelist_datapath_textinput = TextInput(title="datapath:") filelist_datapath_textinput.on_change( "value", filelist_datapath_textinput_callback) def filelist_ranges_textareainput_callback(_attr, _old, new): ranges = [] for line in new.splitlines(): ranges.append(re.findall(r"\b\d+\b", line)) config.filelist_ranges = ranges filelist_ranges_textareainput = TextAreaInput(title="ranges:", height=100) filelist_ranges_textareainput.on_change( "value", filelist_ranges_textareainput_callback) # ---- crystal def crystal_sample_textinput_callback(_attr, _old, new): config.crystal_sample = new crystal_sample_textinput = TextInput(title="Sample Name:") crystal_sample_textinput.on_change("value", crystal_sample_textinput_callback) def lambda_textinput_callback(_attr, _old, new): config.crystal_lambda = new lambda_textinput = TextInput(title="lambda:", width=140) lambda_textinput.on_change("value", lambda_textinput_callback) def ub_textareainput_callback(_attr, _old, new): config.crystal_UB = new ub_textareainput = TextAreaInput(title="UB matrix:", height=100) ub_textareainput.on_change("value", ub_textareainput_callback) def zeroOM_textinput_callback(_attr, _old, new): config.crystal_zeroOM = new zeroOM_textinput = TextInput(title="zeroOM:", width=140) zeroOM_textinput.on_change("value", zeroOM_textinput_callback) def zeroSTT_textinput_callback(_attr, _old, new): config.crystal_zeroSTT = new zeroSTT_textinput = TextInput(title="zeroSTT:", width=140) zeroSTT_textinput.on_change("value", zeroSTT_textinput_callback) def zeroCHI_textinput_callback(_attr, _old, new): config.crystal_zeroCHI = new zeroCHI_textinput = TextInput(title="zeroCHI:", width=140) zeroCHI_textinput.on_change("value", zeroCHI_textinput_callback) # ---- DataFactory def dataFactory_implementation_select_callback(_attr, _old, new): config.dataFactory_implementation = new dataFactory_implementation_select = Select( title="DataFactory implementation:", options=DATA_FACTORY_IMPLEMENTATION, width=300, ) dataFactory_implementation_select.on_change( "value", dataFactory_implementation_select_callback) def dataFactory_dist1_textinput_callback(_attr, _old, new): config.dataFactory_dist1 = new dataFactory_dist1_textinput = TextInput(title="dist1:", width=290) dataFactory_dist1_textinput.on_change( "value", dataFactory_dist1_textinput_callback) # ---- BackgroundProcessor # ---- DetectorEfficency # ---- ReflectionPrinter def reflectionPrinter_format_select_callback(_attr, _old, new): config.reflectionPrinter_format = new reflectionPrinter_format_select = Select( title="ReflectionPrinter format:", options=REFLECTION_PRINTER_FORMATS, width=300, ) reflectionPrinter_format_select.on_change( "value", reflectionPrinter_format_select_callback) # Adaptive Peak Detection (adaptivemaxcog) # ---- threshold def threshold_textinput_callback(_attr, _old, new): config.threshold = new threshold_textinput = TextInput(title="Threshold:") threshold_textinput.on_change("value", threshold_textinput_callback) # ---- shell def shell_textinput_callback(_attr, _old, new): config.shell = new shell_textinput = TextInput(title="Shell:") shell_textinput.on_change("value", shell_textinput_callback) # ---- steepness def steepness_textinput_callback(_attr, _old, new): config.steepness = new steepness_textinput = TextInput(title="Steepness:") steepness_textinput.on_change("value", steepness_textinput_callback) # ---- duplicateDistance def duplicateDistance_textinput_callback(_attr, _old, new): config.duplicateDistance = new duplicateDistance_textinput = TextInput(title="Duplicate Distance:") duplicateDistance_textinput.on_change( "value", duplicateDistance_textinput_callback) # ---- maxequal def maxequal_textinput_callback(_attr, _old, new): config.maxequal = new maxequal_textinput = TextInput(title="Max Equal:") maxequal_textinput.on_change("value", maxequal_textinput_callback) # ---- window def aps_window_textinput_callback(_attr, _old, new): config.aps_window = dict( zip(("x", "y", "z"), re.findall(r"\b\d+\b", new))) aps_window_textinput = TextInput(title="Window (x, y, z):") aps_window_textinput.on_change("value", aps_window_textinput_callback) # Adaptive Dynamic Mask Integration (adaptivedynamic) # ---- window def adm_window_textinput_callback(_attr, _old, new): config.adm_window = dict( zip(("x", "y", "z"), re.findall(r"\b\d+\b", new))) adm_window_textinput = TextInput(title="Window (x, y, z):") adm_window_textinput.on_change("value", adm_window_textinput_callback) # ---- border def border_textinput_callback(_attr, _old, new): config.border = dict(zip(("x", "y", "z"), re.findall(r"\b\d+\b", new))) border_textinput = TextInput(title="Border (x, y, z):") border_textinput.on_change("value", border_textinput_callback) # ---- minWindow def minWindow_textinput_callback(_attr, _old, new): config.minWindow = dict( zip(("x", "y", "z"), re.findall(r"\b\d+\b", new))) minWindow_textinput = TextInput(title="Min Window (x, y, z):") minWindow_textinput.on_change("value", minWindow_textinput_callback) # ---- reflectionFile def reflectionFile_textinput_callback(_attr, _old, new): config.reflectionFile = new reflectionFile_textinput = TextInput(title="Reflection File:") reflectionFile_textinput.on_change("value", reflectionFile_textinput_callback) # ---- targetMonitor def targetMonitor_textinput_callback(_attr, _old, new): config.targetMonitor = new targetMonitor_textinput = TextInput(title="Target Monitor:") targetMonitor_textinput.on_change("value", targetMonitor_textinput_callback) # ---- smoothSize def smoothSize_textinput_callback(_attr, _old, new): config.smoothSize = new smoothSize_textinput = TextInput(title="Smooth Size:") smoothSize_textinput.on_change("value", smoothSize_textinput_callback) # ---- loop def loop_textinput_callback(_attr, _old, new): config.loop = new loop_textinput = TextInput(title="Loop:") loop_textinput.on_change("value", loop_textinput_callback) # ---- minPeakCount def minPeakCount_textinput_callback(_attr, _old, new): config.minPeakCount = new minPeakCount_textinput = TextInput(title="Min Peak Count:") minPeakCount_textinput.on_change("value", minPeakCount_textinput_callback) # ---- displacementCurve def displacementCurve_textinput_callback(_attr, _old, new): maps = [] for line in new.splitlines(): maps.append(re.findall(r"\d+(?:\.\d+)?", line)) config.displacementCurve = maps displacementCurve_textinput = TextAreaInput( title="Displacement Curve (twotheta, x, y):", height=100) displacementCurve_textinput.on_change( "value", displacementCurve_textinput_callback) def mode_radio_button_group_callback(active): if active == 0: config.algorithm = "adaptivemaxcog" set_active_widgets("adaptivemaxcog") else: config.algorithm = "adaptivedynamic" set_active_widgets("adaptivedynamic") mode_radio_button_group = RadioButtonGroup( labels=["Adaptive Peak Detection", "Adaptive Dynamic Integration"], active=0) mode_radio_button_group.on_click(mode_radio_button_group_callback) set_active_widgets("adaptivemaxcog") def process_button_callback(): with tempfile.TemporaryDirectory() as temp_dir: temp_file = temp_dir + "/temp.xml" config.save_as(temp_file) pyzebra.anatric(temp_file) with open(config.logfile) as f_log: output_log.value = f_log.read() process_button = Button(label="Process", button_type="primary") process_button.on_click(process_button_callback) output_log = TextAreaInput(title="Logfile output:", height=700, disabled=True) output_config = TextAreaInput(title="Current config:", height=700, width=400, disabled=True) tab_layout = row( column( upload_div, upload_button, row(logfile_textinput, logfile_verbosity_select), row(filelist_type, filelist_format_textinput), filelist_datapath_textinput, filelist_ranges_textareainput, crystal_sample_textinput, row(lambda_textinput, zeroOM_textinput, zeroSTT_textinput, zeroCHI_textinput), ub_textareainput, row(dataFactory_implementation_select, dataFactory_dist1_textinput), reflectionPrinter_format_select, process_button, ), column( mode_radio_button_group, row( column( threshold_textinput, shell_textinput, steepness_textinput, duplicateDistance_textinput, maxequal_textinput, aps_window_textinput, ), column( adm_window_textinput, border_textinput, minWindow_textinput, reflectionFile_textinput, targetMonitor_textinput, smoothSize_textinput, loop_textinput, minPeakCount_textinput, displacementCurve_textinput, ), ), ), output_config, output_log, ) async def update_config(): config.save_as("debug.xml") with open("debug.xml") as f_config: output_config.value = f_config.read() curdoc().add_periodic_callback(update_config, 1000) return Panel(child=tab_layout, title="Anatric")
Button(label="Primary Button 2", button_type="primary"), Button(label="Success Button 3", button_type="success"), Toggle(label="Default Toggle 1", button_type="default"), Toggle(label="Primary Toggle 2", button_type="primary"), Toggle(label="Success Toggle 3", button_type="success"), Dropdown(label="Default Dropdown 1", button_type="default", menu=menu), Dropdown(label="Primary Dropdown 2", button_type="primary", menu=menu), Dropdown(label="Success Dropdown 3", button_type="success", menu=menu), CheckboxButtonGroup(labels=["Checkbox Option 1", "Checkbox Option 2", "Checkbox Option 3"], button_type="default", active=[0, 1]), CheckboxButtonGroup(labels=["Checkbox Option 4", "Checkbox Option 5", "Checkbox Option 6"], button_type="primary", active=[1, 2]), CheckboxButtonGroup(labels=["Checkbox Option 7", "Checkbox Option 8", "Checkbox Option 9"], button_type="success", active=[0, 2]), RadioButtonGroup(labels=["Radio Option 1", "Radio Option 2", "Radio Option 3"], button_type="default", active=0), RadioButtonGroup(labels=["Radio Option 4", "Radio Option 5", "Radio Option 6"], button_type="primary", active=1), RadioButtonGroup(labels=["Radio Option 7", "Radio Option 8", "Radio Option 9"], button_type="success", active=2), TextInput(placeholder="TextInput 1"), TextInput(placeholder="TextInput 2"), TextInput(placeholder="TextInput 3"), AutocompleteInput(placeholder="AutocompleteInput 1 ...", completions=["aaa", "aab", "aac", "baa", "caa"]), AutocompleteInput(placeholder="AutocompleteInput 2 ...", completions=["AAA", "AAB", "AAC", "BAA", "CAA"]), AutocompleteInput(placeholder="AutocompleteInput 3 ...", completions=["000", "001", "002", "100", "200"]), DatePicker(value=date(2018, 9, 1)), DatePicker(value=date(2018, 9, 2)), DatePicker(value=date(2018, 9, 3)), )
map_plot_glyphs[i].glyph.line_color = "#8f8f8f" elevation_graph_glyphs[i].glyph.line_alpha = 0.2 gradient_graph_glyphs[i].glyph.line_alpha = 0.2 map_plot_glyphs[i].glyph.line_alpha = 0.3 gradient_histogram_glyphs[i].visible = False ############################### # Route selection pane (left) # ############################### origin_input = TextInput(width=400, title="Origin") destination_input = TextInput(width=400, title="Destination") type_input = RadioButtonGroup( labels=["Bicycle", "Driving", "Walking"], width=400, active=0 ) go_button = Button(width=400, label="Search", button_type="success") go_button.on_click(find_routes) alert_holder = PreText(text="", css_classes=['hidden'], visible=False) alert = CustomJS(args={}, code='alert(cb_obj.text);') alert_holder.js_on_change("text", alert) result_picker = RadioGroup(labels=[], width=400) result_picker.on_change("active", display_results) route_selection_pane = column( Div(text="<h2>Search</h2>"), origin_input,
width=5, height=1, color=DARK_GRAY) # create components -------------- title_div = Div( text= 'Revenue Impact of a 4% Surtax on Taxpayers with Adjusted Gross Income over $5 Million', height=30) radio_group_text = Div(text="Include Additional Capital Gains Behavior.") radio_group = RadioGroup(labels=["Without", "With"], active=0) sources['radio_group'] = radio_group elasticity_text = Div(text="Elasticity of Taxable Income") elasticity_option = RadioButtonGroup( labels=sources['capital_gains_no'].data['labels'], active=0) sources['elasticity_option'] = elasticity_option # create callbacks --------------- radio_group.callback = CustomJS(args=sources, code=""" var capitalGainsType = radio_group.active === 0 ? capital_gains_no : capital_gains_yes; elasticity_option.set('labels', capitalGainsType.data.labels); while (elasticity_option.active > capitalGainsType.data.source_ids.length - 1) { elasticity_option.active = elasticity_option.active - 1; } ref.data = eval(capitalGainsType.data.source_ids[elasticity_option.active]).data; ref.trigger('change'); """)
def barchart(df): def make_dataset(df, usageType): df_verwerkt = df[df['attributeName'] == usageType] df_verwerkt = df_verwerkt.sort_values('time') df_verwerkt = df_verwerkt.replace(0, np.NaN) df_verwerkt = df_verwerkt.fillna(method='ffill') df_verwerkt = df_verwerkt.fillna( method='bfill') # nodig om eerste rij te fixen. df_verwerkt['time'] = pd.to_datetime(df_verwerkt['time'], unit='ms', utc=True) df_verwerkt['time'] = df_verwerkt['time'].apply( lambda x: x.astimezone(timezone('Europe/Amsterdam'))) df_verwerkt['hour'] = df_verwerkt['time'].dt.hour df_verwerkt['minutes'] = (df_verwerkt['time'].dt.hour * 60) + df_verwerkt['time'].dt.minute df_verwerkt['dayofweek'] = df_verwerkt['time'].dt.dayofweek df_verwerkt['difference'] = df_verwerkt['value'].diff() df_verwerkt['difference'] = df_verwerkt['difference'].fillna(0) df_verwerkt[df_verwerkt['difference'] > 1000] = 0 # sprong naar Nederhoven uitfilteren df_verwerkt = df_verwerkt[df_verwerkt['difference'] > 0] df_verwerkt = remove_outlier(df_verwerkt, 'difference') groupby = df_verwerkt.groupby('minutes').sum() return ColumnDataSource(data=groupby) def make_plot(src): # Deze regel maakt een dict met de vorm {0: '00:00', 1: '00:01', ... t/m 1440 voor alle minuten van de dag. # In feite zet deze regel alle minuten van 0 t/m 1440 om in een string met tijd voor de x-as. d = { i: f"{floor(i/60):02d}" + ":" + f"{int(i%60):02d}" for i in range(1440) } p = figure(title='Bar chart', x_range=(0, 1440), tools=TOOLS, background_fill_color="#fafafa") p.sizing_mode = 'stretch_both' # https://docs.bokeh.org/en/latest/docs/user_guide/layout.html p.vbar(x='minutes', bottom=0, top='difference', source=src, width=0.9, color={ 'field': 'difference', 'transform': color_mapper }) p.y_range.start = 0 p.xaxis.axis_label = 'Tijd' p.xaxis.major_label_overrides = d p.yaxis.axis_label = 'Verbruik' p.grid.grid_line_color = "white" return p def update(attr, old, new): # Get the selected items for the graph # ... selected = radio_button_group.active usageType = 'gastotalusage' # standaardwaarde # Koppel de selectie aan de juiste gegevens uit het DataFrame if selected == 0: usageType = 'gastotalusage' p.title.text = 'Gasverbruik per minuut' elif selected == 1: usageType = 'tariff1totalusage' p.title.text = 'Stroomtarief 1 verbruik' elif selected == 2: usageType = 'tariff2totalusage' p.title.text = 'Stroomtarief 2 verbruik' print('Update usageType: ' + str(usageType)) # update data new_src = make_dataset(df, usageType) src.data.update(new_src.data) radio_button_group = RadioButtonGroup( labels=["Gas", "Tarief 1", "Tarief 2"], active=0) radio_button_group.on_change('active', update) # initial execution src = make_dataset(df, 'gastotalusage') p = make_plot(src) # make a grid grid = gridplot([[p], [radio_button_group]]) grid.sizing_mode = 'scale_width' tab = Panel(child=grid, title='Bar chart') print("barchart() uitgevoerd") return tab
def __init__(self): ### Methods self.args = Settings() self.index = None self.data_getter = None self.filter = None self._data = None self._model_type = None self._model_dir = self.args.models_path + 'unique_object/' self.controls = {} self.scene_plotter = ScenePlotter(self._set_head_selection) ### initialization of the interface ## Model type selector def update_select_net(): if self._model_dir is not None: file_list = [fn for fn in os.listdir(self._model_dir) if os.path.isfile(os.path.join(self._model_dir, fn))] file_list.sort(key=lambda fn: os.stat(os.path.join(self._model_dir, fn)).st_mtime, reverse=True) file_list = [os.path.splitext(fn)[0] for fn in file_list] self.controls['net'].options = file_list # print(self._model_dir) # print('file_list') # print(file_list) if len(file_list) > 0: self.controls['net'].value = file_list[0] else: self.controls['net'].value = None def update_model_type(): if self.controls['multi_mono_object'].active == 0: self._model_type = 'mono' self._model_dir = self.args.models_path + 'unique_object/' elif self.controls['multi_mono_object'].active == 1: self._model_type = 'multi_obj' self._model_dir = self.args.models_path + 'multi_objects/' elif self.controls['multi_mono_object'].active == 2: self._model_type = 'multi_pred' self._model_dir = self.args.models_path + 'multi_pred/' model_types = ['CV', 'CA', 'Bicycle', 'CV_LSTM', 'CA_LSTM', 'Bicycle_LSTM', 'nn_attention'] existing_types = [type for type in model_types if os.path.isdir(self._model_dir + type)] self.controls['model_sub_type'].options = existing_types print('existing types') print(existing_types) if len(existing_types) > 0 and not self.controls['model_sub_type'].value in existing_types: self.controls['model_sub_type'].value = existing_types[0] return set_model_sub_type() update_select_net() def set_model_sub_type(): if self.controls['model_sub_type'].value is not None: self._model_dir = self._model_dir + self.controls['model_sub_type'].value + '/' self.args.model_type = self.controls['model_sub_type'].value else: self._model_dir = None def update_multi_mono_object(attr, old, new): update_model_type() print(self._model_dir) self._set_data_getter() print('___') multi_mono_object = RadioButtonGroup(labels=["Mono-object", "Multi-objects", "Multi-pred"], active=1) self.controls['multi_mono_object'] = multi_mono_object multi_mono_object.on_change('active', update_multi_mono_object) ## Model sub type selector model_types = ['CV', 'CA', 'Bicycle', 'CV_LSTM', 'CA_LSTM', 'Bicycle_LSTM', 'nn_attention'] model_sub_type = Select(title='Select model type:', value=model_types[3], options=model_types) self.controls['model_sub_type'] = model_sub_type model_sub_type.on_change('value', lambda att, old, new: update_model_type()) ## Model selector select = Select(title="Select parameter file:", value=None, options=[]) self.controls['net'] = select select.on_change('value', lambda att, old, new: self._set_data_getter()) ## Select dataset to use dataset_list = ['Argoverse', 'Fusion', 'NGSIM'] select = Select(title='Dataset:', value=dataset_list[0], options=dataset_list) self.controls['dataset'] = select select.on_change('value', lambda att, old, new: self._set_data_getter(change_index=True)) ## Set what to draw checkbox_group = CheckboxGroup( labels=['Draw lanes', 'Draw history', 'Draw true future', 'Draw forecast', 'Draw forecast covariance'], active=[0, 1, 2, 3, 4]) self.controls['check_box'] = checkbox_group checkbox_group.on_change('active', lambda att, old, new: (self._update_cov(), self._update_lanes(), self._update_path())) ## Set the number of pred n_pred = Slider(start=1, end=6, step=1, value=1, title='Number of prediction hypothesis') self.controls['n_pred'] = n_pred n_pred.on_change('value', lambda att, old, new: (self._update_cov(), self._update_path())) ## Sequence ID input text_input = TextInput(title="Sequence ID to plot:", value="Random") self.controls['sequence_id'] = text_input ## Head selection input multi_select_head = MultiSelect(title='Attention head multiple selection:', value=[], options=[]) self.controls['Head_selection'] = multi_select_head multi_select_head.on_change('value', self.scene_plotter.set_active_heads) ## Refresh all sample button = Button(label="Refresh", button_type="success") self.controls['refresh'] = button button.on_click( lambda event: (self._set_index(), self._set_data())) # button.js_on_click(CustomJS(args=dict(p=self.image), code="""p.reset.emit()""")) update_multi_mono_object(None, None, None) ## Set the interface layout inputs = column(*(self.controls.values()), width=320, height=1000) inputs.sizing_mode = "fixed" lay = layout([[inputs, self.scene_plotter.get_image()]], sizing_mode="scale_both") curdoc().add_root(lay) self.scene_plotter._tap_on_veh('selected', [], [0])
data = data.cpu().detach().numpy() p = figure(plot_height=int(880*0.8), plot_width=int(1680*0.8)) p.image(image='image', x=0, y=0, dw=168, dh=88, palette="Viridis256", source = source) energy_slider = Slider(title="Energy", value = data[0][8], start = 0., end = 2000., step = 10.) phi_slider = Slider(title="Azimuthal angle", value = np.arctan2(data[0][7], data[0][5]), start = -np.pi, end = np.pi, step = np.pi/10.) coseta_slider = Slider(title="Cosine of zenith angle", value = data[0][6], start = -0.999, end = 0.999, step = 1/20.) posx_slider = Slider(title="Position x", value = data[0][2], start = -250., end = 250., step = 500./20) posy_slider = Slider(title="Position y", value = data[0][3], start = -250., end = 250., step = 500./20) posz_slider = Slider(title="Position z", value = data[0][4], start = -250., end = 250., step = 500./20) PID_button = RadioButtonGroup(labels=["gamma", "electron", "muon"], active=0) inputs = row(column(PID_button,energy_slider), column(phi_slider,coseta_slider), column(posx_slider, posy_slider, posz_slider)) def update_data(attrname, old, new) : energy = energy_slider.value phi = phi_slider.value coseta = coseta_slider.value dx = np.cos(phi) dy = coseta dz = np.sin(phi) r = (1-dy**2)**0.5 if r :
menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"), None, ("Item 3", "item_3_value")] dropdown = Dropdown(label="Dropdown button", button_type="warning", menu=menu) dropdown_split = Dropdown(label="Split button", button_type="danger", menu=menu, split=True) checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1]) radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0) checkbox_button_group = CheckboxButtonGroup( labels=["Option 1", "Option 2", "Option 3"], active=[0, 1]) radio_button_group = RadioButtonGroup( labels=["Option 1", "Option 2", "Option 3"], active=0) checkbox_button_group_vertical = CheckboxButtonGroup( labels=["Option 1", "Option 2", "Option 3"], active=[0, 1], orientation="vertical") radio_button_group_vertical = RadioButtonGroup( labels=["Option 1", "Option 2", "Option 3"], active=0, orientation="vertical") text_input = TextInput(placeholder="Enter value ...") completions = ["aaa", "aab", "aac", "baa", "caa"] autocomplete_input = AutocompleteInput( placeholder="Enter value (auto-complete) ...", completions=completions)
def main(): #path variables #in_path = '/mnt/data04/Conduit/afib/new_files/1hour/' #af_outpath = '/mnt/data04/Conduit/afib/AF_annotations/af_ann4/' in_path = join(dirname(__file__), "data_in/") af_outpath = join(dirname(__file__), "data_out/") #Miscellaneous variables colours = { '': 'black', 'O': 'blue', 'N': 'green', '~': 'purple', 'A': 'red' } #wf_classes = ['AF','Normal','Other','Noise','No Signal'] wf_classes = ['AF', 'Not AF'] #global variables remove if you can newECG = pd.DataFrame() df_ann = pd.DataFrame(columns=[0]) #widgets to be used as necessary rdo_btn_wave_lbls = RadioButtonGroup(labels=wf_classes, active=2) date_range_slider = Slider(title="Date Range", step=10) table_source, table_columns = load_file_source(in_path, af_outpath) file_table = DataTable(source=table_source, columns=table_columns, width=800, height=600) pgph_file_loaded = Div(text="Select file from table.", width=1000, height=50) pgph_file_loaded.style = { "font-size": '1.2em', 'font-weight': 'bold', 'color': 'SteelBlue' } txt_processing = Div( text= "Use slider to select segments, label by selecting the wave type and pressing 'Label'. Use the save to save when finished all annotations.", width=1000, height=30) txt_processing.style = { "font-size": '1.2em', 'font-weight': 'bold', 'color': 'SteelBlue', 'white-space': 'pre' } btn_lbl = Button(label='Label', button_type='success') btn_save = Button(label='Save', button_type='danger') btn_load_annotated_graph = Button(label='Load Annotated Graph', button_type='warning') #----------------------------- Functions ---------------------------------# ''' Callback function for the data table ColumnDataSource (table_source). Load the hd5 file based on the selected row in the data_table. Generate the output file path. Update the date range slider according to the new file (date_range_slider). Generate a plot of the hd5 ECG lead II data (wave_graph). Then combine all into a layout (graph_layout) Update the Tab Pane with this new layout. Returns: Nothing''' def callback_select_file_table(attr, old, new): global newECG, out_file #clear tabs graphs to reduce overhead output_tab.child.children = [] sel_id = new txt_processing.text = "Use slider to select segments, label by selecting the wave type and pressing 'Label'. Use the save button to when done." txt_processing.style = {"font-size": '1.2em', 'color': 'SteelBlue'} wave_file_path = load_selected_file(table_source, sel_id) out_file = load_annotation_file( table_source, sel_id, af_outpath) #to be used for saving the file pgph_file_loaded.text = "Processing..." wave_hdfs, hdfs_keys = load_hd5_file(wave_file_path) print(hdfs_keys) newECG = (wave_hdfs.select( key='Waveforms').II).to_frame() #get lead II from waveforms) newECG.reset_index( inplace=True) #move datetime index to column and reset the index newECG.columns = ['date', 'II'] wave_hdfs.close() #enable the buttons if disabled btn_save.disabled = False btn_lbl.disabled = False btn_load_annotated_graph.disabled = True #check if the file has already been annotated annotated = check_if_annotated(table_source, sel_id) if annotated == 'Yes': txt_processing.text = 'This file has already been annotated. If you save this file again you will overwrite previous data.' txt_processing.style = {"font-size": '1.2em', 'color': 'Red'} btn_load_annotated_graph.disabled = False #create figure print("*********************Creating Figure (in Callback File Select)") get_next_graph(0, newECG) pgph_file_loaded.text = "File loaded, navigate Label Data Tab to annotate lead II." ''' Using the AF annotation file, create a Bokeh figure with annotated data. Update the output_tab to show this figure. Disable some buttons to keep users on track. ''' def load_output_graph(): global newECG btn_save.disabled = True btn_lbl.disabled = True btn_load_annotated_graph.disabled = True txt_processing.text = 'Loading Plot...' df_AF = pd.read_hdf(out_file) noise, normal, other, af, nosig, notAF = load_annotations( 0, df_AF.shape[0] - 1, newECG, df_AF) output_graph = get_graph_annotated(noise, normal, other, af, nosig, notAF) output_tab.child.children = [output_graph] txt_processing.text = 'Plot loaded, navigate to "Final Annotated Graph" tab to view. 
 If you save this file again you will overwrite previous data.' btn_save.disabled = False btn_lbl.disabled = False def get_next_graph(sind, df): length = 20000 #7200 eind = sind + length if eind <= list(df.index)[-1] and sind < list( df.index )[-1]: #as long as the end and beginning are less than the end of the dataframe sub_df = df.iloc[sind:eind] sub_df = sub_df.set_index('date') del sub_df.index.name source = ColumnDataSource(sub_df) wave_graph = get_graph(source) start_span, end_span = add_span(source) wave_graph.add_layout(start_span) wave_graph.add_layout(end_span) start_rng = start_span.location end_rng = end_span.location elif eind < list(df.index)[-1] and sind < list( df.index )[-1]: #if the start is before but the end is after then just use the end of the dataframe sub_df = df.iloc[sind:list(df.index)[-1]] sub_df = sub_df.set_index('date') del sub_df.index.name source = ColumnDataSource(sub_df) wave_graph = get_graph(source) start_span, end_span = add_span(source) wave_graph.add_layout(start_span) wave_graph.add_layout(end_span) start_rng = start_span.location end_rng = end_span.location else: txt_processing.text = 'You have finished annotating this file.' return end_span.location = start_span.location #slider to change date range date_range_slider.start = start_rng date_range_slider.end = end_rng date_range_slider.value = start_rng date_range_slider.on_change('value', callback_date_time_slider) graph_layout = column( widgetbox([txt_processing, btn_load_annotated_graph, btn_save], width=250), widgetbox(Div(text="""<hr/>""", style={ 'display': 'block', 'height': '1px', 'border': '0', 'border-top': '1px solid #css', 'margin': '1em 0', 'padding': '0' }), width=1400), widgetbox([rdo_btn_wave_lbls, btn_lbl], width=300), widgetbox(date_range_slider, width=1350), widgetbox(Div(text="""<hr/>""", style={ 'display': 'block', 'height': '1px', 'border': '0', 'border-top': '1px solid #css', 'margin': '1em 0', 'padding': '0' }), width=1400), wave_graph) wf_tab.child.children = [graph_layout] ''' Use a ColumnDataSource to plot the ECG lead II waveform data in a line plot. Parameters: source a ColumnDataSource Returns: p a Bokeh figure ''' def get_graph(source): p = figure(plot_width=1400, plot_height=500, x_axis_type='datetime', tools=['zoom_in', 'zoom_out', 'xpan', 'ypan']) date_range = source.data['II'][0:20000] p.y_range = Range1d(start=min(date_range) - 1, end=max(date_range) + 1) dt_axis_format = ["%d-%m-%Y %H:%M"] wf_x_axis = DatetimeTickFormatter( hours=dt_axis_format, days=dt_axis_format, months=dt_axis_format, years=dt_axis_format, ) p.xaxis.formatter = wf_x_axis p.line(x='index', y='II', source=source, line_color='black', line_width=1) return p ''' Get the first and last time points from the ColumnDataSource (source). Utlizes tzlocal to add an offset which modifies the data. Returns integer timetuple value for the dates found: start, end ''' def get_time(source): start = pd.to_datetime(min(source.data['index'])).timestamp() * 1000 end = pd.to_datetime(max(source.data['index'])).timestamp() * 1000 return start, end ''' Generate two Bokeh Spans based on the ColumnDataSource given (source). Spans are at the first and last datetimes in the source data. Parameters: source a ColumnDataSource Returns: Span, Span ''' def add_span(source): start, end = get_time(source) # Start span represents the start of the area of interest start_span = Span(location=start, dimension='height', line_color='green', line_dash='dashed', line_width=3) # End span represents the end of the area of interest end_span = Span(location=end, dimension='height', line_color='red', line_dash='dashed', line_width=3) return start_span, end_span ''' Callback function for Bokeh Slider, move the Spans on the specified graph (generated in callback_file_table) to the location specified by the Span. Returns: Nothing ''' def callback_date_time_slider(attr, old, new): inds = get_spans() wf_tab.child.children[0].children[5].renderers[inds[1]].location = new ''' Navigate through the widgets on the wave_graph to find the spans Returns the widget indexes of the spans''' def get_spans(): inds = [] for x in range(len(wf_tab.child.children[0].children[5].renderers)): if isinstance(wf_tab.child.children[0].children[5].renderers[x], Span): inds.append(x) return inds ''' Callback function for btn_lbl. Get the location of the spans from the wave_graph, then call segment_and_label Return: Nothing ''' def callback_btn_lbl(): inds = get_spans() active = rdo_btn_wave_lbls.labels[rdo_btn_wave_lbls.active] start_span = wf_tab.child.children[0].children[5].renderers[inds[0]] end_span = wf_tab.child.children[0].children[5].renderers[inds[1]] segment_and_label(active, start_span.location, end_span.location) ''' Function to get ECG data between two Spans (after modifying the timetuple to timestamp). Call apply_annotations using start and end indexes found. Modify the global df_ann variable. Update slider position (start to end), (end to start). Parameters: label a string (AF, Normal, Noise, Other), start a timpletuple integer, end a timetuple integer Return: nothing ''' def segment_and_label(label, start, end): global newECG print("*********************Segmenting and Labelling") try: txt_processing.text = "Use slider to select segments, label by selecting the wave type and pressing 'Label'. Use the save button to when done." start_dt = pd.Timestamp(start / 1000, unit='s') end_dt = pd.Timestamp(end / 1000, unit='s') mask = (newECG['date'] > start_dt) & (newECG['date'] <= end_dt) df_sub = newECG.loc[mask] #apply mask indexes = list(df_sub.index) #get indexes s_ind = indexes[0] #get first index e_ind = indexes[-1] #get last index apply_annotations(label, s_ind, e_ind, df_ann) #concatenate dataframe of annotations get_next_graph(e_ind, newECG) except IndexError: txt_processing.text = 'Indexing error. Advance slider.' ''' Function to apply annotations to a dataframe structured like that of Computing in Cardiology AF algorithm. Parameters: label a string (AF, Normal, Noise, Other), s_ind the index of the start datetime, e_ind the index of the end datetime, df a pandas database to be appended to, columns= 'AF' Return: Nothing ''' def apply_annotations(label, s_ind, e_ind, df): #data frame structure like this if label == 'AF': df.loc[s_ind, 0] = 'A' elif label == 'Not AF': df.loc[s_ind, 0] = 'nAF' elif label == 'Noise': df.loc[s_ind, 0] = '~' elif label == 'Normal': df.loc[s_ind, 0] = 'N' elif label == 'Other': df.loc[s_ind, 0] = 'O' elif label == 'No Signal': df.loc[s_ind, 0] = '-' ''' Stream update to ColumnDataSource that the file has been annotated''' def mark_as_done(file_path): print("*********************Marking as Done") table_source = file_table.source name = os.path.splitext(os.path.basename(file_path))[0] #get file name ind = list(table_source.data['name']).index( name) #get index within the source patches = { 'annotated': [(ind, 'Yes')] } #new data to update ColumnDataSource with table_source.patch(patches) #update - ***** THROWING ERROR - CHECK!! ''' Callback function for btn_save. Utilizes the out_file global variable for the path. Appends dataframe to output file. ''' def callback_save_annotations(): print("*********************Saving Annotations") txt_processing.style = {"font-size": '1.2em', 'color': 'Red'} print("Writting: ", out_file) txt_processing.text = 'Saving Annotations...' df_ann.to_hdf(out_file, key='AF', format='t') print("success!") btn_save.disabled = True btn_lbl.disabled = True mark_as_done(out_file) nrows = df_ann.shape[0] df_ann.drop(df_ann.index[:nrows], inplace=True) #clear dataframe for a new file to be loaded btn_load_annotated_graph.disabled = False txt_processing.style = {"font-size": '1.2em', 'color': 'SteelBlue'} txt_processing.text = '''Done. Click 'Load Annotated Graph' to view annotations or to "File Management" to select new file to anntoate. You will need to reload this file to make changes.''' ''' Load annotations from AF formatted hdf file. ''' def load_annotations(start, end, df, df_AF): # Initialize empty dataframes noise = pd.DataFrame() normal = pd.DataFrame() other = pd.DataFrame() af = pd.DataFrame() nosig = pd.DataFrame() notAF = pd.DataFrame() # Read annotations for n in range(start, end): df_temp = df.iloc[df_AF.index[n]:df_AF.index[n + 1]] df_temp.index = list(df_temp['date']) df_temp.drop(columns='date') value = df_AF.iloc[n, 0] if value == '~': noise = noise.append(df_temp) elif value == 'N': normal = normal.append(df_temp) elif value == 'O': other = other.append(df_temp) elif value == 'A': af = af.append(df_temp) elif value == '-': nosig = nosig.append(df_temp) elif value == 'nAF': notAF = notAF.append(df_temp) #add the last labelled section (end+1) to end of df df_temp = df.iloc[df_AF.index[end]:df.index[-1]] df_temp.index = list(df_temp['date']) df_temp.drop(columns='date') value = df_AF.iloc[end, 0] if value == '~': noise = noise.append(df_temp) elif value == 'N': normal = normal.append(df_temp) elif value == 'O': other = other.append(df_temp) elif value == 'A': af = af.append(df_temp) elif value == '-': nosig = nosig.append(df_temp) elif value == 'nAF': notAF = notAF.append(df_temp) return noise, normal, other, af, nosig, notAF ''' Create Bokeh figure from dataframes af, normal, other and noise. ''' def get_graph_annotated(noise, normal, other, af, nosig, notAF): p = figure( plot_width=1400, plot_height=500, x_axis_type='datetime', tools=['box_zoom', 'wheel_zoom', 'pan', 'reset', 'crosshair']) # plot color coded waves (if they exist) if noise.empty is False: p.line(x='index', y='II', source=noise, color='blue', legend='Noise') if normal.empty is False: p.line(x='index', y='II', source=normal, color='green', legend='Normal') if other.empty is False: p.line(x='index', y='II', source=other, color='purple', legend='Other') if af.empty is False: p.line(x='index', y='II', source=af, color='red', legend='AF') if nosig.empty is False: p.line(x='index', y='II', source=nosig, color='black', legend='No Signal') if notAF.empty is False: p.line(x='index', y='II', source=notAF, color='grey', legend='No Signal') dt_axis_format = ["%d-%m-%Y %H:%M"] wf_x_axis = DatetimeTickFormatter( hours=dt_axis_format, days=dt_axis_format, months=dt_axis_format, years=dt_axis_format, ) p.xaxis.formatter = wf_x_axis return p ############################## Assign Callbacks ########################################## #table_source.on_change('selected', callback_select_file_table) #assign callback table_source.selected.on_change('indices', callback_select_file_table) btn_lbl.on_click(callback_btn_lbl) btn_save.on_click(callback_save_annotations) btn_load_annotated_graph.on_click(load_output_graph) ################################## Load Document ########################################## ####layouts#### file_layout = column(widgetbox(pgph_file_loaded, file_table, width=1000)) col_waveforms = column(name="figures", sizing_mode='scale_width') col_output = column(name="output", sizing_mode='scale_width') ###tabs### wf_tab = Panel(child=col_waveforms, title='Label Data') file_tab = Panel(child=file_layout, title='File Management') output_tab = Panel(child=col_output, title='Final Annotated Graph') tab_pane = Tabs(tabs=[file_tab, wf_tab, output_tab], width=1000) ###combine into document#### curdoc().add_root(column(tab_pane)) curdoc().title = "AF Annotator 4"
("Daily New Cases per Capita", "@dnc"), ], renderers=[cantons]) p1.add_tools(hover) # T2.3 Add circles at the locations of capital cities for each canton, and the sizes are proportional to daily new cases per capita sites = p1.circle('long', 'lat', source=geosource, color='violet', size='size', alpha=0.33) # T2.4 Create a radio button group with labels 'Density', and 'BedsPerCapita' buttons = RadioButtonGroup(labels=['Density', 'BedPerCapita'], active=0) # Define a function to update color mapper used in both patches and colorbar def update_bar(new): for i, d in enumerate(labels): if i == new: color_bar.color_mapper = mappers[d]["transform"] color_bar.title = d cantons.glyph.fill_color = mappers[d] buttons.on_click(update_bar) # T2.5 Add a dateslider to control which per capita daily new cases information to display
def prepare_server(doc, input_data, cell_stack, cell_markers=None, default_cell_marker=None): @lru_cache() def image_markers(lower=False, mapping=False): if mapping: return { y: j for j, y in sorted( ((i, x) for i, x in enumerate( image_markers(lower=lower, mapping=False))), key=lambda x: x[1].lower(), ) } if lower: return [ x.lower() for x in image_markers(lower=False, mapping=False) ] return (cell_markers if cell_markers is not None else [f"Marker {i + 1}" for i in range(cell_stack.shape[1])]) # Data sources ########################################################################### def prepare_data(input_data): data = input_data.copy() if "contour" in data and not all(x in data for x in ["contour_x", "contour_y"]): contour = parse_contour(data["contour"]) data["contour_x"] = contour[0] data["contour_y"] = contour[1] if "marked" not in data: data["marked"] = np.full(data.shape[0], "") source.data = data source = ColumnDataSource(data={}) prepare_data(input_data) image_source = ColumnDataSource( data=dict(image=[], dw=[], dh=[], contour_x=[], contour_y=[])) # Cell picture plot ########################################################################### def add_outline(): data = source.data if all(x in data for x in ["contour_x", "contour_y"]): cell_outline = cell_figure.patches( xs="contour_x", ys="contour_y", fill_color=None, line_color="red", name="cell_outline", source=image_source, ) cell_outline.level = "overlay" else: cell_outline = cell_figure.select(name="cell_outline") for x in cell_outline: cell_figure.renderers.remove(x) default_cell_marker = (0 if default_cell_marker is None else image_markers( mapping=True)[default_cell_marker]) cell_markers_select = Select( value=str(default_cell_marker), options=list( (str(i), x) for x, i in image_markers(mapping=True).items()), title="Marker cell image", ) cell_marker_input = AutocompleteInput( completions=list(image_markers()) + list(image_markers(lower=True)), min_characters=1, placeholder="Search for marker", ) cell_slider = RangeSlider(start=0, end=1, value=(0, 1), orientation="vertical", direction="rtl") metric_select = RadioButtonGroup(active=0, labels=CELL_IMAGE_METRICS[0]) stats = PreText(text="", width=100) cell_mapper = bokeh.models.mappers.LinearColorMapper(viridis(20), low=0, high=1000, high_color=None) cell_color_bar = ColorBar(color_mapper=cell_mapper, width=12, location=(0, 0)) cell_figure = figure( plot_width=450, plot_height=350, tools="pan,wheel_zoom,reset", toolbar_location="left", ) cell_image = cell_figure.image( image="image", color_mapper=cell_mapper, x=0, y=0, dw="dw", dh="dh", source=image_source, ) add_outline() cell_figure.add_layout(cell_color_bar, "right") # Edit data of selected cells ########################################################################### marker_edit_container = column() marker_edit_instances = [] def add_marker_edit_callback(): editor = ColumnEditor( source, marker_edit_container, log_widget=edit_selecton_log, editor_delete_callback=delete_marker_edit_callback, external_edit_callback=edit_selection_callback, ) marker_edit_instances.append(editor) def delete_marker_edit_callback(editor): idx = next(i for i, x in enumerate(marker_edit_instances) if x is editor) del marker_edit_instances[idx] file_name_text = Div() add_marker_edit_button = Button(label="+", button_type="success", align=("start", "end"), width=50) add_marker_edit_button.on_click(add_marker_edit_callback) edit_selection_submit = Button(label="Submit change", button_type="primary", align=("start", "end")) download_button = Button(label="Download edited data", button_type="success", align=("start", "end")) download_button.js_on_click( CustomJS(args=dict(source=source), code=DOWNLOAD_JS)) edit_selecton_log = TextAreaInput(value="", disabled=True, css_classes=["edit_log"], cols=30, rows=10) upload_file_input = FileInput(accept="text/csv", align=("end", "end")) # Cell table ########################################################################### default_data_table_cols = [ TableColumn(field="marked", title="Seen", width=20) ] data_table = DataTable(source=source, columns=default_data_table_cols, width=800) # Callbacks for buttons and widgets ########################################################################### def cell_slider_change(attrname, old, new): cell_mapper.low = new[0] cell_mapper.high = new[1] def selection_change(attrname, old, new): selected = source.selected.indices data = source.data if not selected: return mean_image = CELL_IMAGE_METRICS[1][metric_select.active]( cell_stack[selected, int(cell_markers_select.value), :, :], axis=0) image_data = { "image": [mean_image], "dw": [cell_stack.shape[2]], "dh": [cell_stack.shape[3]], } for coord in ["contour_x", "contour_y"]: try: image_data[coord] = list(data[coord][selected]) except KeyError: pass image_source.data = image_data image_extr = round_signif(mean_image.min()), round_signif( mean_image.max()) cell_slider.start = image_extr[0] cell_slider.end = image_extr[1] cell_slider.step = round_signif((image_extr[1] - image_extr[0]) / 50) cell_slider.value = image_extr stats.text = "n cells: " + str(len(selected)) def autocomplete_cell_change(attrname, old, new): try: idx = image_markers(mapping=True)[new] except KeyError: try: idx = image_markers(lower=True, mapping=True)[new] except KeyError: return cell_markers_select.value = str(idx) cell_marker_input.value = None def data_change(attrname, old, new): new_keys = [n for n in new.keys() if n not in set(old.keys())] for n in new_keys: data_table.columns.append(TableColumn(field=n, title=n)) def edit_selection_submit_click(): for x in marker_edit_instances: x.edit_callback() def edit_selection_callback(): idx = source.selected.indices try: if len(idx) == 1 and all( source.data[x.widgets["input_col"].value][idx] != "NA" for x in marker_edit_instances): source.selected.indices = [idx[0] + 1] except KeyError: pass def upload_file_callback(attrname, old, new): try: data_text = b64decode(new) data = pd.read_csv(BytesIO(data_text)) except Exception: file_name_text.text = f"Error loading file {upload_file_input.filename}" return file_name_text.text = f"Editing file {upload_file_input.filename}" # Have to regenerate contours try: del data["contour_x"] del data["contour_y"] except KeyError: pass data_table.columns = default_data_table_cols prepare_data(data) add_outline() source.selected.on_change("indices", selection_change) source.on_change("data", data_change) cell_slider.on_change("value", cell_slider_change) metric_select.on_change("active", selection_change) cell_markers_select.on_change("value", selection_change) cell_marker_input.on_change("value", autocomplete_cell_change) edit_selection_submit.on_click(edit_selection_submit_click) upload_file_input.on_change("value", upload_file_callback) style_div = Div(text=CUSTOM_CSS) # set up layout layout = column( row( column(data_table), column( cell_markers_select, cell_marker_input, metric_select, row(cell_figure, cell_slider), stats, ), ), file_name_text, marker_edit_container, add_marker_edit_button, row(edit_selection_submit, download_button, upload_file_input), edit_selecton_log, style_div, ) doc.add_root(layout) doc.title = "Cell classifier"
# get all osm files select_file = Select(title="Select OSM File:", value='', options=osm_list) def on_file_change(obj, attr, old, new): print "OSM File:", new global osmfile, osm_list osmfile = new #osm_list.append(osmfile) select_file.on_change('value', on_file_change) ############## ############## # radio group gmap radio_group_gmap = RadioButtonGroup(labels=["GMap", "Blank"], #title='Background Map', active=0, name='Select Plot Options') def radio_group_handler_gmap(active): # need to update skipnodes too global gmap_background # detault to empty datasources if active == 0: gmap_background = True elif active == 1: gmap_background = False radio_group_gmap.on_click(radio_group_handler_gmap) ############## #############
def plot(location=None): ( source_df, labels, colors, location_labels, xs_df, ys_df, scales_dict ) = load_database(location=location) print(location_labels) if location is None: location = location_labels[0] print(location) source = ColumnDataSource(source_df) xs = ColumnDataSource(xs_df) ys = ColumnDataSource(ys_df) scales = ColumnDataSource(scales_dict) bfig = bokeh_plot(source) labels_group = RadioGroup( labels=labels, active=None) active = location_labels.index(location) locations_group = RadioButtonGroup( labels=location_labels, active=active, name='locations_group' ) x_scale, y_scale = scales_dict[location] x_slider = Slider( start=0.05, end=20, value=x_scale, step=0.05, title='x scale' ) y_slider = Slider( start=0.001, end=0.2, value=y_scale, step=0.001, title='y scale' ) with open('bokeh_js/bokeh_plot_onclick.js', 'r') as f: code = f.read() source.selected.js_on_change( 'indices', CustomJS( args=dict( s=source, ls=labels, r=labels_group, ), code=code ) ) with open('bokeh_js/bokeh_label_onchange.js', 'r') as f: code = f.read() labels_group.js_on_change( 'active', CustomJS( args=dict( s=source, r=labels_group, ls=labels, cs=colors), code=code ) ) with open('bokeh_js/bokeh_locations_onchange.js', 'r') as f: code = f.read() locations_group.js_on_change( 'active', CustomJS( args=dict( s=source, r=locations_group, location_labels=location_labels, xs=xs, ys=ys, scales=scales, x_slider=x_slider, y_slider=y_slider, ), code=code ) ) with open('bokeh_js/bokeh_x_slider_onchange.js', 'r') as f: code = f.read() x_slider.js_on_change( 'value', CustomJS( args=dict( s=source, r=locations_group, location_labels=location_labels, xs=xs, ys=ys, scales=scales, x_slider=x_slider, y_slider=y_slider, ), code=code ) ) with open('bokeh_js/bokeh_y_slider_onchange.js', 'r') as f: code = f.read() y_slider.js_on_change( 'value', CustomJS( args=dict( s=source, r=locations_group, location_labels=location_labels, xs=xs, ys=ys, scales=scales, x_slider=x_slider, y_slider=y_slider, ), code=code ) ) return components( column( row( locations_group, ), row( x_slider, y_slider, ), row( bfig, column( labels_group, ) ) ) )
# 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 initial_condition = TextInput(value=pde_settings.IC_init, title="initial condition") initial_condition.on_change('value', initial_condition_change) # 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",
class BokehGainMatching(Tool): name = "BokehGainMatching" description = "Interactively explore the steps in obtaining charge vs hv" input_path = Unicode('', help='Path to the numpy array containing the ' 'gain and hv').tag(config=True) aliases = Dict(dict(f='BokehGainMatching.input_path')) classes = List([]) def __init__(self, **kwargs): super().__init__(**kwargs) self._active_pixel = None self.dead = Dead() self.charge = None self.charge_error = None self.hv = None self.n_hv = None self.n_pixels = None self.n_tmpix = 64 self.modules = None self.tmpix = None self.n_tm = None self.m_pix = None self.c_pix = None self.m_tm = None self.c_tm = None self.m_tm2048 = None self.c_tm2048 = None self.p_camera_pix = None self.p_plotter_pix = None self.p_camera_tm = None self.p_plotter_tm = None self.w_view_radio = None self.layout = None def setup(self): self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]" kwargs = dict(config=self.config, tool=self) arrays = np.load(self.input_path) self.charge = self.dead.mask2d(arrays['charge']) self.charge = np.ma.masked_where(self.charge <= 0, self.charge) self.charge_error = np.ma.array(arrays['charge_error'], mask=self.charge.mask) self.hv = arrays['rundesc'] self.n_hv, self.n_pixels = self.charge.shape assert (self.n_hv == self.hv.size) geom = CameraGeometry.guess(*checm_pixel_pos * u.m, optical_foclen * u.m) self.modules = np.arange(self.n_pixels) // self.n_tmpix self.tmpix = np.arange(self.n_pixels) % self.n_tmpix self.n_tm = np.unique(self.modules).size # Init Plots self.p_camera_pix = Camera(self, "Gain Matching Pixels", geom) self.p_camera_tm = Camera(self, "Gain Matching TMs", geom) self.p_plotter_pix = Plotter(**kwargs) self.p_plotter_tm = Plotter(**kwargs) def start(self): # Overcomplicated method instead of just reshaping... # gain_modules = np.zeros((self.n_hv, self.n_tm, self.n_tmpix)) # hv_r = np.arange(self.n_hv, dtype=np.int)[:, None] # hv_z = np.zeros(self.n_hv, dtype=np.int)[:, None] # tm_r = np.arange(self.n_tm, dtype=np.int)[None, :] # tm_z = np.zeros(self.n_tm, dtype=np.int)[None, :] # tmpix_r = np.arange(self.n_tmpix, dtype=np.int)[None, :] # tmpix_z = np.zeros(self.n_tmpix, dtype=np.int)[None, :] # hv_i = (hv_r + tm_z)[..., None] + tmpix_z # tm_i = (hv_z + tm_r)[..., None] + tmpix_z # tmpix_i = (hv_z + tm_z)[..., None] + tmpix_r # gain_rs = np.reshape(self.charge, (self.n_hv, self.n_tm, self.n_tmpix)) # modules_rs = np.reshape(self.modules, (self.n_tm, self.n_tmpix)) # tmpix_rs = np.reshape(self.tmpix, (self.n_tm, self.n_tmpix)) # tm_j = hv_z[..., None] + modules_rs[None, ...] # tmpix_j = hv_z[..., None] + tmpix_rs[None, ...] # gain_modules[hv_i, tm_i, tmpix_i] = gain_rs[hv_i, tm_j, tmpix_j] # gain_modules_mean = np.mean(gain_modules, axis=2) shape = (self.n_hv, self.n_tm, self.n_tmpix) gain_tm = np.reshape(self.charge, shape) gain_error_tm = np.reshape(self.charge_error, shape) gain_tm_mean = np.mean(gain_tm, axis=2) gain_error_tm_mean = np.sqrt(np.sum(gain_error_tm**2, axis=2)) self.m_pix = np.ma.zeros(self.n_pixels, fill_value=0) self.c_pix = np.ma.zeros(self.n_pixels, fill_value=0) self.m_tm = np.ma.zeros(self.n_tm, fill_value=0) self.c_tm = np.ma.zeros(self.n_tm, fill_value=0) p0 = [0, 5] bounds = (-np.inf, np.inf) # ([-2000, -10], [2000, 10]) for pix in range(self.n_pixels): x = self.hv[~self.charge.mask[:, pix]] y = self.charge[:, pix][~self.charge.mask[:, pix]] if x.size == 0: continue try: coeff, _ = curve_fit( gain_func, x, y, p0=p0, bounds=bounds, # sigma=y_err[:, pix], # absolute_sigma=True ) self.c_pix[pix], self.m_pix[pix] = coeff except RuntimeError: self.log.warning("Unable to fit pixel: {}".format(pix)) for tm in range(self.n_tm): x = self.hv y = gain_tm_mean[:, tm] try: coeff, _ = curve_fit( gain_func, x, y, p0=p0, bounds=bounds, # sigma=y_err_tm[:, tm], # absolute_sigma=True ) self.c_tm[tm], self.m_tm[tm] = coeff except RuntimeError: self.log.warning("Unable to fit tm: {}".format(tm)) self.m_tm2048 = self.m_tm[:, None] * np.ones((self.n_tm, self.n_tmpix)) self.c_tm2048 = self.c_tm[:, None] * np.ones((self.n_tm, self.n_tmpix)) self.m_pix = self.dead.mask1d(self.m_pix) self.c_pix = self.dead.mask1d(self.c_pix) self.m_tm2048 = self.dead.mask1d(self.m_tm2048.ravel()) self.c_tm2048 = self.dead.mask1d(self.c_tm2048.ravel()) # Setup Plots self.p_camera_pix.enable_pixel_picker() self.p_camera_pix.add_colorbar() self.p_camera_tm.enable_pixel_picker() self.p_camera_tm.add_colorbar() self.p_plotter_pix.create(self.hv, self.charge, self.charge_error, self.m_pix, self.c_pix) self.p_plotter_tm.create(self.hv, gain_tm_mean, gain_error_tm_mean, self.m_tm, self.c_tm) # Setup widgets self.create_view_radio_widget() self.set_camera_image() self.active_pixel = 0 # Get bokeh layouts l_camera_pix = self.p_camera_pix.layout l_camera_tm = self.p_camera_tm.layout l_plotter_pix = self.p_plotter_pix.layout l_plotter_tm = self.p_plotter_tm.layout # Setup layout self.layout = layout([[self.w_view_radio], [l_camera_pix, l_plotter_pix], [l_camera_tm, l_plotter_tm]]) def finish(self): curdoc().add_root(self.layout) curdoc().title = "Charge Vs HV" output_dir = dirname(self.input_path) output_path = join(output_dir, 'gain_matching_coeff.npz') np.savez(output_path, alpha_pix=np.ma.filled(self.m_pix), C_pix=np.ma.filled(self.c_pix), alpha_tm=np.ma.filled(self.m_tm), C_tm=np.ma.filled(self.c_tm)) self.log.info("Numpy array saved to: {}".format(output_path)) @property def active_pixel(self): return self._active_pixel @active_pixel.setter def active_pixel(self, val): if not self._active_pixel == val: self._active_pixel = val self.p_camera_pix.active_pixel = val self.p_camera_tm.active_pixel = val self.p_plotter_pix.active_pixel = val self.p_plotter_pix.fig.title.text = 'Pixel {}'.format(val) module = self.modules[val] self.p_plotter_tm.active_pixel = module self.p_plotter_tm.fig.title.text = 'TM {}'.format(module) def set_camera_image(self): if self.w_view_radio.active == 0: self.p_camera_pix.image = self.m_pix self.p_camera_tm.image = self.m_tm2048 self.p_camera_pix.fig.title.text = 'Gain Matching Pixels (gradient)' self.p_camera_tm.fig.title.text = 'Gain Matching TMs (gradient)' elif self.w_view_radio.active == 1: self.p_camera_pix.image = self.c_pix self.p_camera_tm.image = self.c_tm2048 self.p_camera_pix.fig.title.text = 'Gain Matching Pixels (intercept)' self.p_camera_tm.fig.title.text = 'Gain Matching TMs (intercept)' def create_view_radio_widget(self): self.w_view_radio = RadioButtonGroup(labels=["gradient", "intercept"], active=0) self.w_view_radio.on_click(self.on_view_radio_widget_click) def on_view_radio_widget_click(self, active): self.set_camera_image()
def create_view_radio_widget(self): self.w_view_radio = RadioButtonGroup(labels=["gradient", "intercept"], active=0) self.w_view_radio.on_click(self.on_view_radio_widget_click)
source=sources['static'], angle=pi/2, width=5, height=1, color=DARK_GRAY) # create components -------------- title_div = Div(text='Revenue Impact of a 4% Surtax on Taxpayers with Adjusted Gross Income over $5 Million', height=30) radio_group_text = Div(text="Include Additional Capital Gains Behavior.") radio_group = RadioGroup(labels=["Without", "With"], active=0) sources['radio_group'] = radio_group elasticity_text = Div(text="Elasticity of Taxable Income") elasticity_option = RadioButtonGroup(labels=sources['capital_gains_no'].data['labels'], active=0) sources['elasticity_option'] = elasticity_option # create callbacks --------------- radio_group.callback = CustomJS(args=sources, code=""" var capitalGainsType = radio_group.active === 0 ? capital_gains_no : capital_gains_yes; elasticity_option.set('labels', capitalGainsType.data.labels); while (elasticity_option.active > capitalGainsType.data.source_ids.length - 1) { elasticity_option.active = elasticity_option.active - 1; } ref.data = eval(capitalGainsType.data.source_ids[elasticity_option.active]).data; ref.trigger('change'); """)