def _create_fill_map( source: ColumnDataSource, source_column: str = None ) -> Tuple[Union[factor_cmap, linear_cmap], Optional[ColorBar]]: """Create factor map or linear map based on `source_column`.""" fill_map = "navy" color_bar = None if source_column is None or source_column not in source.data: return fill_map, color_bar col_kind = source.data[source_column].dtype.kind if col_kind in ["b", "O"]: s_values = set(source.data[source_column]) if np.nan in s_values: s_values.remove(np.nan) values = list(s_values) fill_map = factor_cmap(source_column, palette=viridis(max(3, len(values))), factors=values) elif col_kind in ["i", "u", "f", "M"]: values = [ val for val in source.data[source_column] if not np.isnan(val) ] fill_map = linear_cmap( field_name=source_column, palette=viridis(256), low=np.min(values), high=np.max(values), ) color_bar = ColorBar( color_mapper=fill_map["transform"], width=8, location=(0, 0) # type: ignore ) return fill_map, color_bar
def plot_output(out,attribute,attribute_label,labels,lines,**kwargs): condensibles = out[0]['condensibles'] kwargs['plot_height'] = kwargs.get('plot_height',300) kwargs['plot_width'] = kwargs.get('plot_width',600) kwargs['x_axis_label'] = kwargs.get('x_axis_label',attribute_label) kwargs['y_axis_label'] = kwargs.get('y_axis_label','Pressure (bars)') kwargs['x_axis_type'] = kwargs.get('x_axis_type','log') kwargs['y_axis_type'] = kwargs.get('y_axis_type','log') cols = viridis(len(out)) pressure = out[0]['pressure'] kwargs['y_range'] = kwargs.get('y_range',[np.max(pressure), np.min(pressure)]) fig = figure(**kwargs) for i in range(len(out)): x = out[i][attribute][:,0] if attribute is "column_density": x = out[i][attribute][:,0]/out[i]["layer_thickness"] pressure = out[i]['pressure'] fig.line(x, pressure, legend_label=labels[i], color=cols[i],line_width=5, line_dash=lines[i]) fig.legend.location = "bottom_left" plot_format(fig) return fig
def plot_true_graph(sample_data, num_tracks=100): p = figure(title='Truth graph', x_axis_label='x', y_axis_label='y', height=800, width=800) true_edges = sample_data.signal_true_edges true_unique, true_lengths = sample_data.pid[true_edges[0]].unique( return_counts=True) pid = sample_data.pid r, phi, z = sample_data.cpu().x.T x, y = r * np.cos(phi * np.pi), r * np.sin(phi * np.pi) cmap = viridis(num_tracks) source = ColumnDataSource(dict(x=x.numpy(), y=y.numpy())) p.circle(x='x', y='y', source=source, color=cmap[0], size=1, alpha=0.1) for i, track in enumerate(true_unique[true_lengths >= 5][:num_tracks]): # Get true track plot track_true_edges = true_edges[:, pid[true_edges[0]] == track] X_edges, Y_edges = x[track_true_edges].numpy( ), y[track_true_edges].numpy() X = np.concatenate(X_edges) Y = np.concatenate(Y_edges) p.circle(X, Y, color=cmap[i], size=5) p.multi_line(X_edges.T.tolist(), Y_edges.T.tolist(), color=cmap[i]) show(p)
def pieChart(df): bokeh.io.output_file('static/graphics/pie.html') labels = list(df['source'].unique()) cant = list(df['source'].value_counts()) x = {labels[i]: cant[i] for i in range(len(labels))} data = pd.Series(x).reset_index(name='value').rename( columns={'index': 'country'}) data['angle'] = data['value'] / data['value'].sum() * 2 * pi data['color'] = viridis(len(x)) p = figure(plot_height=350, title="Pie Chart", toolbar_location=None, tools="hover", tooltips="@country: @value", x_range=(-0.5, 1.0)) p.wedge(x=0, y=1, radius=0.4, start_angle=cumsum('angle', include_zero=True), end_angle=cumsum('angle'), line_color="white", fill_color='color', legend_field='country', source=data) p.axis.axis_label = None p.axis.visible = False p.grid.grid_line_color = None # output_file('static/graphics/pie.html') return p
def prep_palette(self, pname, binverse=False): """ Prepares a palette based on a name :param pname: :return: """ res = palettes.grey(256) if pname == 'Greys256': res = palettes.grey(256) elif pname == 'Inferno256': res = palettes.inferno(256) elif pname == 'Magma256': res = palettes.magma(256) elif pname == 'Plasma256': res = palettes.plasma(256) elif pname == 'Viridis256': res = palettes.viridis(256) elif pname == 'Cividis256': res = palettes.cividis(256) elif pname == 'Turbo256': res = palettes.turbo(256) elif pname == 'Bokeh8': res = palettes.small_palettes['Bokeh'][8] elif pname == 'Spectral11': res = palettes.small_palettes['Spectral'][11] elif pname == 'RdGy11': res = palettes.small_palettes['RdGy'][11] elif pname == 'PiYG11': res = palettes.small_palettes['PiYG'][11] if binverse: res = res[::-1] return res
def plot(self): figure = Figure(**self._plot_args) palette = viridis(len(self.model.data.columns)) color_index = { c: palette[i] for i, c in enumerate(self.model.data.columns) } # instantiating view on render view = self.bokeh_view(ignore_filters=True) # by default : lines for c in self.model.data.columns: # CAREFUL : CDSView used by Glyph renderer must have a source that matches the Glyph renderer's data source figure.line( source=view.source, view=view, x="index", y=c, color=color_index[c], legend_label=c, ) return figure
def houseStockPlot(): df = pd.read_csv('BokehApp/Data/houseStock1.csv') df = df[['Year', 'Dublin_Vacant', 'Irl_Vacant', 'Dublin_Total','Irl_Total']] df.columns = ['Year', 'Dublin vacant', 'Ireland vacant', 'Dublin', 'Ireland'] ll = list(df.columns[1:]) source = ColumnDataSource(data=dict(x=df.Year.values,y=df['Ireland'], y1=df['Dublin'], y2=df['Ireland vacant'], y3=df['Dublin vacant'])) a2 = figure(plot_width=550, plot_height=350, title='Irish House Stock', tools = 'pan, wheel_zoom, box_zoom, reset') #, tooltips=ToolTips) hover = HoverTool() hover.tooltips=[('Ireland', '@y'), ('Dublin','@y1'), ('Ireland vancant', '@y2'), ('Dublin vacant','@y3')] a2.add_tools(hover) colors = viridis(4) a2.varea_stack(['y3','y2','y1','y'], x='x', source=source, color=colors[::-1], legend=ll, muted_alpha=0.2) a2.legend.location='top_left' a2.legend.click_policy="mute" a2.yaxis[0].formatter = NumeralTickFormatter(format="0 M") tick_labels = {'500000':'0.5M','1000000':'1M','1500000':'1,5M','2000000':'2M','2500000':'2,5M'} a2.yaxis.major_label_overrides = tick_labels a2.xaxis.ticker = df.Year.values a2.title.text_font_size = '15px' a2.legend.background_fill_alpha=None a2.legend.border_line_alpha=0 a2.legend.label_text_font_size = "11px" a2.xaxis.major_label_text_font_style = 'bold' a2.grid.grid_line_color=None a2.toolbar.autohide = True a2.outline_line_color=None return a2
def __init__( self, fig: Figure, x_bounds: tuple, y_bounds: tuple, grid_size: float, legend_label: str, ): """ Creates a HeatmapPlotter for the given figure, with the given x-axis and y-axis bounds and grid cell size. This will show up in the Bokeh figure legend as legend_label. :param fig: a Bokeh figure :param x_bounds: the x-axis bounds of the heatmap :param y_bounds: the y-axis bounds of the heatmap :param grid_size: the size of a grid cell on the heatmap :param legend_label: the legend label of the heatmap """ self.image_data_source = ColumnDataSource(dict(image=[])) self.x_bounds = x_bounds self.y_bounds = y_bounds self.grid_size = grid_size fig.image( source=self.image_data_source, image="image", x=min(x_bounds), y=min(y_bounds), dh=max(y_bounds) - min(y_bounds), dw=max(x_bounds) - min(x_bounds), palette=palettes.viridis(100), level="image", legend_label=legend_label, )
def piechart(src, heads, val, acci, title=''): title = title + accisev[acci] + " casualties, " + val + " by " + heads src.columns = src.columns.get_level_values(0) src['angle'] = src[val] / src[val].sum() * 2 * pi src['percent'] = src[val] / src[val].sum() * 100.00 src['color'] = viridis(len(src.index)) p = figure(plot_height=350, title=title, toolbar_location=None, tools="hover", tooltips="@" + heads + ": @" + val + ", @percent", x_range=(-0.5, 1.0)) p.wedge(x=0, y=1, radius=0.4, start_angle=cumsum('angle', include_zero=True), end_angle=cumsum('angle'), line_color="white", fill_color='color', legend=heads, source=src) p.axis.axis_label = None p.axis.visible = False p.grid.grid_line_color = None show(p)
def plotDateGrid(date): # Assert given date is available. assert date in authorKey(df, 'Capella', 'date'), 'No entries for this date.' # Create list of fitting dataframes tempList = [ biblioList[s] for s in range(len(biblioList)) if biblioList[s]['date'][0] in [date] ] # sort by occuring diagrams dfDATE = sorted(tempList, key=lambda tempList: tempList['Count'].sum(), reverse=True) plotListDATE = [] for x in range(len(dfDATE)): titleS = dfDATE[x]['biblio'][0] + '; ' + str( dfDATE[x]['date'][0]) + ' CE' b0 = Bar(dfDATE[x], title=titleS, label='biblio', values='Count', group='diaTyp', bar_width=1, ylabel='Diagrams', palette=viridis(14), width=250, height=250, legend=False) b0.xaxis.major_label_orientation = "horizontal" b0.xaxis.axis_label = '' plotListDATE.append(b0) plotGrid = gridplot(plotListDATE, ncols=3) show(plotGrid)
def ticker1_change(attrname, old, new): """ Loads WT-MT data again and starts ... """ print(old, new) tsneResDF2, data4umap2 = load_data() # randomely select 3 sites uniqLabels0 = tsneResDF2['Label'].unique().tolist() randIntArr = np.random.randint(1, len(uniqLabels0), size=3) randSites = [uniqLabels0[i] for i in randIntArr] tsneResDF2m = tsneResDF2[tsneResDF2['Label'].isin(randSites)].reset_index( drop=True) source2.data = ColumnDataSource(data4umap2).data #### update source2 # print('shapeHere',tsneResDF2.shape,data4umap2.shape) d2 = gen_data_forHover(tsneResDF2m) uniqLabels = tsneResDF2m['Label'].unique().tolist() # palette1 = inferno(len(uniqLabels)) # colors = [palette1[int(uniqLabels.index(x))] for x in tsneResDF2m['Label']] palette1 = all_palettes['Colorblind'][len(uniqLabels)] colors = [palette1[int(uniqLabels.index(x))] for x in tsneResDF2m['Label']] # colors = [colormap[x] for x in tsneResDF2['Label']] d2["color"] = colors source.data = d2 #### update source dCls2 = gen_data_forHover(tsneResDF2) palette2 = viridis(len(tsneResDF2['clsLabel'].unique())) colors2 = [palette2[int(x)] for x in tsneResDF2['clsLabel']] dCls2['color'] = colors2 source3.data = dCls2 #### update source3 mem_stream.send(tsneResDF2) #### update boxplot series.children = [ticker1] + [row(p, p2, column(stats2, p1))] + []
def plot_per(fold_list): df = pd.read_csv('/home/dhrumil/Desktop/Lab/RNAWebsite_v1/GeneratePlot/data/foldability_prediction.csv', header=0) f_list = df[df['foldability'] > 0]['foldability'].tolist() print(len(f_list)) plot = figure(title="Foldability", tools="box_zoom, pan, save,hover,reset,tap,wheel_zoom" , plot_height = 400 , plot_width = 400) hist, edges = np.histogram(f_list, density=False, normed = True, bins=20) hist = hist/len(f_list) cdf=np.cumsum(hist) plot.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:] , legend = "pdf") colors = viridis(len(fold_list)) plot.line(edges[1:], cdf , line_color= "black", line_width= 3 , legend = 'cdf') #plot.line(edges_pdf[1:], hist_pdf_norm, line_color="red", line_width=3) vline_list = list() for i , j in zip(fold_list,colors): vline = Span(location = i, dimension='height', line_color=j, line_width=3) vline_list.append(vline) plot.legend.location = "top_left" plot.renderers.extend(vline_list) script, div = components(plot) #show(plot) return script, div
def get_question_pie(hotel_id, question): """ this function gets hotel_id and question as input and returns pie chart for that questions answers for that hotel """ x = dict(pd.DataFrame({'col1': get_question_answers(hotel_id,question)}).col1.value_counts()) # print(x) data = pd.Series(x).reset_index(name='value').rename(columns={'index':'answer'}) data['angle'] = data['value']/data['value'].sum() * 2*pi data['color'] = viridis(len(x)) p = figure(plot_height=250, plot_width = 375, title= question, toolbar_location=None, tools="hover", tooltips="@answer: @value", x_range=(-0.5, 1.0)) p.wedge(x=0, y=1,radius=0.4, start_angle=cumsum('angle', include_zero=True), end_angle=cumsum('angle'), line_color="black", fill_color='color', legend='answer', source=data) p.axis.axis_label=None p.axis.visible=False p.grid.grid_line_color = None script,div = components(p) return [script,div]
def printer_double(attrname, old, new): mesice={'LEDEN':1,'ÚNOR':2,'BŘEZEN':3,'DUBEN':4} print(mesice_widget.value) print(region_widget.value) if (mesice_widget.value==u"VŠE"): if (region_widget.value!=u"VŠE"): corr_zc_tymy_filtr=corr_zc_tymy[corr_zc_tymy.Region==region_widget.value].copy() if (mesice_widget.value!=u"VŠE"): if (region_widget.value!=u"VŠE"): corr_zc_tymy_filtr=corr_zc_tymy[corr_zc_tymy.Region==region_widget.value].loc[(slice(None),[mesice[mesice_widget.value]]), :].copy() if (mesice_widget.value!=u"VŠE"): if (region_widget.value==u"VŠE"): corr_zc_tymy_filtr=corr_zc_tymy.loc[(slice(None),[mesice[mesice_widget.value]]), :].copy() if (mesice_widget.value==u"VŠE"): if (region_widget.value==u"VŠE"): corr_zc_tymy_filtr=corr_zc_tymy.copy() data_zc=corr_zc_tymy_filtr["ZC"].tolist() print(data_zc) call_colors = viridis(len(remove_dupl(data_zc))) color_key_value_pairs = list(zip(remove_dupl(data_zc), call_colors)) color_dict = dict(color_key_value_pairs) colors = [color_dict[x] for x in corr_zc_tymy_filtr['ZC']] corr_zc_tymy_filtr["color"]=colors if x_widget.value=='MOJE DATA - SMLOUVY': osa_x="PARTNER" if x_widget.value=='PLNĚNÍ EE (%)': osa_x="Plnění EE" if x_widget.value=='PLNĚNÍ EE (ABS)': osa_x="Plnění EE_abs" if x_widget.value=='SCORE_MEAN': osa_x="score_mean" if x_widget.value=='SCORE_MIN': osa_x="score_min" if y_widget.value=='MOJE DATA - SMLOUVY': osa_y="PARTNER" if y_widget.value=='PLNĚNÍ EE (%)': osa_y="Plnění EE" if y_widget.value=='PLNĚNÍ EE (ABS)': osa_y="Plnění EE_abs" if y_widget.value=='SCORE_MEAN': osa_y="score_mean" if y_widget.value=='SCORE_MIN': osa_y="score_min" scatter_cds.data = dict(x=corr_zc_tymy_filtr[osa_x],y=corr_zc_tymy_filtr[osa_y],color=corr_zc_tymy_filtr["color"],ZC=corr_zc_tymy_filtr["ZC"],Agent=corr_zc_tymy_filtr["ID agenta/cesty"])
def __init__(self, df=None, title=None, x_title=None, y_title=None, x_major_name=None, x_minor_name=None, column_display_names=[]): """Constructor Arguments df: A DataFrame containing the data to be displayed. It is assumed to have the following columns : Group, Range, Feature, Count, Total Words, per1000 title: A string for the title for the plot x_title: A string for the X-axis title y_title: A string for the Y-axis title x_major_name: A string with the name of the major X axis x_minor_name: A name for subordinate data series for the X axis if required column_display_names: The names to be used in the data table display and chart, replacing the column names in df. Must be ordered in the same order as the columns in df. """ self._df = df self._title = title self._x_title = x_title self._y_title = y_title self._x_major_name = x_major_name self._x_minor_name = x_minor_name self._column_display_names = column_display_names self._colors = viridis(len(self._df[self._x_minor_name].unique())) self.sort()
def add_columns_for_pie_chart(df, column_name, colors=None, reverse_color=False, random_color_order=False): r = 0.7 df = df.copy() column_sum = df[column_name].sum() df['percentage'] = (df[column_name] / column_sum) percentages = [0] + df['percentage'].cumsum().tolist() df['starts'] = [p * 2 * pi for p in percentages[:-1]] df['ends'] = [p * 2 * pi for p in percentages[1:]] df['middle'] = (df['starts'] + df['ends']) / 2 df['text_x'] = df['middle'].apply(cos) * r df['text_y'] = df['middle'].apply(sin) * r df['text_angle'] = 0.0 if colors: df['colors'] = colors else: if 'colors' not in df: reverse_color = -1 if reverse_color else 1 colors = palettes.viridis(len(df))[::reverse_color] if random_color_order: shuffle(colors) df['colors'] = colors return df
def plot_counts_by_type(df): df = df.dropna() group = df.groupby('PropertyStyle').count().sort_values(by='_Sold', ascending=False) curve = hv.Curve(spike_train, 'milliseconds', 'Hertz', group='Firing Rate') cities = list(group.reset_index().PropertyStyle) solds = list(group.reset_index()._Sold) source = ColumnDataSource( data=dict(cities=cities, solds=solds, color=viridis(len(cities)))) p = figure(x_range=cities, title="Solds by Styles", toolbar_location=None, tools="", sizing_mode='stretch_both') p.vbar(x='cities', top='solds', width=0.9, color='color', legend=None, source=source) p.xgrid.grid_line_color = None p.y_range.start = 0 p.xgrid.grid_line_color = None p.xaxis.major_label_orientation = 1.2 p.outline_line_color = None show(p)
def plot_pt(out, labels, lines, **kwargs): kwargs['plot_height'] = kwargs.get('plot_height',300) kwargs['plot_width'] = kwargs.get('plot_width',600) kwargs['x_axis_label'] = kwargs.get('x_axis_label','Temperature (K)') kwargs['y_axis_label'] = kwargs.get('y_axis_label','Pressure (bars)') kwargs['x_axis_type'] = kwargs.get('x_axis_type','log') kwargs['y_axis_type'] = kwargs.get('y_axis_type','log') cols = viridis(len(out)) ngas = len(out[0]['condensibles']) mh, mmw = out[0]['scalar_inputs']['mh'], out[0]['scalar_inputs']['mmw'] condensibles = out[0]['condensibles'] pressure = out[0]['pressure'] kwargs['y_range'] = kwargs.get('y_range',[np.max(pressure), np.min(pressure)]) fig = figure(**kwargs) for i in range(len(out)): temperature = out[i]['temperature'] pressure = out[i]['pressure'] fig.line(temperature, pressure, legend_label=labels[i], color=cols[i],line_width=5, line_dash=lines[i]) plot_format(fig) return fig
def test_cmap_generator_function(): assert pal.viridis(256) == pal.Viridis256 assert pal.magma(256) == pal.Magma256 assert pal.plasma(256) == pal.Plasma256 assert pal.inferno(256) == pal.Inferno256 assert pal.gray(256) == pal.Greys256 assert pal.grey(256) == pal.Greys256
def tweet_process(tweet_list): features = [] for tweet in tweet_list: features.extend(extract_feature(tweet)) tweet_feature = pandas.DataFrame(features, columns=feature_cols) topic_vectors = vectorizer.fit_transform(tweet_feature['text']) similarity = topic_vectors.dot(topic_vectors.transpose()) nonz = similarity.nonzero() edges = zip(nonz[0], nonz[1], similarity[nonz].flat) edges_upper = (item for item in edges if item[0] > item[1]) tweet_g = networkx.Graph() tweet_g.add_weighted_edges_from(edges_upper) spring_xy = networkx.spring_layout(tweet_g, iterations=50) tweet_feature['x'] = [0] * len(tweet_feature) tweet_feature['y'] = [0] * len(tweet_feature) for node, xy in spring_xy.items(): tweet_feature.loc[node, 'x'] = xy[0] tweet_feature.loc[node, 'y'] = xy[1] tweet_feature['color'] = [0] * len(tweet_feature) maxpop = log(max(tweet_feature['popularity']) + 1, 2) for i in range(len(tweet_feature)): tweet_feature.loc[i, 'color'] = viridis(256)[int( log(tweet_feature.loc[i, 'popularity'] + 1, 2) * 255 / maxpop)] return tweet_feature
def get_colormapper_add_colorbar(plot, high): from bokeh.models import ( FixedTicker, ColorBar, NumeralTickFormatter, LinearColorMapper, ) from bokeh.palettes import viridis PALETTE_N = 10 palette = viridis(PALETTE_N) palette.reverse() color_mapper = LinearColorMapper(palette=palette, low=0, high=high) ticker = FixedTicker(ticks=[0, high]) formatter = NumeralTickFormatter(format='0 a') color_bar = ColorBar( color_mapper=color_mapper, ticker=ticker, formatter=formatter, location=(0, 0), label_standoff=2, height=PALETTE_N * 5, width=10, major_tick_line_color=None, major_label_text_align='left', major_label_text_font=FONT, ) plot.add_layout(color_bar, 'right') return color_mapper
def t_merg(self,df,fMT,metal): #(dataframe,fMT,metal) fig = plt.figure(figsize=(30,30)) ax = [fig.add_subplot(3,3,s) for s in range(1,len(fMT)+1)] #nrows,ncols,index fig.suptitle('Plots of distribution of time tmerg',fontsize=30) col = sns.color_palette(palette.viridis(len(metal))) for i in range(0,len(fMT)): for j in range(0,len(metal)): edge = 50*np.logspace(np.log10(df[i][j]['tmerg[11]'].min()), np.log10(df[i][j]['tmerg[11]'].max()), 30) sns.distplot(df[i][j]['tmerg[11]'],bins=edge,kde=False,norm_hist=True,label=metal[j], hist_kws={"histtype": "step","lw": 2},ax=ax[i],color=col[j]) ax[i].set_title('Distribution of time tmerg for fMT={}'.format(fMT[i]),fontsize=18) ax[i].set_xlabel('tmerg [Myr]',fontsize=18) ax[i].set_ylabel('Density',fontsize=18) ax[i].legend(title='Metallicity',fontsize=14,title_fontsize=16) ax[i].tick_params(axis="x", labelsize=16) ax[i].tick_params(axis="y", labelsize=16) ax[i].set_xscale('log') ax[i].set_yscale('log') ax[i].grid(True, which="both", ls="-",color='0.93') ax[i].set_axisbelow(True) if not os.path.isdir('./hist_fMT'): os.mkdir('./hist_fMT') plt.savefig('hist_fMT/hist_time_tmerg.pdf', format='pdf') plt.close()
def mass_chirp(self,df,fMT,metal): #(dataframe,fMT,metal) fig = plt.figure(figsize=(30,30)) ax = [fig.add_subplot(3,3,s) for s in range(1,len(fMT)+1)] #nrows,ncols,index fig.suptitle('Plots of distribution of mass mchirp',fontsize=30) col = sns.color_palette(palette.viridis(len(metal))) for i in range(0,len(fMT)): for j in range(0,len(metal)): # Compute m_chirp mchirp = np.power( df[i][j]['m1form[8]']*df[i][j]['m2form[10]'], 3/5)/np.power( df[i][j]['m1form[8]']*df[i][j]['m2form[10]'], 1/5) edge = np.logspace(np.log10(mchirp.min()), np.log10(mchirp.max()), 30) sns.distplot(mchirp,bins=edge,kde=False,norm_hist=True,label=metal[j], hist_kws={"histtype": "step","lw": 2},ax=ax[i],color=col[j]) ax[i].set_title('Distribution of mass mchirp for fMT={}'.format(fMT[i]),fontsize=18) ax[i].set_xlabel('mchirp $[M_\odot]$',fontsize=18) ax[i].set_ylabel('Density',fontsize=18) ax[i].legend(title='Metallicity',fontsize=14,title_fontsize=16) ax[i].tick_params(axis="x", labelsize=16) ax[i].tick_params(axis="y", labelsize=16) ax[i].set_xscale('log') ax[i].grid(True, which="both", ls="-",color='0.93') ax[i].set_axisbelow(True) if not os.path.isdir('./hist_fMT'): os.mkdir('./hist_fMT') plt.savefig('hist_fMT/hist_mass_chirp.pdf', format='pdf') plt.close()
def assignColors(arr, maxval, minval, bins=10): """ Assign colors with a logarithmic increment using Bokeh's virids palette colors lower than bins are grey and above are max. input: arr: list of values maxval: Maximum value for color assignment minval: Minimum value for color assignment bins: Number of increments output: arr_colors: Color assigned for each color """ # Create a list of colors for increments colors = viridis(bins) # Create the increments between max and min on a log10 scale bin_ranges = np.logspace(minval, maxval, bins) arr_colors = [] for val in arr: if val == 0: arr_colors.append('grey') elif val > bin_ranges[-1]: arr_colors.append(colors[-1]) else: for i in range(len(bin_ranges)): if val < bin_ranges[i]: arr_colors.append(colors[i]) break return arr_colors
def q(self,df,fMT,metal): #(dataframe,fMT,metal) fig = plt.figure(figsize=(30,30)) ax = [fig.add_subplot(3,3,s) for s in range(1,len(fMT)+1)] #nrows,ncols,index fig.suptitle('Plots of distribution of q',fontsize=30) col = sns.color_palette(palette.viridis(len(metal))) for i in range(0,len(fMT)): for j in range(0,len(metal)): # Compute q q = df[i][j]['m2form[10]']/df[i][j]['m1form[8]'] sns.distplot(q,kde=False,norm_hist=True,label=metal[j], hist_kws={"histtype": "step","lw": 2},ax=ax[i],color=col[j]) ax[i].set_title('Distribution of q for fMT={}'.format(fMT[i]),fontsize=18) ax[i].set_xlabel('q',fontsize=18) ax[i].set_ylabel('Density',fontsize=18) ax[i].legend(title='Metallicity',fontsize=14,title_fontsize=16,loc='upper left') ax[i].tick_params(axis="x", labelsize=16) ax[i].tick_params(axis="y", labelsize=16) ax[i].grid(True, which="both", ls="-",color='0.93') ax[i].set_axisbelow(True) if not os.path.isdir('./hist_fMT'): os.mkdir('./hist_fMT') plt.savefig('hist_fMT/hist_q.pdf', format='pdf') plt.close()
def get_layout(json_data, filters): sql_data = json_to_sql(json_data, filters) data = get_dataframe(sql_data) labels = get_plot_labels(json_data) columns = data.columns.tolist() columns.remove('x') x_axis_data = [(x, z) for x in data['x'] for z in columns] to_zip = [data[c].tolist() for c in columns] y_axis_data = sum(zip(*to_zip), ()) source = ColumnDataSource( data=dict(x_axis_data=x_axis_data, y_axis_data=y_axis_data)) hover = HoverTool(tooltips=[ (','.join(labels.x_label.rsplit('-', 1)[::-1]), "@x_axis_data"), (labels.y_label, "@y_axis_data"), ]) p = figure(x_range=FactorRange(*x_axis_data), plot_width=1200, plot_height=600, title=labels.title, tools=[hover, 'pan', 'box_zoom', 'wheel_zoom', 'save', 'reset']) p.vbar(x='x_axis_data', top='y_axis_data', width=1, source=source, line_color="white", fill_color=factor_cmap('x_axis_data', palette=viridis(len(columns)), factors=columns, start=1, end=len(columns))) p.y_range.start = 0 p.x_range.range_padding = 0.1 p.xaxis.major_label_orientation = 1 p.xgrid.grid_line_color = None p.xaxis.axis_label = labels.x_label p.yaxis.axis_label = labels.y_label p.title.align = 'center' # eng = TextInput(title="ENG") # tran = TextInput(title="TRAN") # miles = TextInput(title="MILES") # # controls = [eng, tran, miles] # # sizing_mode = 'fixed' # # ly = layout([controls, [p]], sizing_mode=sizing_mode) # return ly return p
def plottrends(): x = range(pf.MonthsImported) yforplot = port.marketdatas[0].pricehistory #img = imread('worldmap-background-design_1127-2318.jpg') # create a new plot with a title and axis labels p = figure(title='Assets time series data. Source: Quandl.com', \ x_axis_label='x', y_axis_label='y') # add a line renderer with legend and line thickness mypalette = viridis(port.nrassets) #print(len(mypalette)) for i in range(port.nrassets): #print(i) p.line(range(-port.marketdatas[i].lenpricehistory + 1,1), port.marketdatas[i].pricehistory*100.0, \ legend=port.marketdatas[i].name, line_color = mypalette[i], \ line_width=2) p.legend.location = "top_left" #p.height = 100 #p.width = 100 p.xaxis.axis_label = 'Time (months before T0)' p.yaxis.axis_label = 'Return (USD when each market index starts at USD 100)' plot = p script, div = components(plot) return render_template('plottrends.html', script = script, div = div, \ inittext='')
def percentage_error_plot(y_true, y_pred, y_bench): """ Given the true value and the predicted value, it computes the """ TOOLS = 'pan,wheel_zoom,box_zoom,reset,save,box_select,crosshair' hover = HoverTool(tooltips=[ ("Error pct", '$y'), ]) list_symbols = list(y_true.columns) p = figure(width=900, height=500, x_axis_type="datetime", tools=[TOOLS, hover]) p.legend.location = "top_left" p.xaxis.axis_label = 'Date' p.yaxis.axis_label = 'Error percentage' p.title.text = "Error percentage for %s ticker symbols" % ( ", ".join(list_symbols)) colors = viridis(len(list_symbols)) for (i, sym) in enumerate(list_symbols): p.line(y_true.index, (y_true[sym] - y_pred[sym]) / y_true[sym] * 100, legend=sym, line_width=2, color=colors[i]) #p.line(y_true.index,(y_true[sym]-y_bench[sym])/y_true[sym]*100,line_width=2,legend='Bench_'+sym,color=colors[i],line_dash='dashed') tab = Panel(child=p, title='Error percentage') return tab
def update_graph(jobs_db, graph_path): rows = [] for job in jobs_db.all(): rows.append([ job.get("<project_code>"), job.get("<command>"), job.get(">start_time"), job.get("timeout") ]) df = pd.DataFrame(rows, columns=["project", "command", "start", "timeout"]) df = df.sort_values(by="project", ascending=False) df["start"] = pd.to_datetime(df["start"], format="%H:%M:%S") df["start_txt"] = df.start.astype("str").str.extract(r"(\d+:\d+)", expand=True) + " h" df["timeout_txt"] = df['timeout'].copy().astype('str') + " seconds" df["timeout"] = df['timeout'].astype('timedelta64[s]') df["end"] = pd.to_datetime(df["start"], format="%H:%M:%S") + df["timeout"] colors = viridis(len(df["project"])) output_file(graph_path, title="rvt_model_services_jobs", mode="inline") cds = ColumnDataSource(data=dict( start=df["start"].values, end=df["end"].values, name=df["project"], timeout=df["timeout_txt"], start_txt=df["start_txt"], command=df["command"], color=colors, )) hover = HoverTool(tooltips=[ ("project", "@name"), ("command", "@command"), ("start time:", "@start_txt"), ("timeout:", "@timeout"), ]) tools_opt = [hover, "save", "pan", "wheel_zoom", "box_zoom", "reset"] graph_opt = dict(width=900, x_axis_type="datetime", tools=tools_opt, toolbar_location="right", background_fill_alpha=0, border_fill_alpha=0) jobs_viz = figure(title="rvt_model_service_jobs", y_range=list(df["project"].unique()), **graph_opt) jobs_viz.hbar( source=cds, y="name", left="start", right="end", height=1, color="color", ) style_plot(jobs_viz) save(jobs_viz)
def get_multi_line_plot(self, df: pd.DataFrame, width, height, title): """ This function design a plot with the structure of Parallel Coordinates graph. For that, it uses the function multi_line from bokeh module. And then, it calls the function add_annotation_for_categorical_data in order to add a label where there are the code-category from the categorical data :param df: Data frame which we want to plot :param width: The width measure for the figure :param height: The height measure for the figure :param title: The tittle for the figure :return: The corresponding plot completed """ plot = bk.figure(plot_width=width, plot_height=height, title=title, x_range=list(self.my_df)) ys_list = list() xs_list = list() for i in range(0, len(df)): aux_ys_list = df.iloc[i].tolist() ys_list.append(aux_ys_list.copy()) xs_list.append(list(range(0, len(df.columns)))) try: my_palette = viridis(len(df.index)) plot.multi_line(xs=xs_list, ys=ys_list, line_color=my_palette) except ValueError: plot.multi_line(xs=xs_list, ys=ys_list) plot.xaxis.major_tick_line_color = None plot.xgrid.visible = False plot.ygrid.visible = False TextAlign = enumeration("left", "right", "center") plot.xaxis.major_label_text_align = TextAlign.left plot.xaxis.major_label_orientation = pi / 6 plot = self.add_annotation_for_categorical_data(plot, width) return plot
def colorby(values): if not values.dtype == int: values = [values.unique().tolist().index(v) for v in values] v = viridis(max(values)+1) color = [v[c] for c in values] return color
def _get_categorical_palette(factors: List[str]) -> Dict[str, str]: n = max(3, len(factors)) if n < len(palette): _palette = palette elif n < 21: from bokeh.palettes import Category20 _palette = Category20[n] else: from bokeh.palettes import viridis _palette = viridis(n) return CategoricalColorMapper(factors=factors, palette=_palette)
def colorPalette(self, size=None): # https://bokeh.pydata.org/en/latest/docs/reference/palettes.html # https://bokeh.pydata.org/en/latest/docs/reference/colors.html color = list(d3['Category10'][10]) # [ 'orangered', 'cornflowerblue', ] # color = list(Spectral9).reverse() if size is None: return color elif size <= len(color): return color[0:size] elif size <= 256: return linear_palette(plasma(256), size) else: return linear_palette(plasma(256) + viridis(256) + magma(256), size)
def map_color(arr: [], base_color=None, color_res=256, satur=False) -> "": min_a, max_a = (min(arr), max(arr)) def get_num_col_index(num): return int(round((num - min_a) / (max_a - min_a) * (color_res - 1))) arr_n = [get_num_col_index(c) for c in arr] if base_color: if satur: color_ramp_int = create_s_ramp_by_color(color_res, base_color) else: color_ramp_int = create_l_ramp_by_color(color_res, base_color) color_ramp = [int2hex(c) for c in color_ramp_int] else: color_ramp = palettes.viridis(color_res) arr_colors = [color_ramp[i] for i in arr_n] return arr_colors
def init_grid(self, range_min = -1, range_max = 1): 'Create an empty sample. ' self.converged= False # Initialization self.range_min = range_min self.range_max = range_max # If the algorithm doesn't converge, just return the best point so far. self.widen_attempts = 0 self.active_min = float(self.range_min) self.active_max = float(self.range_max) # tuples of (x, f(x)), ordered by x. self.search_grid = [] # tuples of current estimate & residual avg error, self.residuals = [] # Also assign plotting colors to points self.colors_grid = [] self.iseq = 0 # Color index self.spectrum = viridis(self.CLR_CYCLE) # colors to cycle thru. self.spectrum.reverse() self.x = [] self.y = [] self.half_range = (self.range_max - self.range_min)/2
def test_cmap_generator_function(): assert viridis(10) == Viridis10
d['released-loc'] = [] d['memory-loc'] = [] d['erred-loc'] = [] d['done'] = [] for r, m, e, a, l in zip(d['released'], d['memory'], d['erred'], d['all'], d['left']): rl = width * r / a + l ml = width * (r + m) / a + l el = width * (r + m + e) / a + l done = '%d / %d' % (r + m + e, a) d['released-loc'].append(rl) d['memory-loc'].append(ml) d['erred-loc'].append(el) d['done'].append(done) return d from toolz import memoize from bokeh.palettes import Spectral11, Spectral9, viridis import random task_stream_palette = list(viridis(25)) random.shuffle(task_stream_palette) import itertools counter = itertools.count() @memoize def incrementing_index(o): return next(counter)