def make_plot(xname, yname, xax=False, yax=False): mbl = 40 if yax else 0 mbb = 40 if xax else 0 plot = Plot( x_range=xdr, y_range=ydr, background_fill_color="#efe8e2", border_fill_color='white', plot_width=200 + mbl, plot_height=200 + mbb, min_border_left=2+mbl, min_border_right=2, min_border_top=2, min_border_bottom=2+mbb) circle = Circle(x=xname, y=yname, fill_color="color", fill_alpha=0.2, size=4, line_color="color") r = plot.add_glyph(source, circle) xdr.renderers.append(r) ydr.renderers.append(r) xticker = BasicTicker() if xax: xaxis = LinearAxis() xaxis.axis_label = xname plot.add_layout(xaxis, 'below') xticker = xaxis.ticker plot.add_layout(Grid(dimension=0, ticker=xticker)) yticker = BasicTicker() if yax: yaxis = LinearAxis() yaxis.axis_label = yname yaxis.major_label_orientation = 'vertical' plot.add_layout(yaxis, 'left') yticker = yaxis.ticker plot.add_layout(Grid(dimension=1, ticker=yticker)) plot.add_tools(PanTool(), WheelZoomTool()) return plot
def add_axes(self, plot, label): xaxis = LinearAxis() yaxis = LinearAxis() yaxis.axis_label = label plot.add_layout(xaxis, 'below') plot.add_layout(yaxis, 'left') plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker)) plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker)) return plot
def jobtype_builder(): jtypes = ["Half Time", "Full Time", "Hourly", "Temporary"] xdr = FactorRange(factors=jtypes) ydr = DataRange1d(sources=[source_jobtype.columns("data_range")]) plot = Plot(title="Job Type", data_sources=[source_jobtype], x_range=xdr, y_range=ydr, plot_width=760, plot_height=500) xaxis = CategoricalAxis(plot=plot, dimension=0, major_label_orientation=pi/4.0) yaxis = LinearAxis(plot=plot, dimension=1) yaxis.major_tick_in = 0 ygrid = Grid(plot=plot, dimension=1, axis=yaxis) quad = Rect(x="jobtypes", y="jobtype_half", height="count", width=0.9, fill_color="#33A6A4") bars = Glyph(data_source=source_jobtype, xdata_range=xdr, ydata_range=ydr, glyph=quad) plot.renderers.append(bars) plot.background_fill = '#686975' return plot
def weekday_builder(): dow = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"] xdr = FactorRange(factors=dow) ydr = DataRange1d(sources=[source_dow.columns("data_range")]) plot = Plot(title="Weekday of Job Posting", data_sources=[source_dow], x_range=xdr, y_range=ydr, plot_width=760, plot_height=500) xaxis = CategoricalAxis(plot=plot, dimension=0, major_label_orientation=pi/4.0) yaxis = LinearAxis(plot=plot, dimension=1) yaxis.major_tick_in = 0 ygrid = Grid(plot=plot, dimension=1, axis=yaxis) quad = Rect(x="weekday", y="weekday_half", height="count", width=0.9, fill_color="#D9301A") bars = Glyph(data_source=source_dow, xdata_range=xdr, ydata_range=ydr, glyph=quad) plot.renderers.append(bars) plot.background_fill = '#686975' return plot
def job_loc_plot_builder(): xdr = FactorRange(factors=countries) ydr = DataRange1d(sources=[source_country.columns("data_range")]) plot = Plot(title="Postings by Job Location (Country)", data_sources=[source_country], x_range=xdr, y_range=ydr, plot_width=760, plot_height=500) xaxis = CategoricalAxis(plot=plot, dimension=0, major_label_orientation=pi/4.0) yaxis = LinearAxis(plot=plot, dimension=1) yaxis.major_tick_in = 0 ygrid = Grid(plot=plot, dimension=1, axis=yaxis) quad = Rect(x="country", y="count_half", height="count", width=0.9, fill_color="#483D8B") bars = Glyph(data_source=source_country, xdata_range=xdr, ydata_range=ydr, glyph=quad) plot.renderers.append(bars) plot.background_fill = '#333333' return plot
source = ColumnDataSource(results) # Create a new plot and add a renderer top = Figure(tools=tools, title=None, x_range=day_range, **figure_style_kws) top.line('day', 'S', source=source, line_color=colors[0], line_width=3, line_cap='round') top.y_range = Range1d(0., 40.) top.yaxis.axis_label = "Salinity (g/kg)" top.xaxis.axis_label_text_font_size = label_fontsize top.yaxis.axis_label_text_font_size = label_fontsize # overlay volume level chart to salinity tc = "MediumBlue" # tide color tide_range = Range1d(start=0, end=15) tide_axis = LinearAxis(y_range_name="Z") tide_axis.axis_label = "Tidal Height (m)" tide_axis.axis_label_text_color = tc tide_axis.axis_label_text_font_size = label_fontsize tide_axis.major_tick_line_color = tc tide_axis.major_label_text_color = tc tide_axis.minor_tick_line_alpha = 0. top.extra_y_ranges = {"Z": tide_range} # top.line('day', 'Z', source=source, # line_color=tc, line_width=2, line_cap='round') top.add_layout(tide_axis, "right") top.line('day', 'Z', source=source, line_color=tc, line_width=2, line_cap='round', y_range_name="Z")
r = (cos(x)+1) * 6 + 6 source = ColumnDataSource(data=dict(x=x, y=y, r=r)) xdr = DataRange1d() ydr = DataRange1d() plot = Plot(x_range=xdr, y_range=ydr, min_border=80) circle = Circle( x="x", y="y", size="r", fill_color="red", line_color="black" ) plot.add_glyph(source, circle) xaxis = LinearAxis() plot.add_layout(xaxis, 'below') yaxis = LinearAxis() plot.add_layout(yaxis, 'left') plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker)) plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker)) plot.add_tools(PanTool(), WheelZoomTool()) document.add(plot) session.store_document(document) link = session.object_link(document.context) print ("please visit %s to see plots" % link)
def __init__(self, **kwargs): names = [ 'processes', 'disk-read', 'cores', 'cpu', 'disk-write', 'memory', 'last-seen', 'memory_percent', 'host' ] self.source = ColumnDataSource({k: [] for k in names}) columns = { name: TableColumn(field=name, title=name.replace('_percent', ' %')) for name in names } cnames = [ 'host', 'cores', 'processes', 'memory', 'cpu', 'memory_percent' ] formatters = { 'cpu': NumberFormatter(format='0.0 %'), 'memory_percent': NumberFormatter(format='0.0 %'), 'memory': NumberFormatter(format='0 b'), 'latency': NumberFormatter(format='0.00000'), 'last-seen': NumberFormatter(format='0.000'), 'disk-read': NumberFormatter(format='0 b'), 'disk-write': NumberFormatter(format='0 b'), 'net-send': NumberFormatter(format='0 b'), 'net-recv': NumberFormatter(format='0 b') } table = DataTable( source=self.source, columns=[columns[n] for n in cnames], ) for name in cnames: if name in formatters: table.columns[cnames.index(name)].formatter = formatters[name] mem_plot = Plot(title=Title(text="Memory Usage (%)"), toolbar_location=None, x_range=Range1d(start=0, end=1), y_range=Range1d(start=-0.1, end=0.1), **kwargs) mem_plot.add_glyph( self.source, Circle(x='memory_percent', y=0, size=10, fill_alpha=0.5)) mem_plot.add_layout(LinearAxis(), 'below') hover = HoverTool(point_policy="follow_mouse", tooltips=""" <div> <span style="font-size: 10px; font-family: Monaco, monospace;">@host: </span> <span style="font-size: 10px; font-family: Monaco, monospace;">@memory_percent</span> </div> """) mem_plot.add_tools(hover, BoxSelectTool()) if 'sizing_mode' in kwargs: sizing_mode = {'sizing_mode': kwargs['sizing_mode']} else: sizing_mode = {} self.root = column(mem_plot, table, id='bk-worker-table', **sizing_mode)
def make_plot(self): self.p = figure( x_axis_label="Date", x_axis_type="datetime", y_axis_label="Total Cases and Deaths", width=900, ) self.p.extra_y_ranges = {"ratio_axis": Range1d()} axis = LinearAxis(y_range_name="ratio_axis") axis.formatter = NumeralTickFormatter(format="0 %") self.p.add_layout(axis, "right") colors = Category20_3 self.p.line( source=self.src, x="date", y="cases", line_width=2, color=colors[0], legend_label="Cases", ) self.p.line( source=self.src, x="date", y="deaths", line_width=2, color=colors[1], legend_label="Deaths", ) self.p.line( source=self.src, x="date", y="ratio", line_width=2, y_range_name="ratio_axis", color=colors[2], legend_label="Deaths/Cases", ) self.p.legend.location = "top_left" self.logp = figure( x_axis_label="Date", x_axis_type="datetime", y_axis_label="Total Cases and Deaths", y_axis_type="log", width=900, ) self.logp.extra_y_ranges = {"ratio_axis": Range1d()} logaxis = LogAxis(y_range_name="ratio_axis") logaxis.formatter = NumeralTickFormatter(format="0 %") self.logp.add_layout(logaxis, "right") self.logp.line( source=self.src, x="date", y="cases", line_width=2, color=colors[0], legend_label="Cases", ) self.logp.line( source=self.src, x="date", y="deaths", line_width=2, color=colors[1], legend_label="Deaths", ) self.logp.line( source=self.src, x="date", y="ratio", line_width=2, y_range_name="ratio_axis", color=colors[2], legend_label="Deaths/Cases", ) self.p.legend.location = "top_left"
microseconds=['%F %T.%3N'], milliseconds=['%F %T.%3N'], seconds=['%F %T'], minsec=['%F %T'], minutes=['%F %T'], hourmin=['%F %T'], hours=['%F %T'], days=['%F %T'], months=['%F %T'], years=['%F %T'], ) p.xaxis.major_label_orientation = 0.7 #1.571 #math.pi/2 p.xaxis.axis_label = "T" p.extra_y_ranges = {'RH': Range1d(bounds=(0, 100), start=0, end=100)} p.add_layout(LinearAxis(y_range_name='foo', axis_label='RH'), 'right') p.line(x='time', y='T', alpha=0.5, line_width=1, color='red', source=source) p.line(x='time', y='RH', alpha=0.5, line_width=1, color='blue', source=source, y_range_name='foo') def _read_sensor(): timeval = datetime.datetime.now() #pd.to_datetime('now') #int(time.time()*1000000) #T = np.random.normal(0, 1)
def generate_stack(name, var_label=None, auto_color=True, combine_axes=True, interactive=True): doc.curdoc().clear() num_plots = len(name) # Name for .html file containing plots out_name = "" if isinstance(var_label, int): var_label = list(pytplot.data_quants.keys())[var_label] # Vertical Box layout to store plots all_plots = [] axis_types = [] i = 0 # Configure plot sizes total_psize = 0 j = 0 while (j < num_plots): total_psize += pytplot.data_quants[name[j]].extras['panel_size'] j += 1 p_to_use = pytplot.tplot_opt_glob['window_size'][1] / total_psize # Create all plots while (i < num_plots): last_plot = (i == num_plots - 1) p_height = int(pytplot.data_quants[name[i]].extras['panel_size'] * p_to_use) p_width = pytplot.tplot_opt_glob['window_size'][0] #Check plot type new_fig = _get_figure_class(name[i], auto_color=auto_color, interactive=interactive, show_xaxis=last_plot) new_fig.setsize(height=p_height, width=p_width) if i == 0: new_fig.add_title() axis_types.append(new_fig.getaxistype()) new_fig.buildfigure() # Add name of variable to output file name if last_plot: out_name += name[i] else: out_name += name[i] + '+' # Add plot to GridPlot layout all_plots.append(new_fig.getfig()) i = i + 1 #Add the time stamp to the stack total_string = "" if 'time_stamp' in pytplot.extra_layouts: total_string = pytplot.extra_layouts['time_stamp'] ts = TimeStamp(text=total_string) pytplot.extra_layouts['data_time'] = ts all_plots.append([pytplot.extra_layouts['data_time']]) #Add extra x axes if applicable if var_label is not None: if not isinstance(var_label, list): var_label = [var_label] x_axes = [] x_axes_index = 0 for new_x_axis in var_label: axis_data_quant = pytplot.data_quants[new_x_axis] axis_start = min(axis_data_quant.data.min(skipna=True).tolist()) axis_end = max(axis_data_quant.data.max(skipna=True).tolist()) x_axes.append(Range1d(start=axis_start, end=axis_end)) k = 0 while (k < num_plots): all_plots[k][0].extra_x_ranges[ 'extra_' + str(new_x_axis)] = x_axes[x_axes_index] k += 1 all_plots[k - 1][0].add_layout( LinearAxis(x_range_name='extra_' + str(new_x_axis)), 'below') all_plots[k - 1][0].plot_height += 22 x_axes_index += 1 # Set all plots' x_range and plot_width to that of the bottom plot # so all plots will pan and be resized together. first_type = {} if combine_axes: k = 0 while (k < len(axis_types)): if axis_types[k][0] not in first_type: first_type[axis_types[k][0]] = k else: all_plots[k][0].x_range = all_plots[first_type[axis_types[k] [0]]][0].x_range if axis_types[k][1]: all_plots[k][0].y_range = all_plots[first_type[ axis_types[k][0]]][0].y_range k += 1 return gridplot(all_plots)
editor=SelectEditor(options=classes)), TableColumn(field="cty", title="City MPG", editor=IntEditor()), TableColumn(field="hwy", title="Highway MPG", editor=IntEditor()), ] data_table = DataTable(source=source, columns=columns, editable=True, width=1000, index_position=-1, index_header="row index", index_width=60) plot = Plot(title=None, plot_width=1000, plot_height=300) # Set up x & y axis plot.add_layout(LinearAxis(), 'below') yaxis = LinearAxis() plot.add_layout(yaxis, 'left') plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker)) # Add Glyphs cty_glyph = Circle(x="index", y="cty", fill_color="#396285", size=8, fill_alpha=0.5, line_alpha=0.5) hwy_glyph = Circle(x="index", y="hwy", fill_color="#CE603D", size=8,
# column in your data source. Uncomment the following line # to see the effect. # fill_alpha=0.2, # An alternative form that explicitly sets a default value: #fill_color={"default": "red", "field": "color"}, # Note that line_color is set to a fixed value. This can be any of # the SVG named 147 colors, or a hex color string starting with "#", # or a string "rgb(r,g,b)" or "rgba(r,g,b,a)". # Any other string will be interpreted as a field name to look up # on the datasource. line_color="black") plot.add_glyph(source, circle) plot.add_layout(LinearAxis(), 'below') plot.add_layout(LinearAxis(), 'left') plot.add_tools(PanTool(), WheelZoomTool()) doc = Document() doc.add(plot) if __name__ == "__main__": filename = "colorspec.html" with open(filename, "w") as f: f.write(file_html(doc, INLINE, "Demonstration of ColorSpec")) print("Wrote %s" % filename) view(filename)
def roi_cost(width, height, title_text, title_align): df = pd.read_sql( """SELECT YEAR([P].[DATA]) AS [ROK], [P].[SEC_COST] AS [KOSZT], [PREMIUM].[PREMIUM] FROM [PORTFEL_IN_TIME_VW] AS [P], (SELECT YEAR([DATA]) AS [ROK], MAX([DATA]) AS [MAXDATA] FROM [PORTFEL_IN_TIME_VW] GROUP BY YEAR([DATA])) AS [DATES], (SELECT [ROK], SUM([VAL]) AS [PREMIUM] FROM [PREMIUM_VW] GROUP BY [ROK]) AS [PREMIUM] WHERE [P].[NAZWA] = 'Razem' AND [P].[DATA] = [DATES].[MAXDATA] AND YEAR([P].[DATA]) = [PREMIUM].[ROK] OPTION (MAXRECURSION 0)""", conn) #wyliczenie ROI df['ROI'] = df['PREMIUM'] / df['KOSZT'] #dane source = ColumnDataSource(data=df) p = figure(x_range=(min(df['ROK']) - 0.35, max(df['ROK']) + 0.35), plot_width=width, plot_height=height, toolbar_location=None) #oś dodatkowa dla ROI p.extra_y_ranges = {'roi': Range1d(start=0, end=max(df['ROI']) * 1.5)} p.add_layout(LinearAxis(y_range_name='roi'), 'right') #budowa słupków p.vbar(name='KOSZT', x='ROK', top='KOSZT', width=0.5, color=colors[0], source=source) #linia z ROI p.line(name='ROI', x='ROK', y='ROI', line_width=5, color=colors[1], source=source, y_range_name='roi') hover = HoverTool(tooltips=[('', '@ROK'), ('Koszt', '@KOSZT{0,0.00}'), ('Przychody', '@PREMIUM{0,0.00}'), ('ROI', '@ROI{0,0.00%}')], mode='mouse', renderers=[p.renderers[0]]) p.add_tools(hover) p.yaxis[0].formatter = NumeralTickFormatter(format="0,00 a") p.yaxis[0].axis_label = "Koszt portfela" p.yaxis[1].formatter = NumeralTickFormatter(format="0.00 %") p.yaxis[1].axis_label = "Stopa zwrotu" p.xaxis.ticker.max_interval = 1 p.xaxis.ticker.min_interval = 1 p.axis.minor_tick_in = 0 p.axis.minor_tick_out = 0 p.ygrid.grid_line_width = 0 p.xgrid.grid_line_width = 0 p.outline_line_color = None p.border_fill_color = None #tytuł p.title.text = title_text p.title.align = title_align return p
def plot_time_evol( self, tracts=None, figs_output_dir='', scripts_output_dir='', div_output_dir='', ): """Plot response time and number of incidents as a function of time. If `tracts` is not provided, the method generates plots for each tract in the database. The `tracts` parameter is expected to be a list of strings (not zero-padded), though the method will attempt to convert it to the correct data type otherwise.""" tracts = self._get_tracts(tracts) for tr in tracts: # filter dataset by date and tract df_tmp = self._get_response_time_and_priority_df(tr) median_response_time = self._group_median_response_time( df_tmp, GROUPING_FREQ, ) total_num_incidents = self._group_num_incidents( df_tmp, GROUPING_FREQ, ) priority_groups = self._group_priority( df_tmp, GROUPING_FREQ, ) tract_geometry, cntr_lng, cntr_lat = get_tract_geom(tr) output_file(figs_output_dir + f"stats_tract{tr}.html") tools = "pan,wheel_zoom,box_zoom,crosshair,reset" p1 = figure( plot_width=1200, plot_height=400, x_axis_type='datetime', x_axis_label='Date', y_axis_label='Median Response Time (minutes)', toolbar_location="above", tools=tools, ) p1.yaxis.axis_label_text_font_size = '12pt' p1.yaxis.major_label_text_font_size = '10pt' p1.yaxis.axis_label_text_color = 'steelblue' p1.xaxis.axis_label_text_font_size = '12pt' p1.xaxis.major_label_text_font_size = '10pt' p1.line( median_response_time.index, median_response_time.values, line_width=5, color='steelblue', alpha=0.75, legend_label='Median Response Time', ) p1.y_range = Range1d( min(median_response_time) * 0.95, max(median_response_time) * 1.05, ) p1.extra_y_ranges = { 'NumIncidents': Range1d( start=min(total_num_incidents) * 0.95, end=max(total_num_incidents) * 1.05, ) } p1.add_layout( LinearAxis( y_range_name='NumIncidents', axis_label='Number of Incidents', axis_label_text_font_size='12pt', axis_label_text_color='firebrick', major_label_text_font_size='10pt', ), 'right', ) p1.line( total_num_incidents.index, total_num_incidents.values, line_width=5, color='firebrick', alpha=0.75, y_range_name='NumIncidents', legend_label='Number of Incidents', ) p1.legend.location = "top_left" p1.legend.click_policy = "hide" p2 = figure( plot_width=800, plot_height=400, x_axis_type='datetime', x_axis_label='Date', y_axis_label='Number of Incidents', toolbar_location="above", tools=tools, x_range=p1.x_range, ) p2.min_border_left = 150 p2.y_range.start = 0 p2.yaxis.axis_label_text_font_size = '12pt' p2.yaxis.major_label_text_font_size = '10pt' p2.xaxis.axis_label_text_font_size = '12pt' p2.xaxis.major_label_text_font_size = '10pt' stacked_area_source = ColumnDataSource( data=dict( x=median_response_time.index ) ) for pc in PRIORITY_CODES: stacked_area_source.add( priority_groups[pc], name=pc, ) p2.varea_stack( PRIORITY_CODES, x='x', source=stacked_area_source, color=('#bf9f84', 'darkolivegreen', '#e7cb75'), alpha=0.75, legend_label=[f"Priority {pc}" for pc in PRIORITY_CODES], ) p2.legend.location = 'top_left' p2.legend.orientation = 'horizontal' p2.legend.spacing = 20 tools = "pan,wheel_zoom,reset,save" map_options = GMapOptions( lat=cntr_lat, lng=cntr_lng, map_type="roadmap", zoom=14 ) p3 = gmap( GMAP_API_KEY, map_options, width=420, height=400, tools=tools, toolbar_location='above' ) p3.yaxis.visible=False p3.xaxis.visible=False p3.min_border_left = 50 lng_coords, lat_coords = [], [] for pg in list(tract_geometry.geoms): c = pg.exterior.coords.xy lng_coords.append(list(c[0])) lat_coords.append(list(c[1])) source = ColumnDataSource( data=dict( x=lng_coords, y=lat_coords, ) ) p3.patches( 'x', 'y', source=source, fill_color='darkslateblue', fill_alpha=0.5, line_color="black", line_width=1, ) p = layout([[p3, p2], [p1]], spacing=50) save(p) script, div = components(p) with open( scripts_output_dir + f"stats_script_tract{tr}.js", 'w' ) as f: f.write(script) with open( div_output_dir + f"stats_div_tract{tr}.html", 'w' ) as f: f.write(div) return None
sepal_length=flowers['sepal_length'], sepal_width=flowers['sepal_width'], color=flowers['color'] ) ) plot = Plot(plot_width=800, plot_height=400) plot.title.text = "Iris Data" circle = Circle( x="petal_length", y="petal_width", size=10, fill_color="color", fill_alpha=0.2, line_color="color" ) plot.add_glyph(source, circle) xaxis = LinearAxis(axis_label="petal length", major_tick_in=0) plot.add_layout(xaxis, 'below') yaxis = LinearAxis(axis_label="petal width", major_tick_in=0) plot.add_layout(yaxis, 'left') plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker)) plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker)) plot.add_tools(PanTool(), WheelZoomTool()) # Add a caption as a title placed in "below" layout panel. msg = """The Iris flower data set, or Fisher's Iris data set, is a multivariate data set introduced by Ronald Fisher in his 1936 paper.""" caption = Title(text=msg, align='left', text_font_size='10pt') plot.add_layout(caption, 'below')
x2 = np.linspace(1.5, 5.5, 5) z = x2 + 2 * np.cos((x2 - 1) * np.pi) source1 = ColumnDataSource({ "x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5], "who": ["a", "b", "c", "d", "e"] }) source2 = ColumnDataSource({"x": x, "y": y}) source3 = ColumnDataSource({"x": x2, "y": z}) source4 = ColumnDataSource({"y": [2.5], "x": [0.5]}) plot = Plot(width=300, height=300) plot.title = Title(text="Themed glyphs") xaxis = LinearAxis(ticker=BasicTicker(), formatter=BasicTickFormatter()) yaxis = LinearAxis(ticker=BasicTicker(), formatter=BasicTickFormatter()) plot.add_layout(xaxis, "below") plot.add_layout(yaxis, "left") plot.add_glyph(source1, Scatter(x="x", y="y", marker="diamond", size=20)) plot.add_glyph(source1, Text(x=dodge("x", -0.2), y=dodge("y", 0.1), text="who")) plot.add_glyph(source2, Line(x="x", y="y")) plot.add_glyph(source3, Ellipse(x="x", y="y", width=0.2, height=0.3, angle=-0.7)) plot.add_glyph(source4, glyph=HBar(y="y", right="x", height=1.5))
def plot_picture(dates, states, var_values, confidence_values, save_path, name_dict, s_size=0.1): ## Fig 생성 fig = figure(title=name_dict['title'], x_axis_label='Timeline', x_axis_type='datetime', y_axis_label='score', plot_width=2000, plot_height=500) fig.y_range = Range1d(start=min(var_values), end=max(var_values)) fig.line(dates, var_values, line_width=2, color=name_dict['var_color'], legend_label=name_dict['var_name']) if states is not None and len(dates) > 0: temp_start = dates[0] temp_state = states[0] temp_date = dates[0] for xc, value in zip(dates, states): if temp_state != value: if temp_state == 'prognosis': fig.add_layout( BoxAnnotation(left=temp_start, right=temp_date, fill_alpha=0.2, fill_color='blue')) if temp_state == 'abnormal': fig.add_layout( BoxAnnotation(left=temp_start, right=temp_date, fill_alpha=0.2, fill_color='orange')) temp_start = xc temp_state = value temp_date = xc if temp_state == 'prognosis': fig.add_layout( BoxAnnotation(left=temp_start, right=xc, fill_alpha=0.2, fill_color='blue')) if temp_state == 'abnormal': fig.add_layout( BoxAnnotation(left=temp_start, right=xc, fill_alpha=0.2, fill_color='orange')) if confidence_values is not None: fig.extra_y_ranges = { "var": Range1d(start=-1, end=max(confidence_values) + 1) } fig.add_layout(LinearAxis(y_range_name="var"), 'right') fig.line(dates, confidence_values, legend_label=name_dict['confidence_name'], line_width=2, y_range_name='var', color=name_dict['confidence_color'], line_alpha=.3) fig.legend.click_policy = 'hide' output_file(filename=save_path) save(fig)
def plot_resources(results, palette="Viridis", **kwargs): """Plot resource usage in a bokeh plot. Parameters ---------- results : sequence Output of ResourceProfiler.results palette : string, optional Name of the bokeh palette to use, must be a member of bokeh.palettes.all_palettes. **kwargs Other keyword arguments, passed to bokeh.figure. These will override all defaults set by plot_resources. Returns ------- The completed bokeh plot object. """ bp = import_required("bokeh.plotting", _BOKEH_MISSING_MSG) import bokeh from bokeh import palettes from bokeh.models import LinearAxis, Range1d defaults = dict( title="Profile Results", tools="save,reset,xwheel_zoom,xpan", toolbar_location="above", width=800, height=300, ) # Support plot_width and plot_height for backwards compatibility if "plot_width" in kwargs: kwargs["width"] = kwargs.pop("plot_width") if "plot_height" in kwargs: kwargs["height"] = kwargs.pop("plot_height") # Drop `label_size` to match `plot_cache` and `plot_tasks` kwargs if "label_size" in kwargs: kwargs.pop("label_size") defaults.update(**kwargs) if results: t, mem, cpu = zip(*results) left, right = min(t), max(t) t = [i - left for i in t] p = bp.figure(y_range=fix_bounds(0, max(cpu), 100), x_range=fix_bounds(0, right - left, 1), **defaults) else: t = mem = cpu = [] p = bp.figure(y_range=(0, 100), x_range=(0, 1), **defaults) colors = palettes.all_palettes[palette][6] p.line( t, cpu, color=colors[0], line_width=4, **{ "legend_label" if LooseVersion(bokeh.__version__) >= "1.4" else "legend": "% CPU" }) p.yaxis.axis_label = "% CPU" p.extra_y_ranges = { "memory": Range1d( *fix_bounds(min(mem) if mem else 0, max(mem) if mem else 100, 100)) } p.line( t, mem, color=colors[2], y_range_name="memory", line_width=4, **{ "legend_label" if LooseVersion(bokeh.__version__) >= "1.4" else "legend": "Memory" }) p.add_layout(LinearAxis(y_range_name="memory", axis_label="Memory (MB)"), "right") p.xaxis.axis_label = "Time (s)" return p
def update_scale(attr, old, new): ticker = LinearAxis() if new == "Log scale": ticker = LogAxis() pairplots['dimdem'].yaxis[0] = ticker
plot_height=600, toolbar_location=None, outline_line_color=None, y_axis_type=None) plot.title.text = "Usain Bolt vs. 116 years of Olympic sprinters" plot.title.text_font_size = "14pt" plot.xaxis.ticker = SingleIntervalTicker(interval=5, num_minor_ticks=0) plot.xaxis.axis_line_color = None plot.xaxis.major_tick_line_color = None plot.xgrid.grid_line_dash = "dashed" yticker = FixedTicker( ticks=[1900, 1912, 1924, 1936, 1952, 1964, 1976, 1988, 2000, 2012]) yaxis = LinearAxis(ticker=yticker, major_tick_in=-5, major_tick_out=10) plot.add_layout(yaxis, "right") radius = dict(value=5, units="screen") medal = plot.circle(x="MetersBack", y="Year", radius=radius, fill_color="MedalFill", line_color="MedalLine", fill_alpha=0.5, source=source, level="overlay") #medal_glyph = Circle(x="MetersBack", y="Year", radius=radius, fill_color="MedalFill", line_color="MedalLine", fill_alpha=0.5) #medal = plot.add_glyph(source, medal_glyph) athlete_glyph = Text(x="MetersBack",
p.circle(x='Date', y='dowjclose', name='dowj', alpha=0, source=source2, size=3) p.circle(x='Date', y='XOMclose', name='xom', alpha=0, source=source2, size=3, y_range_name='foo') # Setting the second y axis range name and range p.extra_y_ranges = {"foo": Range1d(start=50, end=150)} # Adding the second axis to the plot. p.add_layout(LinearAxis(y_range_name="foo"), 'right') p.multi_line(name='bill', xs=xom[0], ys=xom[1], color=xom[2], line_width=3, y_range_name='foo') p.multi_line(name='steve', xs=dowj[0], ys=dowj[1], color=dowj[2], line_width=3) p.add_tools( HoverTool(names=['dowj'], mode="vline", line_policy='nearest', point_policy='snap_to_data',
start=sprint.MetersBack.max() + 2, end=0) # XXX: +2 is poor-man's padding (otherwise misses last tick) ydr = DataRange1d(range_padding=0.05) # XXX: should be 2 years (both sides) plot = Plot(x_range=xdr, y_range=ydr, plot_width=1000, plot_height=600, toolbar_location=None, outline_line_color=None) plot.title.text = "Usain Bolt vs. 116 years of Olympic sprinters" xticker = SingleIntervalTicker(interval=5, num_minor_ticks=0) xaxis = LinearAxis(ticker=xticker, axis_line_color=None, major_tick_line_color=None, axis_label="Meters behind 2012 Bolt", axis_label_text_font_size="10pt", axis_label_text_font_style="bold") plot.add_layout(xaxis, "below") xgrid = Grid(dimension=0, ticker=xaxis.ticker, grid_line_dash="dashed") plot.add_layout(xgrid) yticker = SingleIntervalTicker(interval=12, num_minor_ticks=0) yaxis = LinearAxis(ticker=yticker, major_tick_in=-5, major_tick_out=10) plot.add_layout(yaxis, "right") radius = dict(value=5, units="screen") medal_glyph = Circle(x="MetersBack", y="Year", radius=radius, fill_color="MedalFill", line_color="MedalLine",
def timeLineChartWind(data, details='', width=set_w, height=set_h): x_name = 'Time' if len(details['icao']) > 0: location = ' at ' + details['icao'].upper() else: location = '' xdr = DataRange1d(start=data[x_name][0], end=data[x_name][-1]) maxspd, minspd = max(np.nanmax(data['Wind Speed']), np.nanmax(data['Wind Gust'])) + 1, np.nanmax( min(data['Wind Speed']) - 1, 0) ydr = DataRange1d(start=minspd, end=maxspd) sv_plotcolour_spd = '#53f3ae' sv_plotcolour_dir = '#9f54bb' plot = figure(title='Wind' + location + ' (Gusts shown only if reportable)', plot_width=width, plot_height=height, x_axis_type='datetime', x_range=xdr, y_range=ydr, toolbar_location=None, sizing_mode='stretch_both') makeCirclePlot(plot, data, 'Wind Speed', sv_plotcolour_spd) speed_plot = makeLinePlot(plot, data, 'Wind Speed', sv_plotcolour_spd) plot.add_tools( HoverTool( renderers=[speed_plot], tooltips='@{Wind Direction} @{Wind Speed}KT at @Time{%H%MZ}', mode='vline', # use 'mouse' for only over points formatters={'@Time': 'datetime'}, show_arrow=False, )) gust_plot_hidden = makeLinePlot(plot, data, 'Wind Gust', 'red', line_alpha=0) gust_plot = makeCirclePlot(plot, data, 'Wind Gust', sv_plotcolour_spd, size=12) plot.add_tools( HoverTool( renderers=[gust_plot_hidden], tooltips='Reported gust of @{Wind Gust}KT at @Time{%H%MZ}', mode='vline', # use 'mouse' for only over points formatters={'@Time': 'datetime'}, show_arrow=False, )) plot.yaxis.axis_label = 'Wind speed/gust (KT)' setLook(plot) #plot.yaxis.axis_line_color = sv_plotcolour_spd #plot.yaxis.axis_label_text_color = sv_plotcolour_spd #plot.yaxis.major_label_text_color = sv_plotcolour_spd #plot.yaxis.major_tick_line_color = sv_plotcolour_spd plot.extra_y_ranges['dir'] = DataRange1d(start=0, end=360) plot.add_layout( LinearAxis(y_range_name='dir', axis_label='Wind direction (degrees)', axis_line_color=sv_plotcolour_dir, axis_label_text_color=sv_plotcolour_dir, major_label_text_color=sv_plotcolour_dir, major_tick_line_color=sv_plotcolour_dir, minor_tick_line_color=sv_plotcolour_dir), 'right') dir_plot = makeLinePlot(plot, data, 'Wind Direction', sv_plotcolour_dir, line_alpha=0.5) dir_plot.y_range_name = 'dir' return components(plot)
def hist(df, feature, bins=50): '''Plots bokeh histogram, PDF & CDF of a DF feature. Parameters ---------- df : DataFrame DF of the data. feature : str Column name of the df. bins : int Number of bins to plot. Returns ------- None ''' #not nan feature values x = df[feature][df[feature].notna()].values #Get the values for the histogram and bin edges (length(hist)+1)/ #Use density to plot pdf and cdf on the same plot. hist, edges = np.histogram(x, bins=bins, density=True) ### PDF & CDF ## #find normal distribution parameters mu, sigma = norm.fit(x) xs = np.linspace(min(x), max(x) + 1, len(x)) #x values to plot the line(s) pdf = norm.pdf(xs, loc=mu, scale=sigma) #probability distribution function cdf = norm.cdf(xs, loc=mu, scale=sigma) #cumulative distribution function #data sources for cdf source_cdf = ColumnDataSource({'cdf': cdf, 'xs': xs}) #create the canvas p1 = figure(title='Histogram, PDF & CDF', plot_height=400, x_axis_label=feature, y_axis_label='Density') #add histogram p1.quad(bottom=0, top=hist, left=edges[:-1], right=edges[1:], fill_color='royalblue', line_color='black', alpha=0.7) #add pdf p1.line(xs, pdf, line_color='red', line_width=5, alpha=0.5, legend_label='PDF') #set left-hand y-axis range p1.y_range = Range1d(0, max(hist) + 0.05 * max(hist)) #setting the second y axis range name and range p1.extra_y_ranges = {"cdf": Range1d(start=0, end=1.05)} #adding the second y axis to the plot and to the right. p1.add_layout(LinearAxis(y_range_name="cdf", axis_label='CDF'), 'right') #add cdf with y range on the right cdf_plot = p1.line('xs', 'cdf', source=source_cdf, alpha=0.8, line_color='darkgoldenrod', line_width=5, legend_label='CDF', y_range_name='cdf', name='cdf', hover_line_color='green') #hover tool p1.add_tools( HoverTool(renderers=[cdf_plot], tooltips=[('Prob', '@cdf{0.00}')], mode='hline')) #figure properties p1.xgrid.visible = False #hide entries when clocking on a legend p1.legend.click_policy = "hide" show(p1)
def timeChartCloud(data, details='', width=set_w, height=set_h * 2): x_name = 'Time' icao = details['icao'] if len(icao) > 0: location = ' at ' + icao.upper() else: location = '' xdr = DataRange1d(start=data[x_name][0], end=data[x_name][-1]) #ydr = DataRange1d(start=0,end=15000) tick_vals, tick_label_overrides = getHeightmapTicks(icao) ydr = DataRange1d(start=mapHeight(0, icao), end=mapHeight(int(tick_label_overrides[max(tick_vals)]), icao)) sv_plotcolour_vis = 'white' plot = figure(title='Cloud base' + location, plot_width=width, plot_height=height, x_axis_type='datetime', x_range=xdr, y_range=ydr, toolbar_location=None, sizing_mode='stretch_both') colourstates, alphas = [], [] for b in data['Cloud Base']: colourstates.append(applyCloudColourState(b)) data['colourstates'] = colourstates for a in data['Cloud Amount']: if a in ['SCT', 'BKN', 'OVC']: alphas.append(0.6) else: alphas.append(0.2) data['alphas'] = alphas cloud_plot = makeCirclePlot(plot, data, 'Cloud Base Adjusted', 'colourstates', size=15, alpha='alphas') plot.add_tools( HoverTool( renderers=[cloud_plot], tooltips='@{Cloud Amount} at @{Cloud Base}FT at @Time{%H%MZ}', mode='mouse', # use 'mouse' for only over points formatters={'@Time': 'datetime'}, show_arrow=False, )) plot.yaxis.axis_label = 'Height (FT)' plot.add_layout(LinearAxis(axis_label='Height (FT)'), 'right') plot.yaxis.ticker = tick_vals plot.yaxis.major_label_overrides = tick_label_overrides setLook(plot) return components(plot)
def __init__(self, **kwargs): self.source = ColumnDataSource( data={ 'time': [], 'cpu': [], 'memory_percent': [], 'network-send': [], 'network-recv': [] }) x_range = DataRange1d(follow='end', follow_interval=30000, range_padding=0) resource_plot = Plot(x_range=x_range, y_range=Range1d(start=0, end=1), toolbar_location=None, min_border_bottom=10, **kwargs) line_opts = dict(line_width=2, line_alpha=0.8) g1 = resource_plot.add_glyph( self.source, Line(x='time', y='memory_percent', line_color="#33a02c", **line_opts)) g2 = resource_plot.add_glyph( self.source, Line(x='time', y='cpu', line_color="#1f78b4", **line_opts)) resource_plot.add_layout( LinearAxis(formatter=NumeralTickFormatter(format="0 %")), 'left') legend_opts = dict(location='top_left', orientation='horizontal', padding=5, margin=5, label_height=5) resource_plot.add_layout( Legend(items=[('Memory', [g1]), ('CPU', [g2])], **legend_opts)) network_plot = Plot(x_range=x_range, y_range=DataRange1d(start=0), toolbar_location=None, **kwargs) g1 = network_plot.add_glyph( self.source, Line(x='time', y='network-send', line_color="#a6cee3", **line_opts)) g2 = network_plot.add_glyph( self.source, Line(x='time', y='network-recv', line_color="#b2df8a", **line_opts)) network_plot.add_layout(DatetimeAxis(axis_label="Time"), "below") network_plot.add_layout(LinearAxis(axis_label="MB/s"), 'left') network_plot.add_layout( Legend(items=[('Network Send', [g1]), ('Network Recv', [g2])], **legend_opts)) tools = [ PanTool(dimensions='width'), WheelZoomTool(dimensions='width'), BoxZoomTool(), ResetTool() ] if 'sizing_mode' in kwargs: sizing_mode = {'sizing_mode': kwargs['sizing_mode']} else: sizing_mode = {} combo_toolbar = ToolbarBox(tools=tools, logo=None, toolbar_location='right', **sizing_mode) self.root = row(column(resource_plot, network_plot, **sizing_mode), column(combo_toolbar, **sizing_mode), id='bk-resource-profiles-plot', **sizing_mode) # Required for update callback self.resource_index = [0]
sys.exit() pncIntf = pncCommListener(pncSocket) pncIntf.start() #update_lock = threading.Lock() queueLength = figure(title="Buffer Fill Level", plot_width=800, plot_height=400) r1 = queueLength.line([], [], color="firebrick", line_width=2) threadTime = figure(title="Z-Axis Encoder", plot_width=800, plot_height=400) r2 = threadTime.line([], [], color="firebrick", line_width=2) ticker = SingleIntervalTicker(interval=5, num_minor_ticks=10) xaxis = LinearAxis(ticker=ticker) yaxis = LinearAxis(ticker=ticker) ds1 = r1.data_source ds2 = r2.data_source @linear() def update(step): #print(step) if pncIntf.needUpdate: #print('need to update plots') queue_data = pncIntf.data['TCQ'] encoder_data = pncIntf.data['Encoder'] #encoder_len = len(encoder_data)
def __init__(self, n_rectangles=1000, clear_interval=20000, **kwargs): """ kwargs are applied to the bokeh.models.plots.Plot constructor """ self.n_rectangles = n_rectangles self.clear_interval = clear_interval self.last = 0 self.source = ColumnDataSource( data=dict(start=[time() - clear_interval], duration=[0.1], key=['start'], name=['start'], color=['white'], worker=['foo'], y=[0], worker_thread=[1], alpha=[0.0])) x_range = DataRange1d(range_padding=0) y_range = DataRange1d(range_padding=0) self.root = Plot(title=Title(text="Task Stream"), id='bk-task-stream-plot', x_range=x_range, y_range=y_range, toolbar_location="above", min_border_right=35, **kwargs) self.root.add_glyph( self.source, Rect(x="start", y="y", width="duration", height=0.4, fill_color="color", line_color="color", line_alpha=0.6, fill_alpha="alpha", line_width=3)) self.root.add_layout(DatetimeAxis(axis_label="Time"), "below") ticker = BasicTicker(num_minor_ticks=0) self.root.add_layout( LinearAxis(axis_label="Worker Core", ticker=ticker), "left") self.root.add_layout( Grid(dimension=1, grid_line_alpha=0.4, ticker=ticker)) self.root.yaxis.major_label_text_alpha = 0 hover = HoverTool(point_policy="follow_mouse", tooltips=""" <div> <span style="font-size: 12px; font-weight: bold;">@name:</span> <span style="font-size: 10px; font-family: Monaco, monospace;">@duration</span> <span style="font-size: 10px;">ms</span> </div> """) self.root.add_tools(hover, BoxZoomTool(), ResetTool(reset_size=False), PanTool(dimensions="width"), WheelZoomTool(dimensions="width")) if ExportTool: export = ExportTool() export.register_plot(self.root) self.root.add_tools(export) # Required for update callback self.task_stream_index = [0]
def create(self): manufacturers = sorted(mpg["manufacturer"].unique()) models = sorted(mpg["model"].unique()) transmissions = sorted(mpg["trans"].unique()) drives = sorted(mpg["drv"].unique()) classes = sorted(mpg["class"].unique()) manufacturer_select = Select(title="Manufacturer:", value="All", options=["All"] + manufacturers) manufacturer_select.on_change('value', self.on_manufacturer_change) model_select = Select(title="Model:", value="All", options=["All"] + models) model_select.on_change('value', self.on_model_change) transmission_select = Select(title="Transmission:", value="All", options=["All"] + transmissions) transmission_select.on_change('value', self.on_transmission_change) drive_select = Select(title="Drive:", value="All", options=["All"] + drives) drive_select.on_change('value', self.on_drive_change) class_select = Select(title="Class:", value="All", options=["All"] + classes) class_select.on_change('value', self.on_class_change) columns = [ TableColumn(field="manufacturer", title="Manufacturer", editor=SelectEditor(options=manufacturers), formatter=StringFormatter(font_style="bold")), TableColumn(field="model", title="Model", editor=StringEditor(completions=models)), TableColumn(field="displ", title="Displacement", editor=NumberEditor(step=0.1), formatter=NumberFormatter(format="0.0")), TableColumn(field="year", title="Year", editor=IntEditor()), TableColumn(field="cyl", title="Cylinders", editor=IntEditor()), TableColumn(field="trans", title="Transmission", editor=SelectEditor(options=transmissions)), TableColumn(field="drv", title="Drive", editor=SelectEditor(options=drives)), TableColumn(field="class", title="Class", editor=SelectEditor(options=classes)), TableColumn(field="cty", title="City MPG", editor=IntEditor()), TableColumn(field="hwy", title="Highway MPG", editor=IntEditor()), ] data_table = DataTable(source=self.source, columns=columns, editable=True) plot = Plot(title=None, x_range=DataRange1d(), y_range=DataRange1d(), plot_width=1000, plot_height=300) # Set up x & y axis plot.add_layout(LinearAxis(), 'below') yaxis = LinearAxis() plot.add_layout(yaxis, 'left') plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker)) # Add Glyphs cty_glyph = Circle(x="index", y="cty", fill_color="#396285", size=8, fill_alpha=0.5, line_alpha=0.5) hwy_glyph = Circle(x="index", y="hwy", fill_color="#CE603D", size=8, fill_alpha=0.5, line_alpha=0.5) cty = plot.add_glyph(self.source, cty_glyph) hwy = plot.add_glyph(self.source, hwy_glyph) # Add the tools tooltips = [ ("Manufacturer", "@manufacturer"), ("Model", "@model"), ("Displacement", "@displ"), ("Year", "@year"), ("Cylinders", "@cyl"), ("Transmission", "@trans"), ("Drive", "@drv"), ("Class", "@class"), ] cty_hover_tool = HoverTool(renderers=[cty], tooltips=tooltips + [("City MPG", "@cty")]) hwy_hover_tool = HoverTool(renderers=[hwy], tooltips=tooltips + [("Highway MPG", "@hwy")]) select_tool = BoxSelectTool(renderers=[cty, hwy], dimensions=['width']) plot.add_tools(cty_hover_tool, hwy_hover_tool, select_tool) controls = VBox(children=[ manufacturer_select, model_select, transmission_select, drive_select, class_select ]) top_panel = HBox(children=[controls, plot]) layout = VBox(children=[top_panel, data_table]) return layout
def scan_pix_hist(h5_file_name, scurve_sel_pix = 200): with tb.open_file(h5_file_name, 'r') as in_file_h5: meta_data = in_file_h5.root.meta_data[:] hit_data = in_file_h5.root.hit_data[:] scan_args = yaml.load(in_file_h5.root.meta_data.attrs.kwargs) scan_range = scan_args['scan_range'] scan_range_inx = np.arange(scan_range[0], scan_range[1], scan_range[2]) repeat_command = scan_args['repeat_command'] np.set_printoptions(threshold=np.nan) k = 5 param = np.unique(meta_data['scan_param_id']) ret = [] for i in param: wh = np.where(hit_data['scan_param_id'] == i) #this can be faster and multi threaded hd = hit_data[wh[0]] hits = hd['col'].astype(np.uint16) hits = hits * 64 hits = hits + hd['row'] value = np.bincount(hits) value = np.pad(value, (0, 64*64 - value.shape[0]), 'constant') if len(ret): ret = np.vstack((ret, value)) else: ret = value s_hist = np.swapaxes(ret,0,1) indices = np.indices(s_hist.shape) param_inx = np.ravel(indices[1].astype(np.float64))#*0.05 - 0.6) param_inx_string = param_inx.astype('|S5') pix_scan_hist = np.empty((s_hist.shape[1],repeat_command + 10)) for param in range(s_hist.shape[1]): h_count = np.bincount(s_hist[:,param]) h_count = h_count[:repeat_command+10] pix_scan_hist[param] = np.pad(h_count, (0, (repeat_command + 10) - h_count.shape[0]), 'constant') log_hist = np.log10(pix_scan_hist) log_hist[~np.isfinite(log_hist)] = 0 data = { 'scan_param': np.ravel(np.indices(pix_scan_hist.shape)[0]), 'count': np.ravel(np.indices(pix_scan_hist.shape)[1]), 'value': np.ravel(log_hist) } hm1 = HeatMap(data, x='scan_param', y='count', values='value', title='s-scans', palette=Spectral11[::-1], stat=None, plot_width=1000) #, height=4100) mean = np.empty(64*64) noise = np.empty(64*64) x = scan_range_inx for pix in range (64*64): mu, sigma = analysis.fit_scurve(s_hist[pix], x) #this can multi threaded mean[pix] = mu noise[pix] = sigma px = scurve_sel_pix #1110 #1539 single_scan = figure(title="Single pixel scan " + str(px) ) single_scan.diamond(x=x, y=s_hist[px], size=5, color="#1C9099", line_width=2) yf = analysis.scurve(x, 100, mean[px], noise[px]) single_scan.cross(x=x, y=yf, size=5, color="#E6550D", line_width=2) mean[mean > scan_range_inx[-1]] = 0 hist, edges = np.histogram(mean, density=True, bins=50) #print "sigma:",noise hm_th = figure(title="Threshold", x_axis_label = "pixel #", y_axis_label = "threshold [V]", y_range=(scan_range_inx[0], scan_range_inx[-1]), plot_width=1000) hm_th.diamond(y=mean, x=range(64*64), size=1, color="#1C9099", line_width=2) hm_th.extra_y_ranges = {"e": Range1d(start=scan_range_inx[0]*1000*7.6, end=scan_range_inx[-1]*1000*7.6)} hm_th.add_layout(LinearAxis(y_range_name="e"), 'right') barray = fit_gauss(edges[2:], hist[1:]) plt_th_dist = figure(title= 'Threshold Distribution ' + '\sigma = ' + str(round(barray[2],4)) + ' \mu =' + str(round(barray[1],4)), x_axis_label = "threshold [V]", y_range=(0, 1.1*np.max(hist[1:]))) plt_th_dist.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], fill_color="#036564", line_color="#033649",) plt_th_dist.extra_x_ranges = {"e": Range1d(start=edges[0]*1000*7.6, end=edges[-1]*1000*7.6)} plt_th_dist.add_layout(LinearAxis(x_range_name="e"), 'above') plt_th_dist.line(np.arange(edges[1], edges[50], 0.0001), gauss(np.arange(edges[1], edges[50], 0.0001), barray[0], barray[1], barray[2]), line_color="#D95B43", line_width=8, alpha=0.7) noise[noise > 0.02] = 0.02 #this should be done based on 6sigma? hist, edges = np.histogram(noise, density=True, bins=50) hm_noise = figure(title="Noise", x_axis_label = "pixel #", y_axis_label = "noise [V]", y_range=(0, edges[-1]), plot_width=1000) hm_noise.diamond(y=noise, x=range(64*64), size=2, color="#1C9099", line_width=2) hm_noise.extra_y_ranges = {"e": Range1d(start=0, end=edges[-1]*1000*7.6)} hm_noise.add_layout(LinearAxis(y_range_name="e"), 'right') gauss_params_noise = fit_gauss(edges[5:], hist[4:]) plt_noise_dist = figure(title='Noise Distribution ' + '\sigma = ' + str(round(gauss_params_noise[2],4)) + ' \mu = ' + str(round(gauss_params_noise[1],4)) , x_axis_label = "noise [V]", y_range=(0, 1.1*np.max(hist[1:]))) plt_noise_dist.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], fill_color="#036564", line_color="#033649",) plt_noise_dist.extra_x_ranges = {"e": Range1d(start=edges[0]*1000*7.6, end=edges[-1]*1000*7.6)} plt_noise_dist.add_layout(LinearAxis(x_range_name="e"), 'above') plt_noise_dist.line(np.arange(edges[1],edges[50],0.0001),gauss(np.arange(edges[1],edges[50],0.0001),gauss_params_noise[0],gauss_params_noise[1],gauss_params_noise[2]),line_color="#D95B43", line_width=8, alpha=0.7) return vplot(hplot(hm_th, plt_th_dist), hplot(hm_noise,plt_noise_dist), hplot(hm1, single_scan) ), s_hist
else: p.y_range = Range1d( 0, np.float(Exp_Des[axis_scale][Test_Name])) p.yaxis.axis_label = y_label # Set axis options, legend, tickmarks, etc. # Secondary y-axis parameters if secondary_axis_label: if axis_scale == 'Y Scale BDP': p.extra_y_ranges = { secondary_axis_label: Range1d(-secondary_axis_scale, secondary_axis_scale) } p.add_layout( LinearAxis(y_range_name=secondary_axis_label, axis_label=secondary_axis_label), 'right') elif axis_scale == 'Y Scale Temperature': p.extra_y_ranges = { secondary_axis_label: Range1d(-17.78, secondary_axis_scale) } p.add_layout( LinearAxis(y_range_name=secondary_axis_label, axis_label=secondary_axis_label), 'right') else: p.extra_y_ranges = { secondary_axis_label: Range1d(0, secondary_axis_scale) } p.add_layout( LinearAxis(y_range_name=secondary_axis_label, axis_label=secondary_axis_label), 'right')
def make( self, comp_category='deaths_new_dma_per_1M', regions=None, comp_type='vbar', overlay=None, title='', legend_title='Region: Start Date', palette_base=Viridis256, palette_flip=False, palette_shift=0, multiline_labels=True, label_offsets={}, fs_labels=8, legend=False, legend_location='top_right', x_fontsize=10, y_fontsize=10, fs_xticks=16, fs_yticks=16, fs_overlay=10, fs_legend=8, h_legend=20, w_legend=20, width=750, height=500, base_inc=.25, save_file=False, filename=None, annotations=[], bg_color='white', bg_alpha=1, border_color='white', border_alpha=1, ): self.df_comp = self.df[self.df[comp_category].notna()].copy(deep=True) # If regions are passed, filter the dataframe and reset attributes # via `_chart_setup` if regions: regions = [regions] if isinstance(regions, str) else regions self.df_comp = self.df_comp[self.df_comp['region_name'].isin(regions)] else: regions = list(self.regions) # Setup additional class attributes self.comp_category = comp_category self.comp_type = comp_type self.palette_base = palette_base self.base_inc = base_inc self.max_length = self.df.groupby('region_id')['days'].max().max().days + 1 self.days = [i for i in range(self.max_length)] # Set chart attributes fs_labels = str(fs_labels) + 'pt' min_y = self.df_comp[comp_category].min() min_y += min_y * .01 max_y = self.df_comp[comp_category].max() if max_y < 0: max_y -= max_y * .1 else: max_y += max_y * .1 p = figure( y_range=Range1d(start=min_y, end=max_y), plot_height=height, plot_width=width, min_border=0, toolbar_location=None, title=title, ) # Create the Color Palette # An extra color is added and changes in the coloridx are limited # to all but the last item, to allow for shifting of palette # via palette_shift palette_base = np.array(palette_base) coloridx = np.round(np.linspace(0, len(palette_base) - 1, len(regions) + 1)).astype(int) if palette_flip: coloridx[:-1] = coloridx[:-1][::-1] if palette_shift: coloridx[:-1] += palette_shift palette = palette_base[coloridx] if comp_type == 'multiline': ml_data = self._multiline_source() ml_data['color'] = palette[:-1] source_ml = ColumnDataSource(ml_data) p.multi_line(xs='x', ys='y', line_color='color', legend_group='regions', line_width=5, source=source_ml) # Setup labels for each line if multiline_labels: for i in range(len(ml_data['x'])): x_label = int(ml_data['x'][i][-1]) y_label = ml_data['y'][i][-1] x_offset = -20 y_offset = 5 label_region = ml_data['regions'][i] if label_region in label_offsets.keys(): x_offset += label_offsets[label_region]['x_offset'] y_offset += label_offsets[label_region]['y_offset'] label = Label( x=x_label, y=y_label, x_offset=x_offset, y_offset=y_offset, text_font_size=fs_labels, text_color=palette[i], text_alpha=.8, text=label_region, text_font_style='bold', render_mode='canvas' ) p.add_layout(label) if comp_type == 'vbar': vbar_data = self._vbar_source() vbar_source = ColumnDataSource(vbar_data) increments = self._bar_incrementer(regions) legend_items = [] for i, region in enumerate(regions): region_start = vbar_data['{}_date'.format(region)][0] legend_label = region + ': {}'.format(region_start) v = p.vbar( x=dodge('x', increments[i], range=p.x_range), top=region, width=.3, source=vbar_source, color=palette[i], legend_label=legend_label, ) p.legend.visible = legend if legend_title: p.legend.title = 'Region: Start Date' p.legend.location = legend_location p.legend.border_line_color = 'black' p.legend.glyph_height = h_legend p.legend.glyph_width = w_legend p.legend.label_height = h_legend p.legend.label_width = h_legend p.legend.label_text_font_size = str(fs_legend) + 'pt' p.legend.background_fill_alpha = 0.0 p.legend.border_line_alpha = 0.0 p.xaxis.axis_label = self.labels['days_' + self.start_factor] p.xaxis.axis_label_text_font_size = str(x_fontsize) + 'pt' p.xaxis.major_label_text_font_size = str(fs_xticks) + 'pt' p.yaxis.axis_label = self.labels[comp_category] p.yaxis.axis_label_text_font_size = str(y_fontsize) + 'pt' p.yaxis.major_label_text_font_size = str(fs_yticks) + 'pt' p.xaxis.major_tick_line_color = None p.xgrid.grid_line_color = None p.min_border = 20 if overlay: overlay_days = [] overlay_by_region = [] for region_id, df_group in self.df_comp.groupby('region_id'): overlays = list(df_group[overlay].dropna().values) overlay_days.append([i for i in range(len(overlays))]) overlay_by_region.append(overlays) data2 = {'x': overlay_days, 'y': overlay_by_region, 'color': palette[:-1]} source2 = ColumnDataSource(data=data2) start = min(olay for region in overlay_by_region for olay in region) * 0.8 end = max(olay for region in overlay_by_region for olay in region) * 1.1 p.extra_y_ranges = {overlay: Range1d(start=start, end=end)} p.multi_line(xs='x', ys='y', line_color='color', line_width=4, source=source2, y_range_name=overlay, alpha=.3, ) right_axis_label = self.labels[overlay] p.add_layout(LinearAxis(y_range_name='{}'.format(overlay), axis_label=right_axis_label, axis_label_text_font_size=str(fs_overlay) + 'pt'), 'right') p.xgrid.grid_line_color = None p.ygrid.grid_line_color = None p.outline_line_color = border_color p.background_fill_color = bg_color p.background_fill_alpha = bg_alpha p.border_fill_color = border_color p.border_fill_alpha = border_alpha for annot in annotations: p.add_layout(Label(**annot)) if save_file: export_png(p, filename=filename) return p
def members_per_month(request: HttpRequest): members_per_month = FeeEntry.objects.values('month').order_by('month')\ .annotate(count=Count('month')) df_members = pandas.DataFrame.from_dict(members_per_month) df_members['month'] = df_members['month'].map( lambda m: m.strftime('%Y-%m')) df_members['count_text'] = df_members['count'].map( lambda p: '{:.0f}'.format(p)) df_members = df_members.iloc[1:-1] member_fees = FeeEntry.objects.values('month').order_by('month') \ .annotate(fee=Avg('fee')) df_fees = pandas.DataFrame.from_dict(member_fees) df_fees['month'] = df_fees['month'].map(lambda m: m.strftime('%Y-%m')) df_fees['fee_text'] = df_fees['fee'].map(lambda p: '{:.0f}'.format(p)) p1: Figure = figure(title="Member pro Monat", x_range=df_members['month'], tooltips=[("Monat", "@month"), ("Anzahl", "@count")], plot_height=300) p1.sizing_mode = 'scale_width' p1.step(x='month', color='navy', line_width=3, source=df_members, y='count', legend="Count of Members (paid fees)") p1.extra_y_ranges = { "fee_range": Range1d(start=0, end=df_fees['fee'].astype(float).max() + 5) } p1.add_layout(LinearAxis(y_range_name="fee_range"), 'right') p1.step(x='month', y='fee', color='firebrick', source=df_fees, line_width=2, y_range_name="fee_range", legend="Average Fee per member") labels = LabelSet(x='month', y='fee', text='fee_text', level='glyph', x_offset=-10, y_offset=10, source=ColumnDataSource(df_fees), text_font_size="9pt", y_range_name="fee_range") p1.add_layout(labels) labels = LabelSet(x='month', y='count', text='count_text', level='glyph', x_offset=-15, y_offset=10, source=ColumnDataSource(df_members), text_font_size="9pt") p1.add_layout(labels) p1.y_range.start = 0 p1.y_range.end = df_members['count'].max() + 4 p1.x_range.range_padding = 0.1 p1.xaxis.axis_label = "Monat" p1.xaxis.major_label_orientation = 1.2 #p1.outline_line_color = None p1.legend.location = 'bottom_right' html = embed.file_html(p1, resources.CDN, "Member pro Monat") return render(request, 'graph.html', {'html': mark_safe(html)})
plot2 = figure(y_range=(-3, 3), x_range=(0, 3), plot_width=400, plot_height=400, x_axis_type=None, y_axis_label='y_i value') plot2.line(x='xs', y='ys', source=source4) plot2.scatter('xs', 'ys', color='colors', source=source4, line_width=3, line_alpha=0.6) ticker = SingleIntervalTicker(interval=1, num_minor_ticks=0) xaxis = LinearAxis(ticker=ticker, axis_label='y index') plot2.add_layout(xaxis, 'below') resample_Button = Button(label="Resample") covariance_slider = Slider(start=0.0, end=.99, value=0, step=.01, title="Covariance") x1_slider = Slider(start=-2.5, end=2.5, value=0, step=.1, title="y1") resample_Button.on_click(lambda: resample_wrapper()) covariance_slider.on_change('value', lambda attr, old, new: update_all()) x1_slider.on_change('value', lambda attr, old, new: update_xs()) controls = [covariance_slider, x1_slider, resample_Button]
def generate_sentiment_ts_plot(sentiment_ts_data, sentiment_ts_sample_count): tooltips = [ ("Date", "@date{%F}"), ("Mentions", "@Count"), ("Nett Sentiment (7 day mean)", "@NettSentiment{0.0%}"), ] line_plot = figure(title=None, width=None, height=None, sizing_mode="scale_both", x_range=(sentiment_ts_data["date"].min(), sentiment_ts_data["date"].max()), x_axis_type='datetime', y_axis_label="Nett Sentiment (7 day mean)", tools=[], toolbar_location=None) # Setting range of y range line_plot.y_range = Range1d(-1, 1) # Adding Count range on the right line_plot.extra_y_ranges = { "count_range": Range1d(start=0, end=sentiment_ts_sample_count.max() * 1.1) } secondary_axis = LinearAxis(y_range_name="count_range", axis_label="Mentions") line_plot.add_layout(secondary_axis, 'right') sentiment_count_bars = line_plot.vbar(x="date", top="Count", width=pandas.Timedelta(days=0.75), color="orange", source=sentiment_ts_data, y_range_name="count_range") sentiment_line = line_plot.line(x="date", y="NettSentiment", color="blue", source=sentiment_ts_data, line_width=5) # Long Term sentiment baseline long_term_sentiment_span = Span( location=LONG_TERM_SENTIMENT, name="LongTermSentiment", dimension='width', line_color='red', line_dash='dashed', line_width=3, ) line_plot.add_layout(long_term_sentiment_span) start_timestamp = sentiment_ts_data["date"].min() long_term_sentiment_label = Label(x=start_timestamp, y=LONG_TERM_SENTIMENT, x_offset=-10, y_offset=10, text='Sentiment Baseline', render_mode='css', border_line_color='white', border_line_alpha=0.0, angle=0, angle_units='deg', background_fill_color='white', background_fill_alpha=0.0, text_color='red', text_font_size='12pt') line_plot.add_layout(long_term_sentiment_label) hover_tool = HoverTool(renderers=[sentiment_line, sentiment_count_bars], tooltips=tooltips, formatters={ '@date': 'datetime', 'NettSentiment': 'printf' }) line_plot.add_tools(hover_tool) line_plot.xaxis.formatter = DatetimeTickFormatter(days="%Y-%m-%d") line_plot.yaxis.formatter = NumeralTickFormatter(format="0.[0]%") secondary_axis.formatter = NumeralTickFormatter(format="0.[0] a") line_plot.axis.axis_label_text_font_size = "12pt" line_plot.axis.major_label_text_font_size = "12pt" plot_html = file_html(line_plot, CDN, "Behavioural Sentiment Timeseries") return plot_html