def gen_bokeh_plot(): # retrieve current active symbol and data source data_source = DATA_STORE['data_source'] title_source = DATA_STORE['title_source'] # calculate mean absolute deviation (MAD) title = Title(text='Predicted vs Actual Market Open Price') plot = Plot(title=title, plot_width=1200, plot_height=800, h_symmetry=False, v_symmetry=False, min_border=0, toolbar_location='right') val_glyph = Line(x='date', y='val_open', line_color='black', line_width=1.5) pred_glyph = Line(x='date', y='pred_open', line_color='blue', line_width=1.5, line_dash='dashed') plot.add_glyph(data_source, val_glyph) # renderer 0 plot.add_glyph(data_source, pred_glyph) # renderer 1 text_glyph = Text(x='x', y='y', text='text') plot.add_glyph(title_source, text_glyph) # Format plot li1 = LegendItem(label='actual', renderers=[plot.renderers[0]]) li2 = LegendItem(label='predicted', renderers=[plot.renderers[1]]) legend1 = Legend(items=[li1, li2], location='top_right') plot.add_layout(legend1) xaxis = DatetimeAxis() xaxis.formatter = DatetimeTickFormatter(years=['%Y'], months=['%m/%Y'], days=['%d/%m/%Y']) xaxis.major_label_orientation = np.pi / 4 plot.add_layout(xaxis, 'below') yaxis = LinearAxis() plot.add_layout(yaxis, 'left') return plot
def __init__(self,**kwargs): super(WeatherPlot,self).__init__(**kwargs) # def __init__(self, # data, # column_names=cs.column_names_weewx, # column_time=cs.time_column_name_weewx, # plot_height=300, # plot_width=800, # border_left=150, # **kwargs): # if "tool_events" not in kwargs: # kwargs["tool_events"] = ToolEvents() # super(WeatherPlot,self).__init__(x_range=DataRange1d(), # y_range=DataRange1d(), # plot_width=800, # plot_height=500, # min_border_left=150, # **kwargs) time_int = 3600 t_max = int(time.time()) t_min = t_max - 3600 * 24 data = sql_con.get_data_ws(time_int=time_int, t_max=t_max, t_min=t_min) self._data = data column_names=cs.column_names_weewx column_time=cs.time_column_name_weewx data_seconds = data data_seconds.iloc[:, 0] = data_seconds.iloc[:, 0] * 1000 add_glyphs_to_plot(column_names, column_time, data_seconds, self) self.add_layout(DatetimeAxis(), 'below') self.add_tools(PanTool(), WheelZoomTool(), ResizeTool(), CrosshairTool())
def make_plot(): xdr = DataRange1d() ydr = DataRange1d() plot = Plot(title="Product downloads", x_range=xdr, y_range=ydr, plot_width=400, plot_height=400) line = Line(x="dates", y="downloads", line_color="blue") plot.add_glyph(source, line) circle = Circle(x="dates", y="downloads", fill_color="red") plot.add_glyph(source, circle) xaxis = DatetimeAxis() 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(HoverTool(tooltips=dict(downloads="@downloads"))) return plot, source
def pages_queried_timeseries(df, plot_width=600, plot_height=200, rule='1T'): ts = df[['url']].resample(rule, how='count').cumsum() ts.index = ts.index.tz_convert(tzlocal()) #Bokeh=0.10.0 misencodes timestamps, so we have to shift by ts.index = ts.index.shift(ts.index[0].utcoffset().total_seconds(), freq="S") ts = pd.concat([ts[:1], ts]) # prepend 0-value for Line chart compat ts.iloc[0]['url'] = 0 formatter = DatetimeTickFormatter(formats=DATETIME_FORMAT) ticker = DatetimeTicker(desired_num_ticks=3) source = ColumnDataSource(ts) plot = Plot(plot_width=plot_width, plot_height=plot_height, x_range=DataRange1d(range_padding=0.1), y_range=DataRange1d(start=0), **PLOT_FORMATS) plot.add_glyph( source, Line(x='retrieved', y='url', **LINE_FORMATS) ) plot.add_layout( DatetimeAxis(axis_label="Date Retrieved", formatter=formatter, ticker=ticker, **AXIS_FORMATS), 'below') plot.add_layout(LinearAxis(axis_label="Total Pages", **AXIS_FORMATS), 'left') return plot
def plot_choiceset_links(linkfile_df,cost="sim_cost",paths=False): linkfile_df["color"]= map(assignColorByMode, linkfile_df["mode"]) if paths: linkfile_df["annotation"]= map(createLinkPathAnnotation, linkfile_df["mode"], linkfile_df[cost], linkfile_df["route_id"], linkfile_df["trip_id"], linkfile_df["probability"]) else: linkfile_df["annotation"]=map(createLinkAnnotation, linkfile_df["mode"], linkfile_df[cost], linkfile_df["route_id"], linkfile_df["trip_id"]) linkfile_df["yloc"]= map(yloc, linkfile_df["pathnum"],linkfile_df["linknum"]) pathnums = list(set(list(linkfile_df["pathnum"]))) plots = {} for p in pathnums: data_df = linkfile_df[linkfile_df["pathnum"]==p] linksource = ColumnDataSource(data_df) xdr2 = DataRange1d() ydr2 = DataRange1d() plots[p] = Plot( title="Path Number: %d Probability: %4.2f Percent" % (p,100*data_df["probability"].max()), x_range=xdr2, y_range=ydr2, plot_width=800, plot_height=150, h_symmetry=False, v_symmetry=False, min_border=0, toolbar_location=None) glyph = Segment(y0="yloc", x0="new_A_time", y1="yloc", x1="new_B_time", line_color="color", line_width=cost) plots[p].add_glyph(linksource, glyph) choicexaxis = DatetimeAxis() plots[p].add_layout(choicexaxis, 'below') xaxis = DatetimeAxis() yaxis = LinearAxis() plots[p].add_layout(Grid(dimension=0, ticker=xaxis.ticker)) plots[p].add_layout(Grid(dimension=1, ticker=yaxis.ticker)) choice_labels = LabelSet(x="new_A_time", y="yloc", text="annotation", y_offset=-5,x_offset=10, text_font_size="8pt", text_color="#555555", source=linksource, text_align='left') plots[p].add_layout(choice_labels) return plots.values()
def plot_choice_links(linkfile_df,cost="sim_cost",paths=False): linkfile_df["color"]= map(assignColorByMode, linkfile_df["mode"]) if paths: linkfile_df["annotation"]= map(createLinkPathAnnotation, linkfile_df["mode"], linkfile_df[cost], linkfile_df["route_id"], linkfile_df["trip_id"], linkfile_df["probability"]) else: linkfile_df["annotation"]=map(createLinkAnnotation, linkfile_df["mode"], linkfile_df[cost], linkfile_df["route_id"], linkfile_df["trip_id"]) linkfile_df["yloc"]= map(yloc, linkfile_df["pathnum"],linkfile_df["linknum"]) linksource = ColumnDataSource(linkfile_df) #linkfile_df xdr2 = DataRange1d() ydr2 = DataRange1d() choiceplot = Plot( title=None, x_range=xdr2, y_range=ydr2, plot_width=800, plot_height=300, h_symmetry=False, v_symmetry=False, min_border=0, toolbar_location=None) glyph = Segment(y0="yloc", x0="new_A_time", y1="yloc", x1="new_B_time", line_color="color", line_width=cost) choiceplot.add_glyph(linksource, glyph) choicexaxis = DatetimeAxis() choiceplot.add_layout(choicexaxis, 'below') xaxis = DatetimeAxis() yaxis = LinearAxis() choiceplot.add_layout(Grid(dimension=0, ticker=xaxis.ticker)) choiceplot.add_layout(Grid(dimension=1, ticker=yaxis.ticker)) choice_labels = LabelSet(x="new_A_time", y="yloc", text="annotation", y_offset=-5,x_offset=10, text_font_size="8pt", text_color="#555555", source=linksource, text_align='left') choiceplot.add_layout(choice_labels) return choiceplot
def get_weather_plot(time_int=None, t_min=None, t_max=None): plot_height = cs.plot_height plot_width = cs.plot_width border_left = cs.border_left column_names = cs.column_names_weewx column_time = cs.time_column_name_weewx if t_max == None or t_min == None: t_max, t_min = get_first_time_interval() t_span = t_max - t_min if time_int == None: time_int = cs.time_int data_seconds = sql_con.get_data_ws(time_int=time_int, t_min=t_min, t_max=t_max) data_seconds.iloc[:, 0] = data_seconds.iloc[:, 0] * 1000 plot = Plot( x_range=DataRange1d(start=(t_min - t_span * .1) * 1000, end=(t_max + t_span * .1) * 1000), y_range=DataRange1d(), plot_width=plot_width, plot_height=plot_height, # x_axis_type="datetime", min_border_left=border_left, toolbar_location="right") add_glyphs_to_plot(column_names, column_time, data_seconds, plot, 'source_weather') plot.add_layout(DatetimeAxis(name="date_time_axis"), 'below') plot.add_tools( PanTool(), WheelZoomTool(), # ResizeTool(), CrosshairTool(), PreviewSaveTool()) Grid(plot=plot, dimension=0, ticker=plot.select('date_time_axis')[0].ticker) Grid(plot=plot, dimension=1, ticker=plot.select(type=LinearAxis, name=column_names[0])[0].ticker) set_legends(plot) plot.title = cs.plot_title_weewx + ' averaged to {} seconds'.format( time_int) return plot
def make_axis(self, dim, location, scale, label): """Create linear, date or categorical axis depending on the location, scale and with the proper labels. Args: location(str): the space localization of the axis. It can be ``left``, ``right``, ``above`` or ``below``. scale (str): the scale on the axis. It can be ``linear``, ``datetime`` or ``categorical``. label (str): the label on the axis. Return: Axis: Axis instance """ # ToDo: revisit how to handle multiple ranges # set the last range to the chart's range if len(self._ranges[dim]) == 0: raise ValueError('Ranges must be added to derive axis type.') data_range = self._ranges[dim][-1] setattr(self, dim + '_range', data_range) if scale == "auto": if isinstance(data_range, FactorRange): scale = 'categorical' else: scale = 'linear' if scale == "linear": axis = LinearAxis(axis_label=label) elif scale == "datetime": axis = DatetimeAxis(axis_label=label) elif scale == "categorical": axis = CategoricalAxis( major_label_orientation=np.pi / 4, axis_label=label ) else: axis = LinearAxis(axis_label=label) self.add_layout(axis, location) return axis
def large_plot(): source = ColumnDataSource(data=dict(x=[0, 1], y=[0, 1])) xdr = Range1d(start=0, end=1) xdr.tags.append("foo") xdr.tags.append("bar") ydr = Range1d(start=10, end=20) ydr.tags.append("foo") ydr.tags.append(11) plot = Plot(x_range=xdr, y_range=ydr) ydr2 = Range1d(start=0, end=100) plot.extra_y_ranges = {"liny": ydr2} circle = Circle(x="x", y="y", fill_color="red", size=5, line_color="black") plot.add_glyph(source, circle, name="mycircle") line = Line(x="x", y="y") plot.add_glyph(source, line, name="myline") rect = Rect(x="x", y="y", width=1, height=1, fill_color="green") plot.add_glyph(source, rect, name="myrect") plot.add_layout(DatetimeAxis(), 'below') plot.add_layout(LogAxis(), 'left') plot.add_layout(LinearAxis(y_range_name="liny"), 'left') plot.add_layout(Grid(dimension=0), 'left') plot.add_layout(Grid(dimension=1), 'left') plot.add_tools( BoxZoomTool(), PanTool(), SaveTool(), ResetTool(), ResizeTool(), WheelZoomTool(), ) return plot
def _make_base_plot(dfs, activities, x_range, plot_width=900): plot = Plot( x_range=x_range, y_range=Range1d(0, 11), outline_line_color=None, background_fill=COLOR_PRIMARY, border_fill=COLOR_PRIMARY, plot_width=plot_width, plot_height=150, min_border_top=0, toolbar_location=None, ) yticker = BasicTicker(min_interval=3) close_ticker = DatetimeTicker(desired_num_ticks=8) close_ticks = DatetimeTickFormatter( formats={ 'years': ["%b"], 'months': ["%b"], 'days': ["%a %d %b"], 'hours': ["%I%p %d %b"] } ) plot.add_layout(LinearAxis(ticker=yticker, **AXIS_PROPERTIES), 'left') plot.add_layout(DatetimeAxis(formatter=close_ticks, ticker=close_ticker, **AXIS_PROPERTIES), 'below') plot.add_layout(Grid(dimension=1, ticker=yticker, grid_line_alpha=0.3)) palette = get_palette(activities) for i, activity in enumerate(activities): source = dfs[activity] line = Line( line_color=palette[i], line_join='round', line_cap='round', line_width=5, line_alpha=0.75, x='timestamp', y='cumsum_hrs' ) plot.add_glyph(source, line) return plot
def get_ws_plot(data, plot_height=300, plot_width=800, column_names=cs.column_names_weewx, column_time=cs.time_column_name_weewx, border_left=200): data_seconds = data data_seconds.iloc[:, 0] = data_seconds.iloc[:, 0] * 1000 plot = Plot(x_range=DataRange1d(), y_range=DataRange1d(), plot_width=plot_width, plot_height=plot_height, min_border_left=border_left, **kwargs) add_glyphs_to_plot(column_names, column_time, data_seconds, plot) plot.add_layout(DatetimeAxis(), 'below') plot.add_tools(PanTool(), WheelZoomTool(), ResizeTool(), CrosshairTool()) return plot
def __init__(self, face_cascade): self.face_cascade = face_cascade self.t0 = time.mktime(dt.now().timetuple()) * 1000 ### Image Plot self.image_source = ColumnDataSource({"image": []}) self.rect_source = ColumnDataSource({ "x": [], "y": [], "w": [], "h": [] }) self.image_plot = Plot(name="image", width=CAMERA_WIDTH // 2, height=CAMERA_HEIGHT // 2, x_range=Range1d(0, CAMERA_WIDTH), y_range=Range1d(0, CAMERA_HEIGHT)) self.image_plot.add_glyph( self.image_source, Image(image='image', x=0, y=0, dw=CAMERA_WIDTH, dh=CAMERA_HEIGHT)) self.image_plot.add_glyph(self.rect_source, Rect(x='x', y='y', width='w', height='h')) ### Timeseries Plot self.ts_source = ColumnDataSource({"x": [], "y": []}) self.ts_plot = Plot(name="ts", x_range=DataRange1d(), y_range=DataRange1d(), width=CAMERA_WIDTH // 2, height=150) self.ts_plot.add_layout(DatetimeAxis(axis_label="time"), "below") self.ts_plot.add_layout( LinearAxis(axis_label="num faces", ticker=SITicker()), "left") self.ts_plot.add_glyph(self.ts_source, Step(x="x", y="y"))
def la_rate_plot(data, names, region, rolling_days=7): data = (data["cases_norm"].resample(date="1D").nearest( tolerance="1D").ffill("date").fillna(0).diff("date")[:, :-4].rolling( date=rolling_days, center=True).sum().dropna("date")) palette = [ (0, "#f1f1f1"), (5, "#fef0d9"), (10, "#fdd49e"), (25, "#fdbb84"), (50, "#fc8d59"), (100, "#e34a33"), (100000, "#b30000"), ] def colour_val(cases): for threshold, colour in palette: if cases <= threshold: return colour return palette[-1][1] colours = [] y_range = [] yname = [] xname = [] for la in names.index: if la not in data["gss_code"]: continue name = names[la] y_range.append(name) xname += list(data["date"].values) for val in data.sel(gss_code=la).values * 100000 * (7 / rolling_days): yname.append(name) colours.append(colour_val(val)) x_range = [data["date"].min().values, data["date"].max().values] height = len(y_range) * 12 + 100 fig = bokeh_figure( y_range=y_range, x_range=x_range, width=1200, height=height, title=region, sizing_mode="scale_width", tools="", toolbar_location=None, ) data_source = {"y": yname, "x": xname, "colours": colours} fig.rect( "x", "y", 1.01 * (60 * 60 * 24 * 1000), 0.85, source=data_source, color="colours", line_color=None, dilate=True, ) fig.axis.axis_line_color = None fig.grid.grid_line_color = None fig.yaxis.major_tick_line_color = None fig.add_layout(DatetimeAxis(), "above") fig.xaxis.formatter = DatetimeTickFormatter(days="%d %b", months="%d %b") return fig
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]
def create_bk_fig(x=None, xlab=None, x_min=None, x_max=None, ylab=None, fh=None, fw=None, title=None, pw=None, ph=None, x_axis_type="linear", y_axis_type="linear", x_name=None, y_name=None, **kwargs): """ Generates a bokeh figure Parameters ---------- x :obj:`DataArray` Contains x-axis data xlab : :obj:`str` X-axis label x_min : :obj:`float` Min x value x_max : :obj:`float` Max x value ylab : :obj:`str` Y-axis label fh: :obj:`int` True height of figure without legends, axes titles etc fw: :obj:`int` True width of figure without legends, axes etc title: :obj:`str` Title of plot pw: :obj:`int` Plot width including legends, axes etc ph: :obj:`int` Plot height including legends, axes etc x_axis_type: :obj:`str` Type of x-axis can be linear, log, or datetime y_axis_type: :obj:`str` Can be linear, log or datetime x_name: :obj:`str` Name of the column used for the x-axis. Mostly used to form tooltips y_name: :obj:`str` Name of the column used for the y-axis. Also used for tooltips add_grid: :obj:`bool` Whether or not to add grid add_title: :obj:`bool` Whether or not to add title to plot add_xaxis: :obj:`bool` Whether or not to add x-axis and tick marks add_yaxis: :obj:`bool` Add y-axis or not fix_plotsize: :obj:`bool` Enforce certain dimensions on plot. This is useful for ensuring a plot is not obscure by axes and other things. If activated, plot's dimensions will not be responsive. It utilises fw and fh. Returns ------- p : :obj:`Plot` A bokeh Plot object """ add_grid = kwargs.pop("add_grid", False) add_title = kwargs.pop("add_title", True) add_xaxis = kwargs.pop("add_xaxis", False) add_yaxis = kwargs.pop("add_yaxis", False) fix_plotsize = kwargs.pop("fix_plotsize", True) # addition plot specs pl_specs = kwargs.pop("pl_specs", {}) # additional axis specs ax_specs = kwargs.pop("ax_specs", {}) # ticker specs ti_specs = kwargs.pop("ti_specs", {}) plot_specs = dict(background="white", border_fill_alpha=0.1, border_fill_color="white", min_border=3, name="plot", outline_line_dash="solid", outline_line_width=2, outline_line_color="#017afe", outline_line_alpha=0.4, output_backend="canvas", sizing_mode="stretch_width", title_location="above", toolbar_location="above") plot_specs.update(pl_specs) axis_specs = dict(minor_tick_line_alpha=0, axis_label_text_align="center", axis_label_text_font="monospace", axis_label_text_font_size="10px", axis_label_text_font_style="normal", major_label_orientation="horizontal") axis_specs.update(ax_specs) tick_specs = dict(desired_num_ticks=5) tick_specs.update(ti_specs) # Define frame width and height # This is the actual size of the plot without the titles et al if fix_plotsize and not(fh or fw): fw = int(0.98 * pw) fh = int(0.93 * ph) # define the axes ranges x_range = DataRange1d(name="p_x_range", only_visible=True) y_range = DataRange1d(name="p_y_range", only_visible=True) if x_min is not None and x_max is not None and x_name.lower() in ["channel", "frequency"]: x_range = Range1d(name="p_x_range", start=x_min, end=x_max) y_range.only_visible = False # define items to add on the plot p_htool = HoverTool(tooltips=[(x_name, "$x"), (y_name, "$y")], name="p_htool", point_policy="snap_to_data") if x_name.lower() == "time": p_htool.tooltips[0] = (x_name, "$x{%d-%m-%Y %H:%M}") p_htool.formatters = {"$x": "datetime"} p_toolbar = Toolbar(name="p_toolbar", tools=[p_htool, BoxSelectTool(), BoxZoomTool(), # EditTool(), # BoxEditTool(), # RangeTool(), LassoSelectTool(), PanTool(), ResetTool(), SaveTool(), UndoTool(), WheelZoomTool()]) p_ticker = BasicTicker(name="p_ticker", **tick_specs) # select the axis scales for x and y if x_axis_type == "linear": x_scale = LinearScale(name="p_x_scale") # define the axes and tickers p_x_axis = LinearAxis(axis_label=xlab, name="p_x_axis", ticker=p_ticker, **axis_specs) elif x_axis_type == "datetime": x_scale = LinearScale(name="p_x_scale") # define the axes and tickers p_x_axis = DatetimeAxis(axis_label=xlab, name="p_x_axis", ticker=p_ticker, **axis_specs) elif x_axis_type == "log": x_scale = LogScale(name="p_x_scale") p_x_axis = LogAxis(axis_label=xlab, name="p_x_axis", ticker=p_ticker, **axis_specs) if y_axis_type == "linear": y_scale = LinearScale(name="p_y_scale") # define the axes and tickers p_y_axis = LinearAxis(axis_label=ylab, name="p_y_axis", ticker=p_ticker, **axis_specs) elif x_axis_type == "datetime": y_scale = LinearScale(name="p_y_scale") # define the axes and tickers p_y_axis = DatetimeAxis(axis_label=xlab, name="p_y_axis", ticker=p_ticker, **axis_specs) elif y_axis_type == "log": y_scale = LogScale(name="p_y_scale") # define the axes and tickers p_y_axis = LogAxis(axis_label=ylab, name="p_y_axis", ticker=p_ticker, **axis_specs) # Create the plot object p = Plot(plot_width=pw, plot_height=ph, frame_height=fh, frame_width=fw, toolbar=p_toolbar, x_range=x_range, x_scale=x_scale, y_range=y_range, y_scale=y_scale, **plot_specs) if add_title: p_title = Title(align="center", name="p_title", text=title, text_font_size="24px", text_font="monospace", text_font_style="bold",) p.add_layout(p_title, "above") if add_xaxis: p.add_layout(p_x_axis, "below") if add_yaxis: p.add_layout(p_y_axis, "left") if add_grid: p_x_grid = Grid(dimension=0, ticker=p_ticker) p_y_grid = Grid(dimension=1, ticker=p_ticker) p.add_layout(p_x_grid) p.add_layout(p_y_grid) return p
y = sin(x) # Create an array of times, starting at the current time, and extending # for len(x) number of hours. times = np.arange(len(x)) * 3600000 + time.time() source = ColumnDataSource(data=dict(x=x, y=y, times=times)) xdr = DataRange1d(sources=[source.columns("times")]) ydr = DataRange1d(sources=[source.columns("y")]) plot = Plot(x_range=xdr, y_range=ydr, min_border=80) circle = Circle(x="times", y="y", fill_color="red", size=5, line_color="black") plot.add_glyph(source, circle) plot.add_layout(DatetimeAxis(), 'below') plot.add_layout(DatetimeAxis(), 'left') plot.add_tools(PanTool(), WheelZoomTool()) doc = Document() doc.add(plot) if __name__ == "__main__": filename = "dateaxis.html" with open(filename, "w") as f: f.write(file_html(doc, INLINE, "Date Axis Example")) print("Wrote %s" % filename) view(filename)
line_width=2, label=value("sunrise")) sunrise_line_renderer = plot.add_glyph(source, sunrise_line) sunset_line = Line(x="dates", y="sunsets", line_color="red", line_width=2, label=value("sunset")) sunset_line_renderer = plot.add_glyph(source, sunset_line) text = Text(x="dates", y="times", text="texts", text_align="center") plot.add_glyph(text_source, text) xformatter = DatetimeTickFormatter(months="%b %Y") xaxis = DatetimeAxis(formatter=xformatter) plot.add_layout(xaxis, 'below') yaxis = DatetimeAxis() plot.add_layout(yaxis, 'left') plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker)) plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker)) legend = Legend(legends=[sunrise_line_renderer, sunset_line_renderer]) plot.add_layout(legend) doc = Document() doc.add_root(plot) if __name__ == "__main__":
sunrise_line = Line(x="dates", y="sunrises", line_color="orange", line_width=4) sunrise_line_renderer = plot.add_glyph(source, sunrise_line) sunset_line = Line(x="dates", y="sunsets", line_color="crimson", line_width=4) sunset_line_renderer = plot.add_glyph(source, sunset_line) text = Text(x="dates", y="times", text="texts", text_align="center", text_color="grey") plot.add_glyph(text_source, text) xformatter = DatetimeTickFormatter(months="%b %d %Y") min_time = dt.datetime.min.time() xticker = FixedTicker(ticks=[ mktime(dt.datetime.combine(summer_start, min_time).timetuple()) * 1000, mktime(dt.datetime.combine(summer_end, min_time).timetuple()) * 1000 ]) xaxis = DatetimeAxis(formatter=xformatter, ticker=xticker) plot.add_layout(xaxis, 'below') yaxis = DatetimeAxis() yaxis.formatter.hours = ['%H:%M'] plot.add_layout(yaxis, 'left') legend = Legend(items=[ LegendItem(label=value('sunset'), renderers=[sunset_line_renderer]), LegendItem(label=value('sunrise'), renderers=[sunrise_line_renderer]), ]) plot.add_layout(legend) doc = Document() doc.add_root(plot)
def outlet_vis(df, forcing, out_name, scale=5, y_range=(0.008, 0.023), extra_y_range=0.14): df = df / scale # scale m³/5min to m³/min date = df.index.values color = itertools.cycle(palette['Category10'][10]) p = figure(plot_width=960, plot_height=600, x_range=(date[0], date[-1]), y_range=y_range, x_axis_type='datetime', x_axis_label='Date', y_axis_label='Catchment Outlet Discharge [m³/min]') legend_it = [] for i in range(0, df.shape[1]): if df.columns.values[i] == 'Original': pl = p.line(df.index.values, df.iloc[:, i], line_color='#666666', line_width=2) else: c = next(color) pl = p.line(df.index.values, df.iloc[:, i], line_color=c, line_width=2) legend_it.append((df.columns.values[i], [pl])) p.xaxis.major_label_text_font_size = "16pt" p.xaxis.axis_label_text_font_size = "16pt" p.yaxis.formatter = BasicTickFormatter(use_scientific=True, power_limit_low=1, power_limit_high=2, precision=1) df_forcing = pd.DataFrame(forcing[0:date.shape[0]], columns=['forcing']) df_forcing = df_forcing.set_index(date) df_forcing = df_forcing / scale # scale mm/5min to mm/min # Setting the second axis range name and range p.extra_y_ranges = {"foo": Range1d(start=extra_y_range, end=0.0)} p.extra_x_ranges = {"faa": Range1d(date[0], date[-1])} # Adding the second axis to the plot p.add_layout( LinearAxis(y_range_name="foo", axis_label="Rainfall [mm/min]"), 'right') p.add_layout( DatetimeAxis(x_range_name="faa", axis_label="", major_tick_line_color=None, major_label_text_font_size='0pt'), 'above') pl = p.vbar(x=df_forcing.index.values, top=df_forcing['forcing'], x_range_name='faa', y_range_name='foo', line_color='#00BFFF', fill_color='#00BFFF', width=240000) legend_it.append(('Rainfall', [pl])) legend_it = sorted(legend_it, key=itemgetter(0)) # turn off y-axis minor ticks p.yaxis.minor_tick_line_color = None legend = Legend(items=legend_it, location="center") p.add_layout(legend, 'above') p.legend.orientation = "horizontal" p.legend.label_text_font_size = "16pt" p.yaxis.major_label_text_font_size = "16pt" p.yaxis.axis_label_text_font_size = "16pt" p.xgrid.visible = False p.ygrid.visible = False p.output_backend = "svg" export_svgs(p, filename=out_name)
def get_plot(raw, today): dfs, cats = get_sources_and_categories(raw) # Some times first_day = raw.loc[0, 'timestamp'] one_week_ago = today - datetime.timedelta(weeks=1) two_weeks_ago = today - datetime.timedelta(weeks=2) one_week_forward = today + datetime.timedelta(weeks=1) # The ranges all_range = Range1d(start=first_day, end=today) month_range = Range1d(start=two_weeks_ago, end=one_week_forward) week_range = Range1d(start=one_week_ago, end=today) # Selection indicators highlight = Quad( left='start', right='end', bottom=0, top=12, fill_color='white', line_color=COLOR_PRIMARY_CONTRAST, fill_alpha=0.2, ) lowlight = Quad( left='start', right='end', bottom=0, top=12, fill_color=COLOR_PRIMARY, line_color=COLOR_PRIMARY_CONTRAST, fill_alpha=0.5, ) # Make the complete timeline plot all_plot = _make_base_plot(dfs, cats, all_range) detail_selection_source = ColumnDataSource({ 'start': [all_range.start, month_range.end], 'end': [month_range.start, all_range.end] }) all_plot.add_glyph(detail_selection_source, lowlight) # add a second axis to all_layout plot for presentation year_ticker = DatetimeTicker(desired_num_ticks=4) year_ticks = DatetimeTickFormatter( formats={ 'years': ["%Y"], 'months': ["%Y"], 'days': ["%Y"], 'hours': ["%Y"] } ) all_plot.add_layout( DatetimeAxis(formatter=year_ticks, ticker=year_ticker, **AXIS_PROPERTIES), 'below' ) # Make the detail plot detail_plot = _make_base_plot(dfs, cats, month_range) detail_plot.add_tools(PanTool(dimensions=['width'])) detail_plot.add_tools(WheelZoomTool(dimensions=['width'])) detail_plot.add_tools(ResetTool()) week_selection_source = ColumnDataSource({'start': [week_range.start], 'end': [week_range.end]}) detail_plot.add_glyph(week_selection_source, highlight) detail_code = """ // Update the month selection box on the all_data plot when month pans var detail_selection_data = detail_selection_source.get('data'); var detail_start = cb_obj.get('frame').get('x_range').get('start'); var detail_end = cb_obj.get('frame').get('x_range').get('end'); new_detail_selection = { 'start': [detail_selection_data['start'][0], detail_end], 'end': [detail_start, detail_selection_data['end'][1]] }; detail_selection_source.set('data', new_detail_selection); // Always make sure the week highlight box on detail is visible and centered var x = moment.duration(detail_end - detail_start).asWeeks() / 2.4; var start = moment(detail_start); var week_end = start.add(x, 'weeks').format('x'); $("#one_week_before").text(start.format('ddd, DD MMM YYYY')); var newStart = start.format('YYYY-MM-DD'); var week_start = start.add(6, 'days').format('x'); $("#today").text(start.format('ddd, DD MMM YYYY')); new_week_selection = { 'start': [week_start, ], 'end': [week_end, ] }; week_selection_source.set('data', new_week_selection); var url = '/timesheet/?start=' + newStart; $("#timesheet_submit").attr('href', url).addClass("mdl-button--colored"); """ detail_xrange_callback = CustomJS(args={}, code=detail_code) detail_xrange_callback.args['detail_selection_source'] = detail_selection_source detail_xrange_callback.args['week_selection_source'] = week_selection_source detail_plot.x_range.callback = detail_xrange_callback return all_plot, detail_plot
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=[], duration=[], key=[], name=[], color=[], worker=[], y=[], worker_thread=[], alpha=[])) 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 _setxaxis(self): xaxis1 = DatetimeAxis(major_label_text_font_size='0pt', formatter=dttf) xaxis1.visible = False self.fig.add_layout(xaxis1, 'above')
def __init__(self, nplots, plot_height=200, plot_width=1000, rollover=10800, mode="time"): """Initialize stream graph plots. Args: nplots (int): Number of stream plots that will share common controls. plot_height (int, optional): Height of plot area in screen pixels. Defaults to 200. plot_width (int, optional): Width of plot area in screen pixels. Defaults to 1000. rollover (int, optional): A maximum number of points, above which data from the start begins to be discarded. If None, then graph will grow unbounded. Defaults to 10800. mode (str, optional): stream update mode, 'time' - uses the local wall time, 'number' - uses a image number counter. Defaults to 'time'. """ self.rollover = rollover self.mode = mode self._stream_t = 0 self._buffers = [] self._window = 30 # Custom tick formatter for displaying large numbers tick_formatter = BasicTickFormatter(precision=1) # Stream graphs self.plots = [] self.glyphs = [] self._sources = [] for ind in range(nplots): # share x_range between plots if ind == 0: x_range = DataRange1d() plot = Plot( x_range=x_range, y_range=DataRange1d(), plot_height=plot_height, plot_width=plot_width, ) # ---- tools plot.toolbar.logo = None plot.add_tools(PanTool(), BoxZoomTool(), WheelZoomTool(dimensions="width"), ResetTool()) # ---- axes plot.add_layout(LinearAxis(formatter=tick_formatter), place="left") if mode == "time": plot.add_layout(DatetimeAxis(), place="below") elif mode == "number": plot.add_layout(LinearAxis(), place="below") else: pass # ---- grid lines plot.add_layout(Grid(dimension=0, ticker=BasicTicker())) plot.add_layout(Grid(dimension=1, ticker=BasicTicker())) # ---- line glyph source = ColumnDataSource(dict(x=[], y=[], x_avg=[], y_avg=[])) line = Line(x="x", y="y", line_color="gray") line_avg = Line(x="x_avg", y="y_avg", line_color="red") line_renderer = plot.add_glyph(source, line) line_avg_renderer = plot.add_glyph(source, line_avg) # ---- legend plot.add_layout( Legend( items=[("per frame", [line_renderer]), ("moving average", [line_avg_renderer])], location="top_left", )) plot.legend.click_policy = "hide" self.plots.append(plot) self.glyphs.append(line) self._sources.append(source) self._buffers.append(deque(maxlen=MAXLEN)) # Moving average spinner def moving_average_spinner_callback(_attr, _old_value, new_value): if moving_average_spinner.low <= new_value <= moving_average_spinner.high: self._window = new_value moving_average_spinner = Spinner(title="Moving Average Window:", value=self._window, low=1, high=MAXLEN, default_size=145) moving_average_spinner.on_change("value", moving_average_spinner_callback) self.moving_average_spinner = moving_average_spinner # Reset button def reset_button_callback(): # keep the latest point in order to prevent a full axis reset if mode == "time": pass # update with the lastest time elif mode == "number": self._stream_t = 1 for source in self._sources: if source.data["x"]: source.data.update( x=[self._stream_t], y=[source.data["y"][-1]], x_avg=[self._stream_t], y_avg=[source.data["y_avg"][-1]], ) reset_button = Button(label="Reset", button_type="default", default_size=145) reset_button.on_click(reset_button_callback) self.reset_button = reset_button