("line", Line(x="x", y="y", line_color="#F46D43")), ("multi_line", MultiLine(xs="xs", ys="ys", line_color="#8073AC", line_width=2)), ("oval", Oval(x="x", y="y", width=screen(15), height=screen(25), angle=-0.7, fill_color="#1D91C0")), ("patch", Patch(x="x", y="y", fill_color="#A6CEE3")), ("patches", Patches(xs="xs", ys="ys", fill_color="#FB9A99")), ("quad", Quad(left="x", right="xp01", top="y", bottom="ym01", fill_color="#B3DE69")), ("quadratic", Quadratic(x0="x", y0="y", x1="xp02", y1="y", cx="xp01", cy="yp01", line_color="#4DAF4A", line_width=3)), ("ray", Ray(x="x", y="y", length=45, angle=-0.7, line_color="#FB8072", line_width=2)), ("rect", Rect(x="x", y="y", width=screen(10), height=screen(20), angle=-0.7, fill_color="#CAB2D6")), ("segment", Segment(x0="x", y0="y", x1="xm01", y1="ym01", line_color="#F4A582", line_width=3)), ("text", Text(x="x", y="y", text=["hello"])), ("wedge", Wedge(x="x", y="y", radius=screen(15), start_angle=0.6, end_angle=4.1, fill_color="#B3DE69")), ] markers = [ ("circle", Circle(x="x", y="y", radius=0.1, fill_color="#3288BD")), ("circle_x", CircleX(x="x", y="y", size="sizes", line_color="#DD1C77", fill_color=None)), ("circle_cross", CircleCross(x="x", y="y", size="sizes", line_color="#FB8072", fill_color=None, line_width=2)), ("square", Square(x="x", y="y", size="sizes", fill_color="#74ADD1")), ("square_x", SquareX(x="x", y="y", size="sizes", line_color="#FDAE6B", fill_color=None, line_width=2)), ("square_cross", SquareCross(x="x", y="y", size="sizes", line_color="#7FC97F", fill_color=None, line_width=2)), ("diamond", Diamond(x="x", y="y", size="sizes", line_color="#1C9099", line_width=2)), ("diamond_cross", DiamondCross(x="x", y="y", size="sizes", line_color="#386CB0", fill_color=None, line_width=2)), ("triangle", Triangle(x="x", y="y", size="sizes", line_color="#99D594", line_width=2)), ("inverted_triangle", InvertedTriangle(x="x", y="y", size="sizes", line_color="#DE2D26", line_width=2)), ("cross", Cross(x="x", y="y", size="sizes", line_color="#E6550D", fill_color=None, line_width=2)), ("asterisk", Asterisk(x="x", y="y", size="sizes", line_color="#F0027F", fill_color=None, line_width=2)), ("x", X(x="x", y="y", size="sizes", line_color="thistle", fill_color=None, line_width=2)), ] def make_tab(title, glyph):
# function call to base map if __name__ == '__main__': df = mercator_df() fig = nyc_map('Citi bike stations in Jersey city and New york city') # colors for Jersey city and NYC regions fill_color = {70: 'blue', 71: 'firebrick'} line_color = {70: 'blue', 71: 'firebrick'} df["fill"] = df['region_id'].map(lambda x: fill_color[x]) df["line"] = df['region_id'].map(lambda x: line_color[x]) source = ColumnDataSource(df) # circle glyph for the stations region_glyph = Circle(x="x", y="y", fill_color="fill", line_color="line", size=10, fill_alpha=0.5) region = fig.add_glyph(source, region_glyph) # hover tooltip to display name tooltips = """ <div> <span style="font-size: 15px;">@name</span> <br> <span style="font-size: 15px;">station id: @station_id</span> </div> """ # add hover tool to figure hover = HoverTool(tooltips=tooltips, renderers=[region]) fig.add_tools(hover) show(fig)
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", fill_alpha=0.5) medal = plot.add_glyph(source, medal_glyph) athlete_glyph = Text(x="MetersBack", y="Year", x_offset=10, text="SelectedName", text_align="left", text_baseline="middle", text_font_size="9pt") athlete = plot.add_glyph(source, athlete_glyph) no_olympics_glyph = Text(x=7.5, y=1942,
def generate_plot(self): """Iteratively reformats and plots self.data for each cell+model combo. TODO: Finish this doc """ plots = [] modelnames = self.data.index.levels[0].tolist() # Iterate over a list of tuples representing all unique pairs of models. for pair in list(itertools.combinations(modelnames, 2)): tools = [ PanTool(), SaveTool(), WheelZoomTool(), ResetTool(), self.create_hover(), ] modelX = pair[0] modelY = pair[1] dataX = self.data.loc[modelX] dataY = self.data.loc[modelY] # Only necessary b/c bokeh's $index identifier for HoverTool() # is pulling an integer index despite data being indexed by cellid. # If cellid strings can be pulled from index instead, # this code will no longer be needed. cells = [] cellsX = list(set(dataX.index.values.tolist())) cellsY = list(set(dataY.index.values.tolist())) if self.fair: # cellsX and cellsY should be the same if fair was checked cells = cellsX if cells != cellsY: self.script = 'Problem with form_data_array:' self.div = 'Model x: ' + modelX + 'and Model y: ' + modelY\ + ' applied to different cells despite fair check.' return else: # If fair wasn't checked, use the longer list to avoid errors. if len(cellsX) >= len(cellsY): cells = cellsX else: cells = cellsY x_mean = np.mean(dataX[self.measure[0]]) x_median = np.median(dataX[self.measure[0]]) y_mean = np.mean(dataY[self.measure[0]]) y_median = np.median(dataY[self.measure[0]]) x_label = ("{0}, mean: {1:5.4f}, median: {2:5.4f}".format( modelX, x_mean, x_median)) y_label = ("{0}, mean: {1:5.4f}, median: {2:5.4f}".format( modelY, y_mean, y_median)) data = pd.DataFrame({ 'x_values': dataX[self.measure[0]], 'y_values': dataY[self.measure[0]], 'cellid': cells, }) dat_source = ColumnDataSource(data) p = figure( x_range=[0, 1], y_range=[0, 1], x_axis_label=x_label, y_axis_label=y_label, title=("{0}, prefix: {1}, suffix: {2}".format( self.measure[0], self.pre, self.suf)), tools=tools, toolbar_location=TOOL_LOC, toolbar_sticky=TOOL_STICK, output_backend="svg", sizing_mode='scale_width', ) glyph = Circle( x='x_values', y='y_values', size=CIRCLE_SIZE, fill_color=CIRCLE_FILL, fill_alpha=CIRCLE_ALPHA, ) p.add_glyph(dat_source, glyph) p.line([0, 1], [0, 1], line_width=1, color='black') plots.append(p) # If more than one plot was made (i.e. 2 or more models were selected), # put them in a grid. #if len(plots) == 1: # singleplot = plots[0] # self.script,self.div = components(singleplot) # return #elif len(plots) > 1: grid = gridplot( plots, ncols=GRID_COLS, sizing_mode='scale_width', ) self.script, self.div = components(grid) if not plots: self.script, self.div = ('Error, no plots to display.', 'Make sure you selected two models.') else: self.plot = grid if self.display: show(grid)
border_fill_alpha = Override(default=0.0) source = ColumnDataSource( data=dict(x=[1, 2, 3, 4, 4, 5, 5], y=[5, 4, 3, 2, 2.1, 1, 1.1], color=[ "rgb(0, 100, 120)", "green", "blue", "#2c7fb8", "#2c7fb8", "rgba(120, 230, 150, 0.5)", "rgba(120, 230, 150, 0.5)" ])) plot = MyPlot(gradient_angle=45) circle = Circle(x="x", y="y", radius=0.2, fill_color="color", line_color="black") circle_renderer = plot.add_glyph(source, circle) plot.add_layout(LinearAxis(), 'below') plot.add_layout(LinearAxis(), 'left') tap = TapTool(renderers=[circle_renderer], callback=Popup(message="Selected color: @color")) plot.add_tools(PanTool(), WheelZoomTool(), tap) doc = Document() doc.add_root(plot) if __name__ == "__main__":
def generate_plots(self, doc): ''' :param doc: curdoc() required for bokeh function handler :return: None ''' ''' ---------------------------------------------------------------------------------------------------------- Define Histogram ---------------------------------------------------------------------------------------------------------- ''' self.hist_plot = {} self.hist_plot['plotting_data'] = np.array( self.total_pandas_df[self.select_widget_hist.value]) self.hist_plot['plot_width'] = 610 self.hist_plot['plot_height'] = 400 self.hist_plot[ 'title'] = 'Gaussian Fit of ' + self.select_widget_hist.value self.hist_plot['object_figure'] = figure( width=self.hist_plot['plot_width'], height=self.hist_plot['plot_height'], title=self.hist_plot['title']) self.hist_plot['source'] = ColumnDataSource( data=dict(hist=[], left_edge=[], right_edge=[])) self.hist_plot['pdf_source'] = ColumnDataSource( data=dict(x=[], y_pdf=[])) # get stats and gaus fit hist_stats_list = basic_stats([self.select_widget_hist.value], self.total_pandas_df) mu = hist_stats_list[0][self.select_widget_hist.value][0] sigma = hist_stats_list[0][self.select_widget_hist.value][2] gauss_dict = gaussian_fit(self.select_widget_hist.value, self.total_pandas_df) hist = gauss_dict['hist'] edges = gauss_dict['edges'] x = gauss_dict['x'] pdf = gauss_dict['pdf'] self.hist_plot['source'].data = { 'hist': hist, 'left_edge': edges[:-1], 'right_edge': edges[1:] } self.hist_plot['pdf_source'].data = {'x': x, 'y_pdf': pdf} self.hist_plot['quad_glyph'] = Quad(top='hist', bottom=0, left='left_edge', right='right_edge') self.hist_plot['pdf_glyph'] = Line(x='x', y='y_pdf', line_color="#D95B43", line_width=8, line_alpha=0.7) self.hist_plot['object_figure'].add_glyph(self.hist_plot['source'], self.hist_plot['quad_glyph']) self.hist_plot['object_figure'].add_glyph(self.hist_plot['pdf_source'], self.hist_plot['pdf_glyph']) ''' ---------------------------------------------------------------------------------------------------------- Define Heatmap ---------------------------------------------------------------------------------------------------------- ''' self.heat_map = {} heat_frame = set_color(self.select_widget_1.value, self.select_widget_2.value, self.total_pandas_df) self.heat_map_source = ColumnDataSource(heat_frame) self.points_source = ColumnDataSource( data=dict(x=self.total_pandas_df[self.select_widget_1.value], y=self.total_pandas_df[self.select_widget_2.value])) self.heat_map['plot_width'] = 610 self.heat_map['plot_height'] = 400 self.heat_map[ 'title'] = "Heat Map of " + self.select_widget_1.value + ' vs. ' + self.select_widget_2.value self.heat_map['object_figure'] = figure( width=self.heat_map['plot_width'], height=self.heat_map['plot_height'], title=self.heat_map['title']) colors = [ '#FF0000', '#F2000D', '#E6001A', '#D90026', '#CC0033', '#BF0040', '#B2004C', '#A60059', '#990066', '#8C0073', '#800080', '#73008C', '#660099', '#5900A6', '#4D00B2', '#4000BF', '#3300CC', '#2600D9', '#1900E6', '#0D00F2', '#0000FF' ] # mapper is a transform required by bokeh to generate heatmaps mapper = LinearColorMapper(palette=colors, low=heat_frame['heat_values'].min(), high=heat_frame['heat_values'].max()) self.heat_map['circle_glyph'] = Circle(x='x', y='y', size=1, line_color=None, fill_color='black') self.heat_map['rect_glyph'] = Rect( x="rect_x", y="rect_y", width=heat_frame['rect_width'].loc[0], height=heat_frame['rect_width'].loc[0], fill_color={ 'field': 'heat_values', 'transform': mapper }, line_color=None, fill_alpha=0.75) self.heat_map['object_figure'].add_glyph(self.points_source, self.heat_map['circle_glyph']) self.heat_map['object_figure'].add_glyph(self.heat_map_source, self.heat_map['rect_glyph']) self.heat_map['color_bar'] = ColorBar( color_mapper=mapper, major_label_text_font_size="5pt", ticker=BasicTicker(desired_num_ticks=len(colors)), label_standoff=6, border_line_color=None, location=(0, 0), background_fill_alpha=0.75) self.heat_map['object_figure'].add_layout(self.heat_map['color_bar'], 'left') WIDGETBOX_WIDTH = 610 self.layout = layout([ self.select_widget_1, self.select_widget_2, self.select_widget_hist ], [self.heat_map['object_figure'], self.hist_plot['object_figure'] ], [self.x_range_slider, self.y_range_slider], [ widgetbox(self.data_table_heat, width=WIDGETBOX_WIDTH), widgetbox(self.data_table_hist, width=WIDGETBOX_WIDTH) ]) # unavoidable resize error forces two figures to be displayed at once rather that switch between # data can be updated easily but plot type should remain static # https://groups.google.com/a/continuum.io/forum/#!topic/bokeh/P2WPJ9an7IQ doc.add_root(self.layout) """ -------------------------------------------------------------------- Callbacks -------------------------------------------------------------------- """ def select_1_callback(attrname, old, new): self.points_source.data['x'] = self.total_pandas_df[new] self.data_table_heat.columns = [ TableColumn(field="labels", title="Statistics", width=int(self.DATA_TABLE_COL_WIDTH * 0.6)), TableColumn(field="variable_1", title=new, width=self.DATA_TABLE_COL_WIDTH), TableColumn(field="variable_2", title=self.select_widget_2.value, width=self.DATA_TABLE_COL_WIDTH), TableColumn(field="variable_1_2", title=new + ' and ' + self.select_widget_2.value, width=int(self.DATA_TABLE_COL_WIDTH * 1.8)) ] heat_frame = set_color(new, self.select_widget_2.value, self.total_pandas_df) self.heat_map_source.data['rect_x'] = heat_frame['rect_x'] self.heat_map_source.data['rect_width'] = heat_frame['rect_width'] self.heat_map_source.data['heat_values'] = heat_frame[ 'heat_values'] self.data_table_heat.source = ColumnDataSource( fill_data_table([new, self.select_widget_2.value], self.total_pandas_df)) self.heat_map[ 'object_figure'].title.text = "Heat Map of " + new + ' vs. ' + self.select_widget_2.value self.x_range_slider.start = self.total_pandas_df[new].min() self.x_range_slider.end = self.total_pandas_df[new].max() self.x_range_slider.step = (self.total_pandas_df[new].max() - self.total_pandas_df[new].min()) / 100 self.x_range_slider.value = (self.total_pandas_df[new].min(), self.total_pandas_df[new].max()) self.select_widget_1.on_change('value', select_1_callback) def select_2_callback(attrname, old, new): self.points_source.data['y'] = self.total_pandas_df[new] self.data_table_heat.columns = [ TableColumn(field="labels", title="Statistics", width=int(self.DATA_TABLE_COL_WIDTH * 0.6)), TableColumn(field="variable_1", title=self.select_widget_1.value, width=self.DATA_TABLE_COL_WIDTH), TableColumn(field="variable_2", title=new, width=self.DATA_TABLE_COL_WIDTH), TableColumn(field="variable_1_2", title=self.select_widget_1.value + ' and ' + new, width=int(self.DATA_TABLE_COL_WIDTH * 1.8)) ] heat_frame = set_color(self.select_widget_1.value, new, self.total_pandas_df) self.heat_map_source.data['rect_y'] = heat_frame['rect_y'] self.heat_map_source.data['rect_height'] = heat_frame[ 'rect_height'] self.heat_map_source.data['heat_values'] = heat_frame[ 'heat_values'] self.data_table_heat.source = ColumnDataSource( fill_data_table([new, self.select_widget_2.value], self.total_pandas_df)) self.heat_map[ 'object_figure'].title.text = "Heat Map of " + self.select_widget_1.value + ' vs. ' + new self.y_range_slider.start = self.total_pandas_df[new].min() self.y_range_slider.end = self.total_pandas_df[new].max() self.y_range_slider.step = (self.total_pandas_df[new].max() - self.total_pandas_df[new].min()) / 100 self.y_range_slider.value = (self.total_pandas_df[new].min(), self.total_pandas_df[new].max()) self.select_widget_2.on_change('value', select_2_callback) def select_hist_callback(attrname, old, new): # get stats and gaus fit hist_stats_list = basic_stats([new], self.total_pandas_df) mu = hist_stats_list[0][new][0] sigma = hist_stats_list[0][new][2] gauss_dict = gaussian_fit(new, self.total_pandas_df) hist = gauss_dict['hist'] edges = gauss_dict['edges'] x = gauss_dict['x'] self.hist_plot['source'].data = { 'hist': hist, 'left_edge': edges[:-1], 'right_edge': edges[1:] } if new not in self.sq_err_names: pdf = gauss_dict['pdf'] else: pdf = chi_squared(new, self.total_pandas_df) self.hist_plot['pdf_source'].data = {'x': x, 'y_pdf': pdf} self.hist_plot[ 'object_figure'].title.text = "Gaussian Fit of " + new self.data_table_hist.source = ColumnDataSource( fill_data_table([new], self.total_pandas_df)) self.data_table_hist.columns = [ TableColumn(field="labels", title="Statistics", width=self.DATA_TABLE_COL_WIDTH), TableColumn(field="variable_1", title=new, width=self.DATA_TABLE_COL_WIDTH) ] self.select_widget_hist.on_change('value', select_hist_callback) def x_range_callback(attrname, old, new): self.heat_map['object_figure'].x_range.start = new[0] self.heat_map['object_figure'].x_range.end = new[1] def y_range_callback(attrname, old, new): self.heat_map['object_figure'].y_range.start = new[0] self.heat_map['object_figure'].y_range.end = new[1] self.x_range_slider.on_change('value', x_range_callback) self.y_range_slider.on_change('value', y_range_callback)
# set to roughly extent of points x_range = Range1d(start=airports['x'].min() - 10000, end=airports['x'].max() + 10000) y_range = Range1d(start=airports['y'].min() - 10000, end=airports['y'].max() + 10000) # create plot and add tools hover_tool = HoverTool(tooltips=[("Name", "@name"), ("Elevation", "@elevation (m)")]) p = Plot(x_range=x_range, y_range=y_range, plot_height=690, plot_width=990, title=title) p.add_tools(ResizeTool(), WheelZoomTool(), PanTool(), BoxZoomTool(), hover_tool) p.add_tile(tile_source) # create point glyphs point_options = {} point_options['x'] = 'x' point_options['y'] = 'y' point_options['size'] = 9 point_options['fill_color'] = "#60ACA1" point_options['line_color'] = "#D2C4C1" point_options['line_width'] = 1.5 points_glyph = Circle(**point_options) p.add_glyph(points_source, points_glyph) doc = Document() doc.add(p) if __name__ == "__main__": filename = "airports_map.html" with open(filename, "w") as f: f.write(file_html(doc, INLINE, "Bokeh Airports Example")) print("Wrote %s" % filename) view(filename)
API_KEY = "GOOGLE_API_KEY" map_options = GMapOptions(lat=15, lng=0, zoom=2) plot = GMapPlot( plot_width=1000, plot_height=500, map_options=map_options, api_key=API_KEY, output_backend="webgl", ) if plot.api_key == "GOOGLE_API_KEY": plot.add_layout(Label(x=500, y=320, x_units='screen', y_units='screen', text='Replace GOOGLE_API_KEY with your own key', text_color='red', text_align='center')) plot.title.text = "Cities of the world with a population over 5,000 people." circle = Circle(x="lng", y="lat", size=5, line_color=None, fill_color='firebrick', fill_alpha=0.2) plot.add_glyph(ColumnDataSource(data), circle) plot.add_tools(PanTool(), WheelZoomTool()) doc = Document() doc.add_root(plot) if __name__ == "__main__": doc.validate() filename = "maps_cities.html" with open(filename, "w") as f: f.write(file_html(doc, INLINE, "Google Maps - World cities Example")) print("Wrote %s" % filename) view(filename)
toolbar_sticky=False, tools=TOOLS, x_range=Range1d(cluster_hist["min_long"], cluster_hist["max_long"]), y_range=Range1d(cluster_hist["min_lat"], cluster_hist["max_lat"])) clusters = kmeans_viz.add_glyph( source, Ellipse(x="longitude", y="latitude", width="width", height="height", fill_color="LightSeaGreen")) centroids = kmeans_viz.add_glyph( source, Circle(x="longitude", y="latitude", size=10, fill_alpha=1)) hover = kmeans_viz.select_one(HoverTool) hover.point_policy = "follow_mouse" hover.tooltips = [ ("Count", "@count"), ("(Long, Lat)", "($x.2, $y.2)"), ("Width", "@width"), ("Height", "@height"), ] iter_slider = Slider(start=0, end=len(cluster_hist) - 5, value=0, step=1, title="Iteration")
xdr = Range1d(start=-1.25, end=1.25) ydr = Range1d(start=-1.25, end=1.25) ds = ColumnDataSource(dict(dummy=[0])) plot = Plot(title="Speedometer", x_range=xdr, y_range=ydr, plot_width=600, plot_height=600) start_angle = pi + pi/4 end_angle = -pi/4 max_kmh = 250 max_mph = max_kmh*0.621371 major_step, minor_step = 25, 5 plot.add_glyph(ds, Circle(x=0, y=0, radius=1.00, fill_color="white", line_color="black")) plot.add_glyph(ds, Circle(x=0, y=0, radius=0.05, fill_color="gray", line_color="black")) plot.add_glyph(ds, Text(x=0, y=+0.15, angle=0, text=["km/h"], text_color="red", text_align="center", text_baseline="bottom", text_font_style="bold")) plot.add_glyph(ds, Text(x=0, y=-0.15, angle=0, text=["mph"], text_color="blue", text_align="center", text_baseline="top", text_font_style="bold")) def data(value): """Shorthand to override default units with "data", for e.g. `Ray.length`. """ return dict(value=value, units="data") def speed_to_angle(speed, units): max_speed = max_kmh if units == "kmh" else max_mph speed = min(max(speed, 0), max_speed) total_angle = start_angle - end_angle angle = total_angle*float(speed)/max_speed return start_angle - angle
(x + 2 * e, y + 2 * e, 1, "green", "%s02" % n), (x + 3 * e, y + 3 * e, 1, "violet", "%s03" % n), (x + 4 * e, y + 4 * e, 1, "pink", "%s04" % n), (x + 5 * e, y + 5 * e, 1, "black", "%s05" % n), (x + 6 * e, y + 6 * e, 1, "gray", "%s06" % n), (x + 7 * e, y + 7 * e, 1, "olive", "%s07" % n), (x + 8 * e, y + 8 * e, 1, "yellow", "%s08" % n), (x + 9 * e, y + 9 * e, 1, "orange", "%s09" % n), ] f = lambda i: [t[i] for t in d] return dict(x=f(0), y=f(1), s=f(2), c=f(3), name=f(4)) ds1 = ColumnDataSource(data=fds(0, 0, 0.1, "c")) cr1 = plot.add_glyph( ds1, Circle(x="x", y="y", radius="s", fill_color="c", line_color="c")) ds2 = ColumnDataSource(data=fds(-5, 5, 0.5, "d")) cr2 = plot.add_glyph( ds2, Circle(x="x", y="y", radius="s", fill_color="c", line_color="c")) ln2 = plot.add_glyph(ds2, Line(x="x", y="y", line_width=3, line_color="red")) ds3 = ColumnDataSource(data=fds(5, 5, 0.0, "e")) cr3 = plot.add_glyph( ds3, Circle(x="x", y="y", radius="s", fill_color="c", line_color="c")) tooltips = "<b>@name</b> = (@x{0.00}, @y{0.00})" hover = HoverTool(tooltips=tooltips, renderers=[cr1, cr2, ln2, cr3], point_policy="follow_mouse")
ydr = Range1d(start=-1.25, end=1.25) plot = Plot(x_range=xdr, y_range=ydr, plot_width=600, plot_height=600) plot.title.text = "Speedometer" plot.toolbar_location = None start_angle = pi + pi / 4 end_angle = -pi / 4 max_kmh = 250 max_mph = max_kmh * 0.621371 major_step, minor_step = 25, 5 plot.add_glyph( Circle(x=0, y=0, radius=1.00, fill_color="white", line_color="black")) plot.add_glyph( Circle(x=0, y=0, radius=0.05, fill_color="gray", line_color="black")) plot.add_glyph( Text(x=0, y=+0.15, text=["km/h"], text_color="red", text_align="center", text_baseline="bottom", text_font_style="bold")) plot.add_glyph( Text(x=0, y=-0.15, text=["mph"],
zoom=13) plot = GMapPlot(x_range=DataRange1d(), y_range=DataRange1d(), map_options=map_options, title="Washington, DC", plot_width=1280, plot_height=1280, responsive=True) # Finally plot it lines = MultiLine(xs="lons", ys="lats", line_alpha="line_alpha", line_width="line_width", line_color="red", line_cap="round") circle = Circle(x="lon", y="lat", size=10, fill_color="blue", fill_alpha=0.8, line_color=None) plot.add_glyph(source, circle) plot.add_glyph(line_source, lines) plot.add_tools(PanTool(), WheelZoomTool(), BoxZoomTool(), hover, ResetTool(), UndoTool(), RedoTool(), PreviewSaveTool()) output_file("gmap_plot.html") show(plot)
from bokeh.models.glyphs import Circle from bokeh.models import Plot, ColumnDataSource, Range1d, Grid, DataRange1d from bokeh.io import output_file, show output_file("Line_from_models.html") x = [1,2,3,4,5] y= [6,7,8,9,10] data = ColumnDataSource(dict(x=x,y=y)) p = Plot(x_range=DataRange1d(start=0,end=15),y_range=DataRange1d(start=0,end=15)) circle = Circle(x="x", y="y") p.add_glyph(data,circle) show(p)
def make_scatter_plot(source, data, country, xname, yname, xax=False, yax=False): # sets range and borders for plot xdr = DataRange1d(bounds=None) ydr = DataRange1d(bounds=None) mbl = 40 if yax else 0 mbb = 40 if xax else 0 plot = figure(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, title=country) # plots points circle = Circle(x=xname, y=yname, fill_color="blue", fill_alpha=0.2, size=4, line_color="blue") plot.add_glyph(source, circle) # calculates and plots regression line a, b, mse = make_regression_line(data, xname, yname) mse_mean = mse.mean() print(xname, yname, mse_mean) x = data[xname] plot.line(x, a * x + b, color='red') plot.axis.visible = False # makes axis according to place in matrix 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)) return plot
ydr = DataRange1d() plot = Plot(x_range=xdr, y_range=ydr) circle = Circle(x="x", y="y", radius=0.2, # Set the fill color to be dependent on the "color" field of the # data source. If the field is missing, then the default value is # used. Since no explicit default is provided, this picks up the # default in FillProps, which is "gray". fill_color="color", # Alternative to using fill_color with rgba values, you can also use # the fill_alpha setting to set the alpha values of your circle or # other glyphs. This can be set as a single value or powered by a # 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')
x_range=x_range, y_range=y_range, map_options=map_options, title="London Meetups" ) source = ColumnDataSource( data=dict( lat=[51.49013, 51.50013, 51.51013], lon=[-0.130305, -0.126305, -0.120305], fill=['orange', 'blue', 'green'], name=['LondonDataScience', 'Spark', 'MachineLearning'], text=['Graph Data & Algorithms','Spark Internals','Deep Learning on Spark'] ) ) circle = Circle(x="lon", y="lat", size=15, fill_color="fill", line_color=None) plot.add_glyph(source, circle) # TOOLS="pan,wheel_zoom,box_zoom,reset,hover,save" pan = PanTool() wheel_zoom = WheelZoomTool() box_select = BoxSelectTool() reset = ResetTool() hover = HoverTool() # save = SaveTool() plot.add_tools(pan, wheel_zoom, box_select, reset, hover) overlay = BoxSelectionOverlay(tool=box_select) plot.add_layout(overlay) hover = plot.select(dict(type=HoverTool))
def Unplanned_Circles(points, radius): circles = [Circle(p, radius) for p in points] return circles
def main(ini_path, show_flag=False, overwrite_flag=True): """Generate Bokeh figures Bokeh issues: Adjust y range based on non-muted data https://stackoverflow.com/questions/43620837/how-to-get-bokeh-to-dynamically-adjust-y-range-when-panning Linked interactive legends so that there is only one legend for the gridplot Maybe hide or mute QA values above max (instead of filtering them in advance) Args: ini_path (str): show_flag (bool): if True, show the figures in the browser. Default is False. overwrite_flag (bool): if True, overwrite existing tables. Default is True (for now) """ logging.info('\nGenerate interactive timeseries figures') # Eventually read from INI plot_var_list = ['NDVI_TOA', 'ALBEDO_SUR', 'TS', 'NDWI_TOA', 'EVI_SUR'] # plot_var_list = [ # 'NDVI_TOA', 'ALBEDO_SUR', 'TS', 'NDWI_TOA', # 'CLOUD_SCORE', 'FMASK_PCT'] output_folder = 'figures' # Read config file ini = inputs.read(ini_path) inputs.parse_section(ini, section='INPUTS') inputs.parse_section(ini, section='ZONAL_STATS') inputs.parse_section(ini, section='SUMMARY') inputs.parse_section(ini, section='FIGURES') inputs.parse_section(ini, section='BEAMER') # Hardcode GRIDMET month range to the water year ini['SUMMARY']['gridmet_start_month'] = 10 ini['SUMMARY']['gridmet_end_month'] = 9 # Start/end year year_list = list(range( ini['INPUTS']['start_year'], ini['INPUTS']['end_year'] + 1)) month_list = list(utils.wrapped_range( ini['INPUTS']['start_month'], ini['INPUTS']['end_month'], 1, 12)) doy_list = list(utils.wrapped_range( ini['INPUTS']['start_doy'], ini['INPUTS']['end_doy'], 1, 366)) # GRIDMET month range (default to water year) gridmet_start_month = ini['SUMMARY']['gridmet_start_month'] gridmet_end_month = ini['SUMMARY']['gridmet_end_month'] gridmet_months = list(utils.month_range( gridmet_start_month, gridmet_end_month)) logging.info('\nGridmet months: {}'.format( ', '.join(map(str, gridmet_months)))) # Get ee features from shapefile zone_geom_list = gdc.shapefile_2_geom_list_func( ini['INPUTS']['zone_shp_path'], zone_field=ini['INPUTS']['zone_field'], reverse_flag=False) # Filter features by FID before merging geometries if ini['INPUTS']['fid_keep_list']: zone_geom_list = [ zone_obj for zone_obj in zone_geom_list if zone_obj[0] in ini['INPUTS']['fid_keep_list']] if ini['INPUTS']['fid_skip_list']: zone_geom_list = [ zone_obj for zone_obj in zone_geom_list if zone_obj[0] not in ini['INPUTS']['fid_skip_list']] # # Filter features by FID before merging geometries # if ini['INPUTS']['fid_keep_list']: # landsat_df = landsat_df[landsat_df['ZONE_FID'].isin( # ini['INPUTS']['fid_keep_list'])] # if ini['INPUTS']['fid_skip_list']: # landsat_df = landsat_df[~landsat_df['ZONE_FID'].isin( # ini['INPUTS']['fid_skip_list'])] logging.info('\nProcessing zones') for zone_fid, zone_name, zone_json in zone_geom_list: zone_name = zone_name.replace(' ', '_') logging.info('ZONE: {} (FID: {})'.format(zone_name, zone_fid)) zone_stats_ws = os.path.join( ini['ZONAL_STATS']['output_ws'], zone_name) zone_figures_ws = os.path.join( ini['SUMMARY']['output_ws'], zone_name, output_folder) if not os.path.isdir(zone_stats_ws): logging.debug(' Folder {} does not exist, skipping'.format( zone_stats_ws)) continue elif not os.path.isdir(zone_figures_ws): os.makedirs(zone_figures_ws) # Input paths landsat_daily_path = os.path.join( zone_stats_ws, '{}_landsat_daily.csv'.format(zone_name)) gridmet_daily_path = os.path.join( zone_stats_ws, '{}_gridmet_daily.csv'.format(zone_name)) gridmet_monthly_path = os.path.join( zone_stats_ws, '{}_gridmet_monthly.csv'.format(zone_name)) if not os.path.isfile(landsat_daily_path): logging.error(' Landsat daily CSV does not exist, skipping zone') continue elif (not os.path.isfile(gridmet_daily_path) and not os.path.isfile(gridmet_monthly_path)): logging.error( ' GRIDMET daily or monthly CSV does not exist, skipping zone') continue # DEADBEEF - Eventually support generating only Landsat figures # logging.error( # ' GRIDMET daily and/or monthly CSV files do not exist.\n' # ' ETo and PPT will not be processed.') # Output paths output_doy_path = os.path.join( zone_figures_ws, '{}_timeseries_doy.html'.format(zone_name)) output_date_path = os.path.join( zone_figures_ws, '{}_timeseries_date.html'.format(zone_name)) logging.debug(' Reading Landsat CSV') landsat_df = pd.read_csv(landsat_daily_path) logging.debug(' Filtering Landsat dataframe') landsat_df = landsat_df[landsat_df['PIXEL_COUNT'] > 0] # QA field should have been written in zonal stats code # Eventually this block can be removed if 'QA' not in landsat_df.columns.values: landsat_df['QA'] = 0 # # This assumes that there are L5/L8 images in the dataframe # if not landsat_df.empty: # max_pixel_count = max(landsat_df['PIXEL_COUNT']) # else: # max_pixel_count = 0 if year_list: landsat_df = landsat_df[landsat_df['YEAR'].isin(year_list)] if month_list: landsat_df = landsat_df[landsat_df['MONTH'].isin(month_list)] if doy_list: landsat_df = landsat_df[landsat_df['DOY'].isin(doy_list)] # Assume the default is for these to be True and only filter if False if not ini['INPUTS']['landsat4_flag']: landsat_df = landsat_df[landsat_df['PLATFORM'] != 'LT04'] if not ini['INPUTS']['landsat5_flag']: landsat_df = landsat_df[landsat_df['PLATFORM'] != 'LT05'] if not ini['INPUTS']['landsat7_flag']: landsat_df = landsat_df[landsat_df['PLATFORM'] != 'LE07'] if not ini['INPUTS']['landsat8_flag']: landsat_df = landsat_df[landsat_df['PLATFORM'] != 'LC08'] if ini['INPUTS']['path_keep_list']: landsat_df = landsat_df[ landsat_df['PATH'].isin(ini['INPUTS']['path_keep_list'])] if (ini['INPUTS']['row_keep_list'] and ini['INPUTS']['row_keep_list'] != ['XXX']): landsat_df = landsat_df[ landsat_df['ROW'].isin(ini['INPUTS']['row_keep_list'])] if ini['INPUTS']['scene_id_keep_list']: # Replace XXX with primary ROW value for checking skip list SCENE_ID scene_id_df = pd.Series([ s.replace('XXX', '{:03d}'.format(int(r))) for s, r in zip(landsat_df['SCENE_ID'], landsat_df['ROW'])]) landsat_df = landsat_df[scene_id_df.isin( ini['INPUTS']['scene_id_keep_list']).values] # This won't work: SCENE_ID have XXX but scene_id_skip_list don't # landsat_df = landsat_df[landsat_df['SCENE_ID'].isin( # ini['INPUTS']['scene_id_keep_list'])] if ini['INPUTS']['scene_id_skip_list']: # Replace XXX with primary ROW value for checking skip list SCENE_ID scene_id_df = pd.Series([ s.replace('XXX', '{:03d}'.format(int(r))) for s, r in zip(landsat_df['SCENE_ID'], landsat_df['ROW'])]) landsat_df = landsat_df[np.logical_not(scene_id_df.isin( ini['INPUTS']['scene_id_skip_list']).values)] # This won't work: SCENE_ID have XXX but scene_id_skip_list don't # landsat_df = landsat_df[np.logical_not(landsat_df['SCENE_ID'].isin( # ini['INPUTS']['scene_id_skip_list']))] # Filter by QA/QC value if ini['SUMMARY']['max_qa'] >= 0 and not landsat_df.empty: logging.debug(' Maximum QA: {0}'.format( ini['SUMMARY']['max_qa'])) landsat_df = landsat_df[ landsat_df['QA'] <= ini['SUMMARY']['max_qa']] # Filter by average cloud score if ini['SUMMARY']['max_cloud_score'] < 100 and not landsat_df.empty: logging.debug(' Maximum cloud score: {0}'.format( ini['SUMMARY']['max_cloud_score'])) landsat_df = landsat_df[ landsat_df['CLOUD_SCORE'] <= ini['SUMMARY']['max_cloud_score']] # Filter by Fmask percentage if ini['SUMMARY']['max_fmask_pct'] < 100 and not landsat_df.empty: landsat_df['FMASK_PCT'] = 100 * ( landsat_df['FMASK_COUNT'] / landsat_df['FMASK_TOTAL']) logging.debug(' Max Fmask threshold: {}'.format( ini['SUMMARY']['max_fmask_pct'])) landsat_df = landsat_df[ landsat_df['FMASK_PCT'] <= ini['SUMMARY']['max_fmask_pct']] # Filter low count SLC-off images if ini['SUMMARY']['min_slc_off_pct'] > 0 and not landsat_df.empty: logging.debug(' Mininum SLC-off threshold: {}%'.format( ini['SUMMARY']['min_slc_off_pct'])) # logging.debug(' Maximum pixel count: {}'.format( # max_pixel_count)) slc_off_mask = ( (landsat_df['PLATFORM'] == 'LE07') & ((landsat_df['YEAR'] >= 2004) | ((landsat_df['YEAR'] == 2003) & (landsat_df['DOY'] > 151)))) slc_off_pct = 100 * (landsat_df['PIXEL_COUNT'] / landsat_df['PIXEL_TOTAL']) # slc_off_pct = 100 * (landsat_df['PIXEL_COUNT'] / max_pixel_count) landsat_df = landsat_df[ ((slc_off_pct >= ini['SUMMARY']['min_slc_off_pct']) & slc_off_mask) | (~slc_off_mask)] if landsat_df.empty: logging.error( ' Empty Landsat dataframe after filtering, skipping zone') continue # Aggregate GRIDMET (to water year) if os.path.isfile(gridmet_monthly_path): logging.debug(' Reading montly GRIDMET CSV') gridmet_df = pd.read_csv(gridmet_monthly_path) elif os.path.isfile(gridmet_daily_path): logging.debug(' Reading daily GRIDMET CSV') gridmet_df = pd.read_csv(gridmet_daily_path) logging.debug(' Computing GRIDMET summaries') # Summarize GRIDMET for target months year if (gridmet_start_month in [10, 11, 12] and gridmet_end_month in [10, 11, 12]): month_mask = ( (gridmet_df['MONTH'] >= gridmet_start_month) & (gridmet_df['MONTH'] <= gridmet_end_month)) gridmet_df.loc[month_mask, 'GROUP_YEAR'] = gridmet_df['YEAR'] + 1 elif (gridmet_start_month in [10, 11, 12] and gridmet_end_month not in [10, 11, 12]): month_mask = gridmet_df['MONTH'] >= gridmet_start_month gridmet_df.loc[month_mask, 'GROUP_YEAR'] = gridmet_df['YEAR'] + 1 month_mask = gridmet_df['MONTH'] <= gridmet_end_month gridmet_df.loc[month_mask, 'GROUP_YEAR'] = gridmet_df['YEAR'] else: month_mask = ( (gridmet_df['MONTH'] >= gridmet_start_month) & (gridmet_df['MONTH'] <= gridmet_end_month)) gridmet_df.loc[month_mask, 'GROUP_YEAR'] = gridmet_df['YEAR'] # GROUP_YEAR for rows not in the GRIDMET month range will be NAN gridmet_df = gridmet_df[~pd.isnull(gridmet_df['GROUP_YEAR'])] if year_list: gridmet_df = gridmet_df[gridmet_df['GROUP_YEAR'].isin(year_list)] if gridmet_df.empty: logging.error( ' Empty GRIDMET dataframe after filtering by year') continue # Group GRIDMET data by user specified range (default is water year) gridmet_group_df = gridmet_df \ .groupby(['ZONE_NAME', 'ZONE_FID', 'GROUP_YEAR']) \ .agg({'ETO': np.sum, 'PPT': np.sum}) \ .reset_index() \ .sort_values(by='GROUP_YEAR') # .rename(columns={'ETO': 'ETO', 'PPT': 'ETO'}) \ # Rename wasn't working when chained... gridmet_group_df.rename(columns={'GROUP_YEAR': 'YEAR'}, inplace=True) gridmet_group_df['YEAR'] = gridmet_group_df['YEAR'].astype(int) # # Group GRIDMET data by month # gridmet_month_df = gridmet_df\ # .groupby(['ZONE_NAME', 'ZONE_FID', 'GROUP_YEAR', 'MONTH']) \ # .agg({'ETO': np.sum, 'PPT': np.sum}) \ # .reset_index() \ # .sort_values(by=['GROUP_YEAR', 'MONTH']) # gridmet_month_df.rename(columns={'GROUP_YEAR': 'YEAR'}, inplace=True) # # Rename monthly PPT columns # gridmet_month_df['MONTH'] = 'PPT_M' + gridmet_month_df['MONTH'].astype(str) # # Pivot rows up to separate columns # gridmet_month_df = gridmet_month_df.pivot_table( # 'PPT', ['ZONE_NAME', 'YEAR'], 'MONTH') # gridmet_month_df.reset_index(inplace=True) # columns = ['ZONE_NAME', 'YEAR'] + ['PPT_M{}'.format(m) for m in gridmet_months] # gridmet_month_df = gridmet_month_df[columns] # del gridmet_month_df.index.name # Merge Landsat and GRIDMET collections zone_df = landsat_df.merge( gridmet_group_df, on=['ZONE_NAME', 'ZONE_FID', 'YEAR']) if zone_df is None or zone_df.empty: logging.info(' Empty zone dataframe, not generating figures') continue # Compute ETg zone_df['ETG_MEAN'] = zone_df['ETSTAR_MEAN'] * ( zone_df['ETO'] - zone_df['PPT']) zone_df['ETG_LPI'] = zone_df['ETSTAR_LPI'] * ( zone_df['ETO'] - zone_df['PPT']) zone_df['ETG_UPI'] = zone_df['ETSTAR_UPI'] * ( zone_df['ETO'] - zone_df['PPT']) zone_df['ETG_LCI'] = zone_df['ETSTAR_LCI'] * ( zone_df['ETO'] - zone_df['PPT']) zone_df['ETG_UCI'] = zone_df['ETSTAR_UCI'] * ( zone_df['ETO'] - zone_df['PPT']) # Compute ET zone_df['ET_MEAN'] = zone_df['ETG_MEAN'] + zone_df['PPT'] zone_df['ET_LPI'] = zone_df['ETG_LPI'] + zone_df['PPT'] zone_df['ET_UPI'] = zone_df['ETG_UPI'] + zone_df['PPT'] zone_df['ET_LCI'] = zone_df['ETG_LCI'] + zone_df['PPT'] zone_df['ET_UCI'] = zone_df['ETG_UCI'] + zone_df['PPT'] # ORIGINAL PLOTTING CODE # Check that plot variables are present for plot_var in plot_var_list: if plot_var not in landsat_df.columns.values: logging.error( ' The plotting variable {} does not exist in the ' 'dataframe'.format(plot_var)) sys.exit() # if ini['INPUTS']['scene_id_keep_list']: # # Replace XXX with primary ROW value for checking skip list SCENE_ID # scene_id_df = pd.Series([ # s.replace('XXX', '{:03d}'.format(int(r))) # for s, r in zip(landsat_df['SCENE_ID'], landsat_df['ROW'])]) # landsat_df = landsat_df[scene_id_df.isin( # ini['INPUTS']['scene_id_keep_list']).values] # # This won't work: SCENE_ID have XXX but scene_id_skip_list don't # # landsat_df = landsat_df[landsat_df['SCENE_ID'].isin( # # ini['INPUTS']['scene_id_keep_list'])] # if ini['INPUTS']['scene_id_skip_list']: # # Replace XXX with primary ROW value for checking skip list SCENE_ID # scene_id_df = pd.Series([ # s.replace('XXX', '{:03d}'.format(int(r))) # for s, r in zip(landsat_df['SCENE_ID'], landsat_df['ROW'])]) # landsat_df = landsat_df[np.logical_not(scene_id_df.isin( # ini['INPUTS']['scene_id_skip_list']).values)] # # This won't work: SCENE_ID have XXX but scene_id_skip_list don't # # landsat_df = landsat_df[np.logical_not(landsat_df['SCENE_ID'].isin( # # ini['INPUTS']['scene_id_skip_list']))] # Compute colors for each QA value logging.debug(' Building column data source') qa_values = sorted(list(set(zone_df['QA'].values))) colors = { qa: "#%02x%02x%02x" % (int(r), int(g), int(b)) for qa, (r, g, b, _) in zip( qa_values, 255 * cm.viridis(mpl.colors.Normalize()(qa_values))) } logging.debug(' QA values: {}'.format( ', '.join(map(str, qa_values)))) # Unpack the data by QA type to support interactive legends sources = dict() # sources = defaultdict(dict) # platform_list = ['LT04', 'LT05', 'LE07', 'LC08'] for qa_value in qa_values: # for platform in platform_list: # qa_df = zone_df[ # (zone_df['PLATFORM'] == platform) & # (zone_df['QA'] == qa_value)] qa_df = zone_df[zone_df['QA'] == qa_value] qa_data = { 'INDEX': list(range(len(qa_df.index))), 'PLATFORM': qa_df['PLATFORM'], 'DATE': pd.to_datetime(qa_df['DATE']), 'TIME': pd.to_datetime(qa_df['DATE']).map( lambda x: x.strftime('%Y-%m-%d')), 'DOY': qa_df['DOY'].values, 'QA': qa_df['QA'].values, 'COLOR': [colors[qa] for qa in qa_df['QA'].values] } for plot_var in plot_var_list: if plot_var in qa_df.columns.values: qa_data.update({plot_var: qa_df[plot_var].values}) sources[qa_value] = bokeh.models.ColumnDataSource(qa_data) # sources[qa_value][platform] = bokeh.models.ColumnDataSource( # qa_data) tooltips = [ ("LANDSAT", "@PLATFORM"), ("DATE", "@TIME"), ("DOY", "@DOY")] # hover_tool = bokeh.models.HoverTool(tooltips=tooltips) # tools="xwheel_zoom,xpan,xbox_zoom,reset,box_select" # tools = [ # hover_tool, # bokeh.models.WheelZoomTool(dimensions='width'), # bokeh.models.PanTool(dimensions='width'), # bokeh.models.BoxZoomTool(dimensions='width'), # bokeh.models.ResetTool(), # bokeh.models.BoxSelectTool()] # Selection hover_circle = Circle( fill_color='#ff0000', line_color='#ff0000') selected_circle = Circle( fill_color='COLOR', line_color='COLOR') nonselected_circle = Circle( fill_color='#aaaaaa', line_color='#aaaaaa') # Plot the data by DOY logging.debug(' Building DOY timeseries figure') if os.path.isfile(output_doy_path): os.remove(output_doy_path) output_file(output_doy_path, title=zone_name) figure_args = dict( plot_width=750, plot_height=250, title=None, tools="xwheel_zoom,xpan,xbox_zoom,reset,box_select", # tools="xwheel_zoom,xpan,xbox_zoom,reset,tap", active_scroll="xwheel_zoom") plot_args = dict( size=4, alpha=0.9, color='COLOR') if ini['SUMMARY']['max_qa'] > 0: plot_args['legend'] = 'QA' figures = [] for plot_i, plot_var in enumerate(plot_var_list): if plot_i == 0: f = figure( # x_range=bokeh.models.Range1d(1, 366, bounds=(1, 366)), y_axis_label=plot_var, **figure_args) else: f = figure( x_range=f.x_range, y_axis_label=plot_var, **figure_args) # # Add each QA level as a separate object # for qa, platform_sources in sorted(sources.items()): # for platform, source in platform_sources.items(): # if platform == 'LT05': # r = f.triangle( # 'DOY', plot_var, source=source, **plot_args) # elif platform == 'LE07': # r = f.square( # 'DOY', plot_var, source=source, **plot_args) # elif platform == 'LC08': # r = f.circle( # 'DOY', plot_var, source=source, **plot_args) # else: # r = f.diamond( # 'DOY', plot_var, source=source, **plot_args) # r.hover_glyph = hover_circle # r.selection_glyph = selected_circle # r.nonselection_glyph = nonselected_circle # r.muted_glyph = nonselected_circle # hover_tool.renderers.append(r) # Add each QA level as a separate object for qa, source in sorted(sources.items()): r = f.circle('DOY', plot_var, source=source, **plot_args) r.hover_glyph = hover_circle r.selection_glyph = selected_circle r.nonselection_glyph = nonselected_circle r.muted_glyph = nonselected_circle # # DEADBEEF - This will display high QA points as muted # if qa > ini['SUMMARY']['max_qa']: # r.muted = True # # r.visible = False f.add_tools(bokeh.models.HoverTool(tooltips=tooltips)) # if ini['SUMMARY']['max_qa'] > 0: f.legend.location = "top_left" f.legend.click_policy = "hide" # f.legend.click_policy = "mute" f.legend.orientation = "horizontal" figures.append(f) del f # Try to not allow more than 4 plots in a column p = gridplot( figures, ncols=len(plot_var_list) // 3, sizing_mode='stretch_both') if show_flag: show(p) save(p) # Plot the data by DATE logging.debug(' Building date timeseries figure') if os.path.isfile(output_date_path): os.remove(output_date_path) output_file(output_date_path, title=zone_name) figure_args = dict( plot_width=750, plot_height=250, title=None, tools="xwheel_zoom,xpan,xbox_zoom,reset,box_select", # tools="xwheel_zoom,xpan,xbox_zoom,reset,tap", active_scroll="xwheel_zoom", x_axis_type="datetime",) plot_args = dict( size=4, alpha=0.9, color='COLOR') if ini['SUMMARY']['max_qa'] > 0: plot_args['legend'] = 'QA' figures = [] for plot_i, plot_var in enumerate(plot_var_list): if plot_i == 0: f = figure( # x_range=bokeh.models.Range1d(x_limit[0], x_limit[1], bounds=x_limit), y_axis_label=plot_var, **figure_args) else: f = figure( x_range=f.x_range, y_axis_label=plot_var, **figure_args) if plot_var == 'TS': f.y_range.bounds = (270, None) # # Add each QA level as a separate object # for qa, platform_sources in sorted(sources.items()): # for platform, source in sorted(platform_sources.items()): # if platform == 'LT05': # r = f.triangle( # 'DATE', plot_var, source=source, **plot_args) # elif platform == 'LE07': # r = f.square( # 'DATE', plot_var, source=source, **plot_args) # elif platform == 'LC08': # r = f.circle( # 'DATE', plot_var, source=source, **plot_args) # else: # r = f.diamond( # 'DATE', plot_var, source=source, **plot_args) # r.hover_glyph = hover_circle # r.selection_glyph = selected_circle # r.nonselection_glyph = nonselected_circle # r.muted_glyph = nonselected_circle # hover_tool.renderers.append(r) # Add each QA level as a separate object for qa, source in sorted(sources.items()): r = f.circle('DATE', plot_var, source=source, **plot_args) r.hover_glyph = hover_circle r.selection_glyph = selected_circle r.nonselection_glyph = nonselected_circle r.muted_glyph = nonselected_circle # # DEADBEEF - This will display high QA points as muted # if qa > ini['SUMMARY']['max_qa']: # r.muted = True # # r.visible = False f.add_tools(bokeh.models.HoverTool(tooltips=tooltips)) # if ini['SUMMARY']['max_qa'] > 0: f.legend.location = "top_left" f.legend.click_policy = "hide" # f.legend.click_policy = "mute" f.legend.orientation = "horizontal" figures.append(f) del f # Try to not allow more than 4 plots in a column p = gridplot( figures, ncols=len(plot_var_list) // 3, sizing_mode='stretch_both') if show_flag: show(p) save(p) # Pause after each iteration if show is True if show_flag: input('Press ENTER to continue')
colormap = {'setosa': 'red', 'versicolor': 'green', 'virginica': 'blue'} flowers['color'] = flowers['species'].map(lambda x: colormap[x]) source = ColumnDataSource(data=dict(petal_length=flowers['petal_length'], petal_width=flowers['petal_width'], 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())
def survey(): if request.method == "GET": return render_template('survey.html') else: #Request was a POST user_input = pd.DataFrame(data=[[request.form['Average_Sleep'], request.form['Sex'], request.form['Marital'], request.form['Employment'], request.form['Physical_QoL'], request.form['Mental_QoL'], request.form['Physical_Activity'], request.form['Race'], request.form['Age'], request.form['Weight'], request.form['Height_feet'], request.form['Height_inches'], request.form['Education'], request.form['Income'], request.form['Soda_Consumption'], request.form['Sugary_Drink_Consumption'], request.form['ALCDAY5'], request.form['AVEDRNK2'], request.form['Smoker_Status'], request.form['Marijuana_Use'], request.form['Calorie_Informed_Choices'], request.form['HeartAttackOutcomeDummy'], request.form['AnginaCoronaryHDOutcomeDummy'], request.form['StrokeOutcomeDummy'], request.form['AsthmaLifetimeOutcomeDummy'], request.form['SkinCancerOutcomeDummy'], request.form['OtherCancerOutcomeDummy'], request.form['COPDEmphysemaChronicBroncOutcomeDummy'], request.form['ArthritisOutcomeDummy'], request.form['DepressionOutcomeDummy'], request.form['KidneyDiseaseOutcomeDummy'], request.form['Life_Satisfaction']]], columns=['Average Sleep', 'Sex', 'Marital', 'Employment', 'Physical QoL', 'Mental QoL', 'Physical Activity', 'Race', 'Age', 'Weight', 'Height_feet','Height_inches', 'Education', 'Income', 'Soda Consumption', 'Sugary Drink Consumption', 'Alcohol Days', 'Alcohol Drinks','Smoker Status', 'Marijuana Use', 'Calorie Informed Choices', 'HeartAttackOutcomeDummy', 'AnginaCoronaryHDOutcomeDummy', 'StrokeOutcomeDummy', 'AsthmaLifetimeOutcomeDummy', 'SkinCancerOutcomeDummy', 'OtherCancerOutcomeDummy', 'COPDEmphysemaChronicBroncOutcomeDummy', 'ArthritisOutcomeDummy', 'DepressionOutcomeDummy', 'KidneyDiseaseOutcomeDummy', 'Life Satisfaction'], dtype=np.float)#.astype(float) #return model1.predict(transform(user_input)) # print(user_input.values) prediction=model1.predict_proba(transform(user_input).values)[-1][-1] def risk_category(risk_probability): """ Takes a risk probability (e.g., "prediction") as a float and returns the corresponding risk level category as a string. @risk_probably: float @reutnr: str """ if risk_probability < 0.25: return "Low Risk" if risk_probability >= 0.25 and risk_probability < 0.50: return "Low Moderate Risk" if risk_probability >=.50 and risk_probability < 0.75: return "High Moderate Risk" else: return "High Risk" def adjusted_risk(user_input): #Need to test this function """ Takes DataFrame of user_input, transforms it, and calculates adjusted predicted risk based on changes to modifible health behaviors. Returns a new adjusted probability (float) and the list of suggested health behavior changes contributing to the reduced risk. @user_input: DataFrame @return: float, list<str> """ transformed_df = transform(user_input) suggested_modifications = [] #Append to suggested modification list #Sets sleep to average sleep recommended for adults 18 - 64 yrs #(7-9 hrs), adults 65+ (7-8 hrs) by National Sleep Foundation if transformed_df['Average Sleep'].values[0] < 7.0 or transformed_df['Average Sleep'].values[0] > 9.0: orig_sleep = transformed_df['Average Sleep'].values[0] transformed_df['Average Sleep'].values[0] = 8.0 suggested_modifications.append("Get an average of 8.0 hours of sleep per night instead of "+ str(orig_sleep)+ " hours.") #Sets Physical Activity to had physical activity in past 30 days if transformed_df['Physical Activity'].values[0] == 0: transformed_df['Physical Activity'].values[0] = 1 suggested_modifications.append("Incorporate a regular exercise routine into your schedule – this could be as simple as walking versus driving to the corner store or taking the stairs instead of the elevator.") #Sets Obese -> Overweight and Overweight -> Normal weight if transformed_df['BMI'].values[0] == 3.0 or transformed_df['BMI'].values[0] == 4.0: orig_BMI = transformed_df['BMI'].values[0] transformed_df['BMI'].values[0] = transformed_df['BMI'].values[0] - 1.0 if orig_BMI == 3.0: orig_BMI = "Overweight (BMI: 25 – < 30)" suggested_BMI = "Normal Weight (BMI: 18.5 - < 25)" suggested_modifications.append("Reduce BMI through gradual, healthy weight loss from "+ orig_BMI+ " to "+ suggested_BMI+ ".") if orig_BMI == 4.0: orig_BMI = "Obese (BMI: >= 30)" suggested_BMI = "Overweight (BMI: 25 – < 30)" suggested_modifications.append("Reduce BMI through gradual, healthy weight loss from "+ orig_BMI+ " to "+ suggested_BMI+ ".") #Sets Underweight -> Normal weight if transformed_df['BMI'].values[0] == 1: transformed_df['BMI'].values[0] = transformed_df['BMI'].values[0] + 1.0 orig_BMI = "Underweight (BMI: < 18.5)" suggested_BMI = "Normal Weight (BMI: 18.5 - < 25)" suggested_modifications.append("Reduce BMI through gradual, healthy weight loss from "+ orig_BMI+ " to "+ suggested_BMI+ ".") #Sets Daily smokers -> Occasional smokers and Occasional smokers -> Former smokers if transformed_df['Smoker Status'].values[0] == 1.0 or transformed_df['Smoker Status'].values[0] == 2.0: orig_smoker = transformed_df['Smoker Status'].values[0] transformed_df['Smoker Status'].values[0] = transformed_df['Smoker Status'].values[0] + 1.0 if orig_smoker == 1.0: orig_smoker = "smoking every day" suggested_smoker = "smoking some days" suggested_modifications.append("Reduce smoking frequency from "+orig_smoker+" to "+suggested_smoker+ ".") if orig_smoker == 2.0: orig_smoker = "smoking some days" suggested_smoker = "former smoker (quit)" suggested_modifications.append("Reduce smoking frequency from "+orig_smoker+" to "+suggested_smoker+ ".") #Reduces weekly alcohol consumption by 25% (cutoff arbitrary) if transformed_df['Alcohol Consumption'].values[0] >= 1.0: orig_alcohol = transformed_df['Alcohol Consumption'].values[0] suggested_alcohol = transformed_df['Alcohol Consumption'].values[0]*0.25 transformed_df['Alcohol Consumption'].values[0] = transformed_df['Alcohol Consumption'].values[0]*0.25 suggested_modifications.append("Reduce average weekly alcohol consumption from " +str(orig_alcohol)+ " drink(s) per week to " +str(suggested_alcohol)+ " drink(s) per week.") #Sets 1-13 days poor Mental QoL -> 0 days and 14+ poor days -> 1-13 days if transformed_df['Mental QoL'].values[0] == 2.0 or transformed_df['Mental QoL'].values[0] == 3.0: #orig_mental = transformed_df['Mental QoL'].values[0] transformed_df['Mental QoL'].values[0] = transformed_df['Mental QoL'].values[0] - 1.0 suggested_modifications.append("Consider consulting a psychologist/psychiatrist to learn tools for coping with stress and emotional difficulties in order to improve your mental health.") return (transformed_df, suggested_modifications) adjusted_prediction=model1.predict_proba(adjusted_risk(user_input)[0].values)[-1][-1] modification_list=adjusted_risk(user_input)[1] #Gauge Chart Rendering xdr = Range1d(start=-1.25, end=1.25) ydr = Range1d(start=-1.25, end=1.25) plot = Plot(x_range=xdr, y_range=ydr, plot_width=500, plot_height=500) plot.title.text = "Predicted Diabetes Risk" plot.toolbar_location = None start_angle = pi + pi/4 end_angle = -pi/4 max_kmh = 1.0 max_mph = 1.0 major_step, minor_step = .25, .05 plot.add_glyph(Circle(x=0, y=0, radius=1.00, fill_color="white", line_color="black")) plot.add_glyph(Circle(x=0, y=0, radius=0.05, fill_color="gray", line_color="black")) plot.add_glyph(Text(x=0, y=+0.15, text=["Current Risk Probability"], text_color="red", text_align="center", text_baseline="bottom", text_font_style="bold")) plot.add_glyph(Text(x=0, y=-0.15, text=["Adjusted Risk Probability"], text_color="blue", text_align="center", text_baseline="top", text_font_style="bold")) def data(value): """Shorthand to override default units with "data", for e.g. `Ray.length`. """ return dict(value=value, units="data") def speed_to_angle(speed, units): max_speed = max_kmh speed = min(max(speed, 0), max_speed) total_angle = start_angle - end_angle angle = total_angle*float(speed)/max_speed return start_angle - angle def add_needle(speed, units, color_choice, line_weight): angle = speed_to_angle(speed, units) plot.add_glyph(Ray(x=0, y=0, length=data(0.75), angle=angle, line_color=color_choice, line_width=line_weight)) plot.add_glyph(Ray(x=0, y=0, length=data(0.10), angle=angle-pi, line_color=color_choice, line_width=line_weight)) def polar_to_cartesian(r, alpha): return r*cos(alpha), r*sin(alpha) def add_gauge(radius, max_value, length, direction, color, major_step, minor_step): major_angles, minor_angles = [], [] major_labels, minor_labels = [], [] total_angle = start_angle - end_angle major_angle_step = float(major_step)/max_value*total_angle minor_angle_step = float(minor_step)/max_value*total_angle major_angle = 0 while major_angle <= total_angle: major_angles.append(start_angle - major_angle) major_angle += major_angle_step minor_angle = 0 while minor_angle <= total_angle: minor_angles.append(start_angle - minor_angle) minor_angle += minor_angle_step major_labels = [ major_step*i for i, _ in enumerate(major_angles) ] minor_labels = [ minor_step*i for i, _ in enumerate(minor_angles) ] n = major_step/minor_step minor_angles = [ x for i, x in enumerate(minor_angles) if i % n != 0 ] minor_labels = [ x for i, x in enumerate(minor_labels) if i % n != 0 ] glyph = Arc(x=0, y=0, radius=radius, start_angle=start_angle, end_angle=end_angle, direction="clock", line_color=color, line_width=2) plot.add_glyph(glyph) rotation = 0 if direction == 1 else -pi x, y = zip(*[ polar_to_cartesian(radius, angle) for angle in major_angles ]) angles = [ angle + rotation for angle in major_angles ] source = ColumnDataSource(dict(x=x, y=y, angle=angles)) glyph = Ray(x="x", y="y", length=data(length), angle="angle", line_color=color, line_width=2) plot.add_glyph(source, glyph) x, y = zip(*[ polar_to_cartesian(radius, angle) for angle in minor_angles ]) angles = [ angle + rotation for angle in minor_angles ] source = ColumnDataSource(dict(x=x, y=y, angle=angles)) glyph = Ray(x="x", y="y", length=data(length/2), angle="angle", line_color=color, line_width=1) plot.add_glyph(source, glyph) x, y = zip(*[ polar_to_cartesian(radius+2*length*direction, angle) for angle in major_angles ]) text_angles = [ angle - pi/2 for angle in major_angles ] source = ColumnDataSource(dict(x=x, y=y, angle=text_angles, text=major_labels)) glyph = Text(x="x", y="y", angle="angle", text="text", text_align="center", text_baseline="middle") plot.add_glyph(source, glyph) add_gauge(0.75, max_kmh, 0.05, +1, "red", major_step, minor_step) add_gauge(0.70, max_mph, 0.05, -1, "blue", major_step, minor_step) add_needle(prediction, "Current Risk", "red", 6) add_needle(adjusted_prediction, "Adjusted Risk", "blue", 3) script, div = components(plot) return render_template('orig_output.html', script=script, div=div, prediction=prediction, adjusted_prediction=adjusted_prediction, risk_level=risk_category(prediction), adjusted_risk_level=risk_category(adjusted_prediction), modifications=modification_list)
HEIGHT = 400 plot = Plot(x_range=xdr, y_range=ydr, min_border=50, plot_width=1000, plot_height=HEIGHT) line_glyph = Line(x="x", y="y", line_color="navy", line_width=2, line_dash="dashed") line = plot.add_glyph(source, line_glyph) circle = Circle(x="x", y="y2", size=6, line_color="red", fill_color="orange", fill_alpha=0.6) circle = plot.add_glyph(source, circle) pan = PanTool() wheel_zoom = WheelZoomTool() preview_save = SaveTool() plot.add_tools(pan, wheel_zoom, preview_save) # Add axes (Note it's important to add these before adding legends in side panels) plot.add_layout(LinearAxis(), 'below') plot.add_layout(LinearAxis(), 'left') #plot.add_layout(LinearAxis(), 'right') - Due to a bug cannot have two things on the right side
session.use_doc('glyph2_server') session.load_document(document) x = arange(-2*pi, 2*pi, 0.1) y = sin(x) 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)
def plot_system_metrics(self): self.figures = [] x_range = None # iterate over metrics e.g. cpu usage, gpu usage, i/o reads and writes etc # create a histogram per dimension and event for dimension in self.filtered_dimensions: self.sources[dimension] = {} for event in self.filtered_events: if event in self.system_metrics[dimension]: values = self.system_metrics[dimension][event] values = values[values[:, 0].argsort()] # set y ranges for cpu and gpu which are measured in percent if "Utilization" in dimension or "Memory" in dimension: y_range = (0, 102) else: y_range = ( np.min(values[-self.width:, 1]), np.max(values[-self.width:, 1]), ) # create figure: each system metric has its own figure if x_range == None: plot = figure( plot_height=200, plot_width=1000, x_range=(values[-self.width, 0], values[-1, 0]), y_range=y_range, tools= "crosshair,xbox_select,pan,reset,save,xwheel_zoom", ) x_range = plot.x_range else: plot = figure( plot_height=200, plot_width=1000, x_range=x_range, y_range=y_range, tools= "crosshair,xbox_select,pan,reset,save,xwheel_zoom", ) plot.xgrid.visible = False plot.ygrid.visible = False # create line chart for system metric source = ColumnDataSource( data=dict(x=values[:, 0], y=values[:, 1])) callback = CustomJS( args=dict(s1=source, div=self.div), code=""" console.log('Running CustomJS callback now.'); var inds = s1.selected.indices; console.log(inds); var line = "<span style=float:left;clear:left;font_size=13px><b> Selected index range: [" + Math.min.apply(Math,inds) + "," + Math.max.apply(Math,inds) + "]</b></span>\\n"; console.log(line) var text = div.text.concat(line); var lines = text.split("\\n") if (lines.length > 35) lines.shift(); div.text = lines.join("\\n");""", ) plot.js_on_event("selectiongeometry", callback) line = Line(x="x", y="y", line_color="blue") circle = Circle(x="x", y="y", fill_alpha=0, line_width=0) p = plot.add_glyph(source, line) p = plot.add_glyph(source, circle) # create tooltip for hover tool hover = HoverTool(renderers=[p], tooltips=[("index", "$index"), ("(x,y)", "($x, $y)")]) plot.xaxis.axis_label = "Time in ms" plot.yaxis.axis_label = dimension + "_" + event plot.add_tools(hover) # store figure and datasource self.figures.append(plot) self.sources[dimension][event] = source return self.figures
def index(): if request.method == 'GET': return render_template('index.html') else: if request.form.get("address"): app.address = request.form['address'] else: app.address = False app.dayofweek = request.form['dayofweek'] app.direction = request.form['direction'] app.timeofday = int(request.form['timeofday']) app.ampm = request.form['ampm'] if app.address == False: app.msg = 'You must enter your desired address.' return render_template('error_page.html', msg=app.msg) params = {'address': str(app.address)} r = (requests.get('https://maps.googleapis.com/maps/api/geocode/json', params=params)).json() app.formatted_address = r['results'][0]['formatted_address'] my_latitude = r['results'][0]['geometry']['location']['lat'] my_longitude = r['results'][0]['geometry']['location']['lng'] x_min = -74.293396 #longitude SW: 40.481965, -74.293396 NE:40.911486, -73.733866 x_max = -73.733866 #longitude y_min = 40.481965 #latitude y_max = 40.911486 #latitude mesh_space = 0.01 if my_latitude < y_min or my_latitude >= y_max or my_longitude < x_min or my_longitude >= x_max or app.address == "" or app.address == False: app.msg = 'The address you entered is outside the boundaries of NYC.' return render_template('error_page.html', msg=app.msg) centers_x, centers_rx = np.linspace(x_min, x_max, (x_max - x_min) / mesh_space, retstep="True") centers_y, centers_ry = np.linspace(y_min, y_max, (y_max - y_min) / mesh_space, retstep="True") my_center_id = get_center_id(my_longitude, my_latitude, x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max, mesh_space=mesh_space) input = open( '../network_mesh_space=0.01_day=' + str(app.dayofweek) + '.pickle', 'rb') network_df = pickle.load(input) input.close() input = open( '../main_data_mesh_space=0.01_day=' + str(app.dayofweek) + '.pickle', 'rb') data_df = pickle.load(input) input.close() ################################################## ########Bokeh MAP block############################## x_range = Range1d() y_range = Range1d() # JSON style string taken from: https://snazzymaps.com/style/1/pale-dawn map_options = GMapOptions(lat=my_latitude, lng=my_longitude, map_type="roadmap", zoom=13, styles=""" [{"featureType":"administrative","elementType":"all","stylers":[{"visibility":"on"},{"lightness":33}]}, {"featureType":"landscape","elementType":"all","stylers":[{"color":"#f2e5d4"}]}, {"featureType":"poi.park","elementType":"geometry","stylers":[{"color":"#c5dac6"}]}, {"featureType":"poi.park","elementType":"labels","stylers":[{"visibility":"on"},{"lightness":20}]}, {"featureType":"road","elementType":"all","stylers":[{"lightness":20}]}, {"featureType":"road.highway","elementType":"geometry","stylers":[{"color":"#c5c6c6"}]}, {"featureType":"road.arterial","elementType":"geometry","stylers":[{"color":"#e4d7c6"}]}, {"featureType":"road.local","elementType":"geometry","stylers":[{"color":"#fbfaf7"}]}, {"featureType":"water","elementType":"all","stylers":[{"visibility":"on"},{"color":"#acbcc9"}]}]""" ) plot = GMapPlot(x_range=x_range, y_range=y_range, map_options=map_options, title="" #plot_width=750, plot_height=750 ) plot.plot_width = 800 plot.plot_height = 800 source = ColumnDataSource(data=dict(lat=[my_latitude], lon=[my_longitude], fill=['orange', 'blue', 'green'])) circle = Circle(x="lon", y="lat", size=10, fill_color="fill", line_color="black") plot.add_glyph(source, circle) source = ColumnDataSource(data=dict( lat=[my_latitude - 0.005, my_latitude + 0.005], lon=[my_longitude - 0.005, my_longitude - 0.005], )) line = Line(x="lon", y="lat", line_width=2, line_color="green") plot.add_glyph(source, line) source = ColumnDataSource(data=dict( lat=[my_latitude + 0.005, my_latitude + 0.005], lon=[my_longitude - 0.005, my_longitude + 0.005], )) line = Line(x="lon", y="lat", line_width=2, line_color="green") plot.add_glyph(source, line) source = ColumnDataSource(data=dict( lat=[my_latitude - 0.005, my_latitude + 0.005], lon=[my_longitude + 0.005, my_longitude + 0.005], )) line = Line(x="lon", y="lat", line_width=2, line_color="green") plot.add_glyph(source, line) source = ColumnDataSource(data=dict( lat=[my_latitude - 0.005, my_latitude - 0.005], lon=[my_longitude - 0.005, my_longitude + 0.005], )) line = Line(x="lon", y="lat", line_width=2, line_color="green") plot.add_glyph(source, line) #hover.tooltips = [ #("index", "$index"), #("(x,y)", "($x, $y)"), #("radius", "@radius"), #("fill color", "$color[hex, swatch]:fill_color"), #("foo", "@foo"), #("bar", "@bar"), #] if app.ampm == "pm": app.timeofday = app.timeofday + 24 if app.direction == "from": n0 = network_df[app.timeofday][my_center_id] n0.sort(ascending=False, axis=1) n0 = n0.irow(range(20)) elif app.direction == "to": n0 = network_df[app.timeofday][:, my_center_id] n0.sort(ascending=False, axis=1) n0 = n0.irow(range(20)) #widths = [9,8,8,7,6,5,4,3,2,1] ww = 0. for index, row in n0.iteritems(): ww += 0.3 #p_i = get_center_coordinates(my_center_id,x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max,mesh_space=mesh_space) p_f = get_center_coordinates(index, x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max, mesh_space=mesh_space) ss = ColumnDataSource(data=dict( lat=[my_latitude, p_f[1]], lon=[my_longitude, p_f[0]], )) line = Line(x="lon", y="lat", line_width=ww) plot.add_glyph(ss, line) pan = PanTool() wheel_zoom = WheelZoomTool() box_select = BoxSelectTool() plot.add_tools(pan, wheel_zoom, box_select) #xaxis = LinearAxis(axis_label="lat", major_tick_in=0, formatter=NumeralTickFormatter(format="0.000")) #plot.add_layout(xaxis, 'below') #yaxis = LinearAxis(axis_label="lon", major_tick_in=0, formatter=PrintfTickFormatter(format="%.3f")) #plot.add_layout(yaxis, 'left') overlay = BoxSelectionOverlay(tool=box_select) plot.add_layout(overlay) app.script, app.div = components(plot) ################################################## ################################################## ################################################## ########Bokeh FIG block############################## # select the tools we want TOOLS = "pan,wheel_zoom,box_zoom,reset,save" #print datetime.datetime(hour=int(33)/2, minute=int(33)%2*30) #print data_df.index p1 = figure(tools=TOOLS, plot_width=400, plot_height=400, x_axis_label='Time', y_axis_label='Number of trips') #,x_axis_type='datetime') p1.line((data_df.index) / 2, data_df['number_of_pickups_at_time_slot'], line_width=2, color="blue", legend="Total number of pickups in NYC in a typical day") p1.line((data_df.index) / 2, data_df['number_of_dropoffs_at_time_slot'], line_width=2, color="red", legend="Total number of dropoffs in NYC in a typical day") #p1.circle(dates, closing_prices, fill_color="red", size=6) #plots = {'Red': p1} #script_graph1, div_graph1 = components(plots) #app.script_graph1 = script_graph1 #app.div_graph1 = div_graph1.values()[0] ################################################## ################################################## ###ADD plot of NUMBER OF TRIPS (PICK UP AND DROPOFF FROM LOCATION) pickup_count = [0 for i in range(48)] dropoff_count = [0 for i in range(48)] for ind in network_df.index.levels[0]: try: pickup_count[ind] = network_df[ind][my_center_id].count() except KeyError: pass try: dropoff_count[ind] = network_df[ind][:, my_center_id].count() except KeyError: continue TOOLS = "pan,wheel_zoom,box_zoom,reset,save" p2 = figure(tools=TOOLS, plot_width=400, plot_height=400, x_axis_label='Time', y_axis_label='Number of trips') #,x_axis_type='datetime') p2.line(np.array(range(48)) / 2, pickup_count, line_width=2, color="blue", legend="Average pickups from your location") p2.line(np.array(range(48)) / 2, dropoff_count, line_width=2, color="red", legend="Average dropoffs at your location") #p1.circle(dates, closing_prices, fill_color="red", size=6) #plots2 = {'Red': p2} plots1and2 = gridplot([[p1, p2]]) script_graph2, div_graph2 = components(plots1and2) app.script_graph2 = script_graph2 app.div_graph2 = div_graph2 return redirect('/graph_page')
def generate_plot(self): """TODO: write this doc.""" tools = [ PanTool(), SaveTool(), WheelZoomTool(), ResetTool(), ] x_values = [] y_values = [] std_errors = [] models = self.data.index.levels[0].tolist() for model in models: values = self.data[self.measure[0]].loc[model].values mean = np.mean(values) stderr = np.around(st.sem(values, nan_policy='omit'), 5) n_parms = self.data['n_parms'].loc[model].values[0] x_values.append(n_parms) y_values.append(mean) std_errors.append(stderr) newData = pd.DataFrame.from_dict({ 'stderr': std_errors, 'mean': y_values, 'n_parms': x_values, 'modelname': models, }) # Drop any models with NaN values, since that means they had no # performance data for one or more columns. newData.dropna(axis=0, how='any', inplace=True) if newData.size == 0: self.script, self.div = ( "Error, no plot to display.", "None of the models contained valid performance data.") return dat_source = ColumnDataSource(newData) p = figure( tools=tools, x_axis_label=("N Parms, model prefix: {0}, " "suffix: {1}".format(self.pre, self.suf)), y_axis_label=("Mean {0}, +/- Standard Error".format( self.measure[0])), title="Mean {0} per Model vs Complexity".format(self.measure[0]), output_backend=OUTPUT_FORMAT, sizing_mode='stretch_both', ) circles = Circle( x='n_parms', y='mean', size=6, fill_color="navy", fill_alpha=0.7, ) circle_renderer = p.add_glyph(dat_source, circles) hover = self.create_hover() hover.renderers = [circle_renderer] p.add_tools(hover) #p.circle(x_values, y_values, size=6, color="navy", alpha=0.7) error_bars_x = [] error_bars_y = [] for i, std in enumerate(std_errors): error_bars_x.append([x_values[i], x_values[i]]) error_bars_y.append([y_values[i] - std, y_values[i] + std]) p.multi_line( error_bars_x, error_bars_y, color="firebrick", alpha=0.4, line_width=2, ) # workaround to prevent title and toolbar from overlapping grid = gridplot([p], ncols=GRID_COLS, sizing_mode='stretch_both') self.script, self.div = components(grid) self.plot = grid if self.display: show(grid)
def radialplot(tree, node_color='node_color', node_size='node_size', node_alpha='node_alpha', edge_color='edge_color', edge_alpha='edge_alpha', edge_width='edge_width', hover_var='hover_var', figsize=(500, 500), **kwargs): """ Plots unrooted radial tree. Parameters ---------- tree : instance of skbio.TreeNode Input tree for plotting. node_color : str Name of variable in `tree` to color nodes. node_size : str Name of variable in `tree` that specifies the radius of nodes. node_alpha : str Name of variable in `tree` to specify node transparency. edge_color : str Name of variable in `tree` to color edges. edge_alpha : str Name of variable in `tree` to specify edge transparency. edge_width : str Name of variable in `tree` to specify edge width. hover_var : str Name of variable in `tree` to display in the hover menu. figsize : tuple, int Size of resulting figure. default: (500, 500) **kwargs: dict Plotting options to pass into bokeh.models.Plot Returns ------- bokeh.models.Plot Interactive plotting instance. Notes ----- This assumes that the tree is strictly bifurcating. See also -------- bifurcate """ # TODO: Add in example doc string # This entire function was motivated by # http://chuckpr.github.io/blog/trees2.html t = UnrootedDendrogram.from_tree(tree) nodes = t.coords(figsize[0], figsize[1]) # fill in all of the node attributes def _retreive(tree, x, default): return pd.Series( {n.name: getattr(n, x, default) for n in tree.levelorder()}) # default node color to light grey nodes[node_color] = _retreive(t, node_color, default='#D3D3D3') nodes[node_size] = _retreive(t, node_size, default=1) nodes[node_alpha] = _retreive(t, node_alpha, default=1) nodes[hover_var] = _retreive(t, hover_var, default=None) edges = nodes[['child0', 'child1']] edges = edges.dropna(subset=['child0', 'child1']) edges = edges.unstack() edges = pd.DataFrame({ 'src_node': edges.index.get_level_values(1), 'dest_node': edges.values }) edges['x0'] = [nodes.loc[n].x for n in edges.src_node] edges['x1'] = [nodes.loc[n].x for n in edges.dest_node] edges['y0'] = [nodes.loc[n].y for n in edges.src_node] edges['y1'] = [nodes.loc[n].y for n in edges.dest_node] ns = [n.name for n in t.levelorder(include_self=True)] attrs = pd.DataFrame(index=ns) # default edge color to black attrs[edge_color] = _retreive(t, edge_color, default='#000000') attrs[edge_width] = _retreive(t, edge_width, default=1) attrs[edge_alpha] = _retreive(t, edge_alpha, default=1) edges = pd.merge(edges, attrs, left_on='dest_node', right_index=True, how='outer') edges = edges.dropna(subset=['src_node']) node_glyph = Circle(x="x", y="y", radius=node_size, fill_color=node_color, fill_alpha=node_alpha) edge_glyph = Segment(x0="x0", y0="y0", x1="x1", y1="y1", line_color=edge_color, line_alpha=edge_alpha, line_width=edge_width) def df2ds(df): return ColumnDataSource(ColumnDataSource.from_df(df)) ydr = DataRange1d(range_padding=0.05) xdr = DataRange1d(range_padding=0.05) plot = Plot(x_range=xdr, y_range=ydr, **kwargs) plot.add_glyph(df2ds(edges), edge_glyph) ns = plot.add_glyph(df2ds(nodes), node_glyph) tooltip = [("Feature ID", "@index")] if hover_var is not None: tooltip += [(hover_var, "@" + hover_var)] hover = HoverTool(renderers=[ns], tooltips=tooltip) plot.add_tools(hover, BoxZoomTool(), ResetTool()) return plot
WheelZoomTool) from bokeh.resources import INLINE x = arange(-2 * pi, 2 * pi, 0.1) y = sin(x) y2 = linspace(0, 100, len(y)) source = ColumnDataSource(data=dict(x=x, y=y, y2=y2)) plot = Plot(x_range=Range1d(start=-6.5, end=6.5), y_range=Range1d(start=-1.1, end=1.1), min_border=80) plot.extra_y_ranges = {"foo": Range1d(start=0, end=100)} circle = Circle(x="x", y="y", fill_color="red", size=5, line_color="black") plot.add_glyph(source, circle) plot.add_layout(LinearAxis(), 'below') plot.add_layout(LinearAxis(), 'left') circle2 = Circle(x="x", y="y2", fill_color="blue", size=5, line_color="black") plot.add_glyph(source, circle2, y_range_name="foo") plot.add_layout(LinearAxis(y_range_name="foo"), 'left') plot.add_tools(PanTool(), WheelZoomTool()) doc = Document() doc.add_root(plot)
map_options=map_options, api_key=API_KEY, ) plot.title.text = "Meteorite Landings" # Defining data elements (as lists) that will go into the Map and its Tooltip: source = ColumnDataSource(data=dict(lat=list(df.reclat), lon=list(df.reclong), fill=list(df.fill), mass=list(df.mass), year=list(df.year), recclass=list(df.recclass), name=list(df.name))) # Adding Map's Glyphs: circle = Circle(x="lon", y="lat", size=5, fill_color="fill", line_alpha=0) plot.add_glyph(source, circle) # Initializing and adding Map Tools to the plot object: pan = PanTool() wheel_zoom = WheelZoomTool() box_select = BoxSelectTool() box_zoom = BoxZoomTool() reset = ResetTool() # This allows you to specify what goes in the Map's Tooltip hover = HoverTool(tooltips=[("Class", "@recclass"), ( "Name", "@name"), ("Year", "@year"), ("(lat, long)", "(@lat, @lon)"), ("Mass", "@mass")]) plot.add_tools(pan, wheel_zoom, box_select, box_zoom, reset, hover)