def populate_glyphs(self):
self.plot.renderers=[]
self.plot.tools=[]
if self._show_counties:
print "showing you the counties"
#datasource = ColumnDataSource(county_data)
#apatch = Patches(xs=county_xs, ys=county_ys, fill_color='white')
#apatch = Patches(xs='xs', ys='ys', fill_color='colors', fill_alpha="alpha")
apatch = Patches(xs='xs', ys='ys', fill_color='thecolors', fill_alpha='alpha')
self.plot.add_glyph(self.county_source, apatch, name='counties')
if self._show_hotels:
print "showing you the hotels"
circle2 = Circle(x="lon", y="lat", size=10, fill_color="fill2", fill_alpha=1.0, line_alpha=0.0)
circle = Circle(x="lon", y="lat", size=10, fill_color="fill", fill_alpha=1.0, line_color="black")
#print "source is ", self.source['lon'], self.source['lat'], self.source['f1ll']
self.plot.add_glyph(self.source, circle, nonselection_glyph=circle2, name='hotels')
#county_xs, county_ys = get_some_counties()
rndr = self.plot.renderers[-1]
pan = PanTool()
wheel_zoom = WheelZoomTool()
box_select = BoxSelectTool()
box_select.renderers = [rndr]
tooltips = "@name"
tooltips = "<span class='tooltip-text'>@names</span>\n<br>"
tooltips += "<span class='tooltip-text'>Reviews: @num_reviews</span>"
hover = HoverTool(tooltips=tooltips, names=['hotels'])
tap = TapTool(names=['hotels'])
self.plot.add_tools(pan, wheel_zoom, box_select, hover, tap)
overlay = BoxSelectionOverlay(tool=box_select)
self.plot.add_layout(overlay)
def __init__(self, scheduler, width=800, **kwargs):
self.scheduler = scheduler
self.names = [
'worker', 'ncores', 'cpu', 'memory', 'memory_limit',
'memory_percent', 'num_fds', 'read_bytes', 'write_bytes',
'cpu_fraction'
]
table_names = [
'worker', 'ncores', 'cpu', 'memory', 'memory_limit',
'memory_percent', 'num_fds', 'read_bytes', 'write_bytes'
]
self.source = ColumnDataSource({k: [] for k in self.names})
columns = {
name: TableColumn(field=name, title=name.replace('_percent', ' %'))
for name in table_names
}
formatters = {
'cpu': NumberFormatter(format='0.0 %'),
'memory_percent': NumberFormatter(format='0.0 %'),
'memory': NumberFormatter(format='0 b'),
'memory_limit': NumberFormatter(format='0 b'),
'read_bytes': NumberFormatter(format='0 b'),
'write_bytes': NumberFormatter(format='0 b'),
'num_fds': NumberFormatter(format='0'),
'ncores': NumberFormatter(format='0')
}
table = DataTable(
source=self.source,
columns=[columns[n] for n in table_names],
row_headers=False,
reorderable=True,
sortable=True,
width=width,
)
for name in table_names:
if name in formatters:
table.columns[table_names.index(
name)].formatter = formatters[name]
hover = HoverTool(point_policy="follow_mouse",
tooltips="""
<div>
<span style="font-size: 10px; font-family: Monaco, monospace;">@host: </span>
<span style="font-size: 10px; font-family: Monaco, monospace;">@memory_percent</span>
</div>
""")
mem_plot = figure(title='Memory Use (%)',
toolbar_location=None,
x_range=(0, 1),
y_range=(-0.1, 0.1),
height=60,
width=width,
tools='',
**kwargs)
mem_plot.circle(source=self.source,
x='memory_percent',
y=0,
size=10,
fill_alpha=0.5)
mem_plot.ygrid.visible = False
mem_plot.yaxis.minor_tick_line_alpha = 0
mem_plot.xaxis.visible = False
mem_plot.yaxis.visible = False
mem_plot.add_tools(hover, BoxSelectTool())
hover = HoverTool(point_policy="follow_mouse",
tooltips="""
<div>
<span style="font-size: 10px; font-family: Monaco, monospace;">@worker: </span>
<span style="font-size: 10px; font-family: Monaco, monospace;">@cpu</span>
</div>
""")
cpu_plot = figure(title='CPU Use (%)',
toolbar_location=None,
x_range=(0, 1),
y_range=(-0.1, 0.1),
height=60,
width=width,
tools='',
**kwargs)
cpu_plot.circle(source=self.source,
x='cpu_fraction',
y=0,
size=10,
fill_alpha=0.5)
cpu_plot.ygrid.visible = False
cpu_plot.yaxis.minor_tick_line_alpha = 0
cpu_plot.xaxis.visible = False
cpu_plot.yaxis.visible = False
cpu_plot.add_tools(hover, BoxSelectTool())
self.cpu_plot = cpu_plot
if 'sizing_mode' in kwargs:
sizing_mode = {'sizing_mode': kwargs['sizing_mode']}
else:
sizing_mode = {}
self.root = column(cpu_plot,
mem_plot,
table,
id='bk-worker-table',
**sizing_mode)
v = np.arctan(x)
r = np.tan(x)
e = ColumnDataSource(dict(x=x, y=v))
f = ColumnDataSource(dict(x=x, y=r))
list_of_axis = [(a, b), (c, d), (e, f)]
hover = HoverTool(tooltips=[
("(x,y)", "($x, $y)"),
])
Tools = [
TapTool(),
BoxZoomTool(),
BoxSelectTool(),
PreviewSaveTool(),
ResetTool()
]
def update_title(new, radio, sources):
print("hello")
active_source = sources[radio.active]
factor = float(new)
x = active_source.data["x"]
y = factor * active_source.data["y"]
active_source.data = dict(x=x, y=y)
def CreateGraphVisualization(self):
Col1 = 120
Col2 = 10
Layouts = {
'Circular': nx.circular_layout,
'Spring': nx.spring_layout,
'Fruchterman': nx.fruchterman_reingold_layout,
'Spectral': nx.spectral_layout,
'Random': nx.random_layout,
'Shell': nx.shell_layout,
}
NodeColorProperty = self._settings['NodeColorProperty']
LineColorProperty = self._settings['LineColorProperty']
Iterations = self._settings['Iterations']
Layout = self._settings['Layout']
ShowRefNode = self._settings['ShowRefNode']
NodeSize = self._settings['NodeSize']
OpenBrowser = self._settings['Open plots in browser']
NodeDict = self.__CreateUniqueNodePropertyDict(NodeColorProperty)
LineDict = self.__CreateUniqueLinePropertyDict(LineColorProperty)
ColorList = list(colors.cnames.keys())
NodeColor = [
ColorList[Col2 + NodeDict[i[1][NodeColorProperty]]]
for i in self.__dssGraph.nodes(data=True)
]
self.__NodeList = list(NodeDict.keys())
self.__LineList = list(LineDict.keys())
self.__NodeColor = [
ColorList[Col2 + x] for x in range(len(self.__NodeList))
]
self.__LineColor = [
ColorList[Col1 + x] for x in range(len(self.__LineList))
]
try:
layout = Layouts[Layout](self.__dssGraph, iterations=Iterations)
except:
layout = Layouts[Layout](
self.__dssGraph
) #, k = 1.1/sqrt(self.__dssGraph.number_of_nodes()), iterations= 50)
NodeData = pd.DataFrame([[
i[0], layout[i[0]][0], layout[i[0]][1], i[1]['kVBase'],
i[1]['TotalMiles'], i[1]['NumNodes'], i[1]['N_Customers'],
i[1]['Distance'], i[1]['ConnectedPDs'], i[1]['ConnectedPCs']
] for i in self.__dssGraph.nodes(data=True)],
columns=[
'Name',
'X',
'Y',
'kVBase',
'TotalMiles',
'NumNodes',
'N_Customers',
'Distance',
'ConnectedPDs',
'ConnectedPCs',
]).set_index('Name')
NodeData['colors'] = NodeColor
self.DataSource = ColumnDataSource(NodeData)
hoverBus = HoverTool(tooltips=[
('Name', '@Name'),
("(x,y)", "(@X, @Y)"),
('kVBase', '@kVBase'),
('TotalMiles', '@TotalMiles'),
('NumNodes', '@NumNodes'),
('N_Customers', '@N_Customers'),
('Distance', '@Distance'),
('Connected PDs', '@ConnectedPDs'),
('Connected PCs', '@ConnectedPCs'),
])
Xs = []
Ys = []
LineColors = []
for Edge in self.__dssGraph.edges():
Node1 = list(Edge)[0]
Node2 = list(Edge)[1]
if ShowRefNode:
Xs.append([NodeData.loc[Node1]['X'], NodeData.loc[Node2]['X']])
Ys.append([NodeData.loc[Node1]['Y'], NodeData.loc[Node2]['Y']])
LineColors.append(ColorList[Col1 + LineDict[
self.__dssGraph[Node1][Node2][LineColorProperty]]])
else:
if Node2 != 'Ref Ground Node':
Xs.append(
[NodeData.loc[Node1]['X'], NodeData.loc[Node2]['X']])
Ys.append(
[NodeData.loc[Node1]['Y'], NodeData.loc[Node2]['Y']])
LineColors.append(ColorList[Col1 + LineDict[
self.__dssGraph[Node1][Node2][LineColorProperty]]])
self.__Figure = figure(
tools=[
ResetTool(), hoverBus,
BoxSelectTool(),
SaveTool(),
BoxZoomTool(),
WheelZoomTool(),
PanTool()
],
title="Distribution network graph representation",
plot_width=650,
plot_height=600,
)
if NodeSize:
C = self.__Figure.circle('X',
'Y',
source=self.DataSource,
size=NodeSize,
level='overlay',
color='colors',
legend='Nodes')
else:
C = self.__Figure.circle('X',
'Y',
source=self.DataSource,
level='overlay',
color='colors',
legend='Nodes')
L = self.__Figure.multi_line(Xs, Ys, color=LineColors, legend='Edges')
self.__Figure.legend.location = "top_left"
self.__Figure.legend.click_policy = "hide"
output_file(
os.path.join(self._settings['OutputPath'],
self._settings['OutputFile']))
doc = curdoc()
doc.add_root(self.__Figure)
doc.title = "PyDSS"
self.session = push_session(doc)
return
def save_graph(fol_path):
df = folderstats.folderstats(fol_path, ignore_hidden=True)
df.loc[list(np.where(df["folder"] == True)[0]),
"name"] = df[df["folder"] == True]["path"].apply(ret_name).values
# df["name"] = df["name"]+"."+df["extension"]
df_sorted = df.sort_values(by='id')
G = nx.Graph()
for i, row in df_sorted.iterrows():
if row.parent:
G.add_edge(row.id, row.parent)
plot = Plot(plot_width=1000,
plot_height=1000,
x_range=Range1d(-1.1, 1.1),
y_range=Range1d(-1.1, 1.1))
plot.title.text = "File System"
plot.add_tools(TapTool(), BoxSelectTool(), BoxZoomTool(), ResetTool(),
WheelZoomTool(), PanTool())
graph_renderer = from_networkx(G, nx.spring_layout, scale=2, center=(0, 0))
graph_renderer.node_renderer.data_source.data["id"] = df_sorted[
"id"].astype('str').values
graph_renderer.node_renderer.data_source.data["name"] = df_sorted["name"]
graph_renderer.node_renderer.data_source.data["links"] = df_sorted["path"]
graph_renderer.node_renderer.data_source.add(Spectral8, 'color')
graph_renderer.node_renderer.glyph = Circle(size=20, fill_color="color")
graph_renderer.node_renderer.selection_glyph = Circle(size=20,
fill_color="color")
graph_renderer.node_renderer.hover_glyph = Circle(size=20,
fill_color="color")
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
line_alpha=0.8,
line_width=5)
graph_renderer.edge_renderer.selection_glyph = MultiLine(
line_color=Spectral4[2], line_width=5)
graph_renderer.edge_renderer.hover_glyph = MultiLine(
line_color=Spectral4[1], line_width=5)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
pos = graph_renderer.layout_provider.graph_layout
x, y = zip(*pos.values())
url = "@links"
code = """
console.log(source.data)
var data = source.data.file;
var ind= cb_data.source.selected.indices;
console.log(data[ind])
window.open(data[ind])
//window.location.href = data[ind]
"""
source = ColumnDataSource({
'x': x,
'y': y,
'field': df_sorted["name"].values,
'file': df_sorted["path"].values
})
labels = LabelSet(x='x', y='y', text='field', source=source)
taptool = plot.select(type=TapTool)
taptool.callback = CustomJS(args=dict(source=source), code=code)
plot.renderers.append(graph_renderer)
plot.renderers.append(labels)
output_file("interactive_graphs.html")
show(plot)
source_low = ColumnDataSource(data=dict(
lat=full_data.query('interest_level=="low"')["latitude"].tolist(),
lon=full_data.query('interest_level=="low"')["longitude"].tolist()))
circle_low = Circle(x="lon",
y="lat",
size=2,
fill_color="green",
fill_alpha=0.3,
line_color=None)
plot.add_glyph(source_high, circle_high)
plot.add_glyph(source_medium, circle_medium)
plot.add_glyph(source_low, circle_low)
plot.add_tools(PanTool(), WheelZoomTool(), BoxSelectTool())
output_file("gmap_plot.html")
show(plot)
# # Conclusion
train_size = train_data.shape[0]
full_data['created_datetime'] = pd.to_datetime(full_data['created'],
format="%Y-%m-%d %H:%M:%S")
full_data['created_epoch'] = full_data['created_datetime'].apply(
lambda x: x.value // 10**9)
date_num_vars = ['created_epoch']
LBL = preprocessing.LabelEncoder()
LE_vars = []
<img
src="static/icons/date.png" height="25" alt="static/icons/date.png" width="25"
style="vertical-align: middle;"
></img>
<pbokeh style="vertical-align: middle; font-size: 15px; font-weight: bold;">@Date_String<pbokeh>
<img
src="static/icons/time.png" height="25" alt="static/icons/time.png" width="25"
style="vertical-align: middle;"
></img>
<pbokeh style="vertical-align: middle; font-size: 15px; font-weight: bold;">@Time_String</pbokeh>
</div>
</div>
""")
wheel_zoom_tool = WheelZoomTool()
box_select_tool = BoxSelectTool()
callback = CustomJS(args=dict(source=source),
code="""
var selected=source.selected['1d']['indices']
window.open(source.data.Url[selected]);
""")
tap_tool = TapTool(callback=callback)
pan_tool = PanTool()
fig.toolbar_location = 'above'
fig.toolbar.logo = None
fig.add_tools(pan_tool, wheel_zoom_tool, box_select_tool, hover_tool, tap_tool)
fig.toolbar.active_scroll = wheel_zoom_tool
fig.toolbar.active_drag = pan_tool
fig.toolbar.active_inspect = hover_tool
#set the google api key
color_palette = list(reversed(Viridis11[:8]))
mapper = LinearColorMapper(palette=color_palette, low=min_value, high=max_value)
color_bar = ColorBar(color_mapper = mapper, border_line_color = None, location = (0,0))
plot_color = figure(title="", x_axis_location="above", x_range=names2, y_range=list(reversed(names2)),toolbar_location = 'below')
plot_color.plot_width = 650
plot_color.plot_height = 650
plot_color.grid.grid_line_color = None
plot_color.axis.axis_line_color = None
plot_color.axis.major_tick_line_color = None
plot_color.axis.major_label_text_font_size = "5pt"
plot_color.axis.major_label_standoff = 0
plot_color.xaxis.major_label_orientation = np.pi/3
plot_color.add_tools(hover_am)
plot_color.add_tools(BoxSelectTool())
plot_color.rect('xname', 'yname', 0.9, 0.9, source=source, line_color=None, hover_line_color='black', fill_color={'field': 'count', 'transform': mapper})
plot_color.add_layout(color_bar, 'right')
# alpha matrix
plot_alpha = figure(title="", x_axis_location="above", x_range=names2, y_range=list(reversed(names2)),toolbar_location = 'below')
plot_alpha.plot_width = 650
plot_alpha.plot_height = 650
plot_alpha.grid.grid_line_color = None
plot_alpha.axis.axis_line_color = None
plot_alpha.axis.major_tick_line_color = None
plot_alpha.axis.major_label_text_font_size = "5pt"
plot_alpha.axis.major_label_standoff = 0
plot_alpha.xaxis.major_label_orientation = np.pi/3
plot_alpha.add_tools(hover_am)
def generate_chart(self):
"""
Description:
-------------------------------------------
Input:
-------------------------------------------
Ouput:
"""
if self.colors == []:
self.no_colors_set = True
self.colors = ["#8735fb"] * len(self.y)
if len(self.title) == 0:
self.title = "Stacked Line plots on x-axis: " + self.x
self.chart = figure(
title=self.title,
toolbar_location="right",
tools="pan, wheel_zoom, reset",
active_scroll="wheel_zoom",
active_drag="pan",
x_range=self.x_range,
y_range=self.y_range,
width=self.width,
height=self.height,
**self.library_specific_params,
)
self.chart.add_tools(BoxSelectTool(dimensions="width"))
if self.legend:
mapper = LinearColorMapper(palette=self.colors,
low=1,
high=len(self.y))
self.color_bar = ColorBar(
color_mapper=mapper,
location=(0, 0),
ticker=FixedTicker(ticks=list(range(1,
len(self.y) + 1))),
major_label_overrides=dict(
zip(list(range(1,
len(self.y) + 1)), self.y)),
major_label_text_baseline="top",
major_label_text_align="left",
major_tick_in=0,
major_tick_out=0,
)
self.chart.add_layout(self.color_bar, self.legend_position)
self.chart.xgrid.grid_line_color = None
self.chart.ygrid.grid_line_color = None
if self.x_axis_tick_formatter:
self.chart.xaxis.formatter = self.x_axis_tick_formatter
if self.y_axis_tick_formatter:
self.chart.yaxis.formatter = self.y_axis_tick_formatter
self.interactive_image = InteractiveImage(
self.chart,
self.generate_InteractiveImage_callback(),
data_source=self.source,
timeout=self.timeout,
x_dtype=self.x_dtype,
y_dtype=self.y_dtype,
)
def _init_fig(self):
self.fig.add_tools(BoxSelectTool(dimensions="width"))
self.fig.plot_height = 500
self.source = ColumnDataSource({'timestamp': [], self.feature: []})
self.fig.line('timestamp', self.feature, source=self.source)
p2 = figure(
# axis properties
x_range=ageQuantile,
y_range=(0, int(max(percentageAge)) + 1),
y_axis_label="Percentage of age group with a positive Covid-19 test",
x_axis_label="Age quantiles",
# plot properties
plot_height=250,
title="Percentage positive tests per age quantile",
toolbar_location="right",
tools=[
WheelZoomTool(),
ResetTool(),
PanTool(),
BoxSelectTool(), "save", "tap"
],
)
p2.x_range.max_interval = 19 # sets x-axis maximum
vbar_renderer = p2.vbar( # creates bars
x='x',
top='y',
width=0.5,
source=sourcep2, # defines source
color='blue', # default color of the bars
)
vbar_selected = VBar( # defines how a selected bar looks
fill_alpha=0.2,
return plot
plot_1 = create_graph(nx.circular_layout,
inspection_policy=NodesAndLinkedEdges(),
scale=1,
center=(0, 0))
plot_1.title.text = "Circular Layout (NodesAndLinkedEdges inspection policy)"
plot_1.add_tools(HoverTool(tooltips=None))
plot_2 = create_graph(nx.spring_layout,
selection_policy=NodesAndLinkedEdges(),
scale=2,
center=(0, 0))
plot_2.title.text = "Spring Layout (NodesAndLinkedEdges selection policy)"
plot_2.add_tools(TapTool(), BoxSelectTool())
plot_3 = create_graph(nx.random_layout,
inspection_policy=EdgesAndLinkedNodes(),
center=(0, 0))
plot_3.title.text = "Random Layout (EdgesAndLinkedNodes inspection policy)"
plot_3.add_tools(HoverTool(tooltips=None))
plot_4 = create_graph(nx.fruchterman_reingold_layout,
selection_policy=EdgesAndLinkedNodes(),
scale=2,
center=(0, 0),
dim=2)
plot_4.title.text = "FR Layout (EdgesAndLinkedNodes selection policy)"
plot_4.add_tools(TapTool())
def plot_data(data_df, connections, year, geoSource_new):
data_df_countries = data_df #.drop_duplicates(subset=None, keep='first', inplace=True)
connections_df = connections
node_source = ColumnDataSource(
data_df_countries[["country_id", "Country", "Longitude", "Latitude"]])
edge_source = ColumnDataSource(connections_df[["start", "end"]])
node_renderer = GlyphRenderer(data_source=node_source,
glyph=node_glyph,
selection_glyph=node_selection,
nonselection_glyph=node_nonselection)
## Create edge_renderer
edge_renderer = GlyphRenderer(data_source=edge_source,
glyph=edge_glyph,
hover_glyph=edge_hover,
selection_glyph=edge_selection,
nonselection_glyph=edge_nonselection)
## Create layout_provider
graph_layout = dict(
zip(data_df_countries.country_id.astype(str),
zip(data_df_countries.Longitude, data_df_countries.Latitude)))
layout_provider = StaticLayoutProvider(graph_layout=graph_layout)
## Create graph renderer
graph = GraphRenderer(edge_renderer=edge_renderer,
node_renderer=node_renderer,
layout_provider=layout_provider,
inspection_policy=NodesAndLinkedEdges(),
selection_policy=NodesAndLinkedEdges())
plot = Plot(x_range=Range1d(-150, 150),
y_range=Range1d(15, 75),
plot_width=800,
plot_height=600,
background_fill_color=Set3_12[4],
background_fill_alpha=0.2)
plot.title.text = "Human Trafficing Visualization for " + str(year)
# plot.add_glyph( geoSource_data, Patches(xs='xs', ys='ys', line_color='grey'
# , line_width=.5, fill_color=Set3_12[6], fill_alpha=0.25))
plot.add_glyph(
geoSource_new,
Patches(xs='xs',
ys='ys',
line_color='grey',
line_width=.2,
fill_color={
'field': 'Tier',
'transform': mapper2
},
fill_alpha=0.25))
plot.renderers.append(graph)
plot.add_layout(LinearAxis(axis_label="Latitude"), "below")
plot.add_layout(LinearAxis(axis_label="Longitude"), "left")
hover = HoverTool(
show_arrow=True, # tooltips= # [("Country Involved: ", "@Country")],
tooltips="""
<div>
<div>
<span style="font-size: 15px;">Country Information </span>
<span style="font-size: 12px; color: #696;">@Destination_Country </span>
</div>
</div>
""",
renderers=[graph])
hover_no_tooltips = HoverTool(tooltips=None, renderers=[graph])
box_zoom = BoxZoomTool()
plot.add_tools(hover, hover_no_tooltips, box_zoom, TapTool(),
BoxSelectTool(), ResetTool(), WheelZoomTool())
plot.toolbar.active_inspect = [hover, hover_no_tooltips]
plot.toolbar.active_drag = box_zoom
plot.outline_line_color = "navy"
plot.outline_line_alpha = 0.3
plot.outline_line_width = 3
plot.add_tile(STAMEN_TONER_LABELS)
return plot
("Length", "@length bp"),
("Protein Families", "@single_copy_PFAMs"),
("# Single Copies", "@num_single_copies"),
("GC%", "@gc %"),
("Kingdom", "@kingdom"),
("Phylum", "@phylum"),
("Class", "@class"),
("Order", "@order"),
("Family", "@family"),
("Genus", "@genus"),
("Species", "@species"),
("Tax ID", "@taxid"),
],
formatters={"Coverage": "printf", "Length": "printf", "GC%": "printf"},
),
BoxSelectTool(callback=contig_selection(source=source, source2=contigsList)),
LassoSelectTool(callback=contig_selection(source=source, source2=contigsList)),
TapTool(),
)
if args["legend"]:
cluster_plot.scatter(
x="bh_tsne_x",
y="bh_tsne_y",
source=source,
legend="cluster",
color="cluster",
fill_color=factor_cmap(
"cluster", palette=crcolor, factors=list(df.cluster.unique())
),
)
view_green_s4 = CDSView(source=s4, filters=[GroupFilter(column_name='ann', group='N')])
view_red_s4 = CDSView(source=s4, filters=[GroupFilter(column_name='ann', group='V')])
view_blue_s4 = CDSView(source=s4, filters=[GroupFilter(column_name='noise', group='True')])
# output to static HTML file
output_file("Poincare.html")
data.to_csv(r'C:\Users\Sujith Tenali\Desktop\zero11.csv')
# ------------------------------------------ FIGURE 1 ----------------------------------------------------------
# # configure visual properties on a plot's figure attribute
p1 = figure(output_backend="webgl", plot_width=700, plot_height=700)
p1.add_tools(BoxSelectTool())
p1.add_tools(PolySelectTool())
p1.toolbar.active_drag =BoxSelectTool()
p1.toolbar.active_scroll = None
p1.toolbar.active_tap = None
p1.toolbar.active_inspect = None
# p1.add_tools(TapTool())
p1.add_tools(HoverTool(
tooltips=[
('index', '$index'),
('(x,y)', '($x, $y)'),
('time', '@localtime{%c}'),
],
formatters={
def generate_chart(self):
"""
Description:
-------------------------------------------
Input:
-------------------------------------------
Ouput:
"""
if len(self.title) == 0:
self.title = "Graph"
self.x_range = (
self.x_range[0] - self.node_point_size,
self.x_range[1] + self.node_point_size,
)
self.y_range = (
self.y_range[0] - self.node_point_size,
self.y_range[1] + self.node_point_size,
)
self.chart = figure(
toolbar_location="right",
tools="pan, wheel_zoom, reset",
active_scroll="wheel_zoom",
active_drag="pan",
x_range=self.x_range,
y_range=self.y_range,
width=self.width,
height=self.height,
)
self.tile_provider = _get_provider(self.tile_provider)
if self.tile_provider is not None:
self.chart.add_tile(self.tile_provider)
self.chart.axis.visible = False
# reset legend and color_bar
self.legend_added = False
self.color_bar = None
# loading icon from a url
impath = (
"https://raw.githubusercontent.com/rapidsai/cuxfilter/" +
"branch-0.15/python/cuxfilter/charts/datashader/icons/graph.png")
self.inspect_neighbors = CustomInspectTool(
icon=load_image(impath),
_active=True,
tool_name="Inspect Neighboring Edges",
)
# loading icon from a url
impath = (
"https://raw.githubusercontent.com/rapidsai/cuxfilter/" +
"branch-0.15/python/cuxfilter/charts/datashader/icons/XPan.png")
self.display_edges = CustomInspectTool(icon=load_image(impath),
_active=True,
tool_name="Display Edges")
def cb(attr, old, new):
if new:
self.connected_edges = calc_connected_edges(
self.interactive_image.kwargs["data_source"],
self.edges,
self.node_x,
self.node_y,
self.node_id,
self.edge_source,
self.edge_target,
self.edge_aggregate_col,
self.x_dtype,
self.y_dtype,
self.edge_render_type,
self.curve_params,
)
self.interactive_image.update_chart()
self.display_edges.on_change("_active", cb)
self.chart.add_tools(BoxSelectTool())
self.chart.add_tools(LassoSelectTool())
self.chart.add_tools(self.inspect_neighbors)
self.chart.add_tools(self.display_edges)
self.chart.xgrid.grid_line_color = None
self.chart.ygrid.grid_line_color = None
self.interactive_image = InteractiveImage(
self.chart,
self.generate_InteractiveImage_callback(),
data_source=self.nodes,
timeout=self.timeout,
x_dtype=self.x_dtype,
y_dtype=self.y_dtype,
)
if self.legend_added is False:
self.render_legend()
def generateAreaSelection(dataframe, userWidth, userHeight, position_min,
position_max):
snps = dataframe
snps["log10"] = -numpy.log10(snps.pvalue_assoc) #transformation
snps = snps.sort_values(by="pvalue_assoc") # SORT BY P-VALUE
max_pvalue = int(snps.log10[0:1]) # GET MINIMUM P-VALUE
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#NEW COLUMNS AND RENAMING
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
snps['imp'] = numpy.where(snps['info_assoc'] == 1, snps['log10'],
'NaN') # gather information on imputed snps
snps['Imputed'] = numpy.where(
snps['info_assoc'] == 1, True,
False) #discriminate between imputed and genotyped for table
snps['interest'] = numpy.where(snps['log10'] >= (-numpy.log10(0.00000005)),
snps['log10'],
'NaN') #select snp of interest
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
source = ColumnDataSource(snps) # SOURCE DATA FOR BOKEH PLOT
TOOLS = [
HoverTool(tooltips=[("SNP", "@rs_id_assoc"), (
"Gene", "@gene"), ("P-value", "@pvalue_assoc"), ("Region",
"@func")]),
CrosshairTool(),
WheelZoomTool(),
BoxSelectTool(),
BoxZoomTool(),
ResizeTool(),
ResetTool(),
PanTool(),
PreviewSaveTool(),
TapTool()
]
stringLegend = "pvalue < " + str(0.001)
plot = figure(webgl=True,
tools=TOOLS,
x_axis_label='Position',
y_axis_label='-log10(p)',
plot_width=userWidth,
plot_height=userHeight,
x_range=(position_min - 150000, position_max + 150000),
y_range=(-3.2, max_pvalue + 3)
# y_range = (-1, max_pvalue+1)
)
plot.circle('position', 'log10', source=source, size=7, legend='Genotyped')
plot.square('position',
'imp',
source=source,
size=7,
color="olive",
legend='Imputed')
plot.circle('position',
'interest',
source=source,
size=7,
color="red",
legend=stringLegend)
snps = snps.sort_values(by="position") # SORT POSITIONS
snps.drop_duplicates(subset=('gene'), inplace=True,
keep="last") # TAKE GENE NAME DUPLICATES OFF
# for i in range(0,10):
# snps['ligne'+str(i+1)] = snps.start_gen[i:len(snps):10]
# snps['Fligne'+str(i+1)] = snps.end_gen[i:len(snps):10]
#
# positions = {
# 'ligne1' : -0.30,
# 'ligne2' : -0.55,
# 'ligne3' : -0.85,
# 'ligne4' : -1.15,
# 'ligne5' : -2.95,
# 'ligne6' : -2.65,
# 'ligne7' : -2.35,
# 'ligne8' : -2.05,
# 'ligne9' : -1.75,
# 'ligne10' : -1.45
# }
# for key, value in positions.items():
# print key, value
# plot.segment(snps[key], [value]*(len(snps)), snps['F'+key],[value]*(len(snps)), line_width=6, line_color="#8b4513",) #ligne 1
# # plot.text(snps[key]+((snps['F'+key]-snps[key])/2), [value-0.05]*(len(snps)), text=snps.gene, text_color='black', text_align='center', text_font_size='5pt', text_font_style='bold')
snps['ligne1'] = snps.start_gen[0:len(snps):10]
snps['Fligne1'] = snps.end_gen[0:len(snps):10]
snps['ligne2'] = snps.start_gen[1:len(snps):10]
snps['Fligne2'] = snps.end_gen[1:len(snps):10]
snps['ligne3'] = snps.start_gen[2:len(snps):10]
snps['Fligne3'] = snps.end_gen[2:len(snps):10]
snps['ligne4'] = snps.start_gen[3:len(snps):10]
snps['Fligne4'] = snps.end_gen[3:len(snps):10]
snps['ligne5'] = snps.start_gen[4:len(snps):10]
snps['Fligne5'] = snps.end_gen[4:len(snps):10]
snps['ligne6'] = snps.start_gen[5:len(snps):10]
snps['Fligne6'] = snps.end_gen[5:len(snps):10]
snps['ligne7'] = snps.start_gen[6:len(snps):10]
snps['Fligne7'] = snps.end_gen[6:len(snps):10]
snps['ligne8'] = snps.start_gen[7:len(snps):10]
snps['Fligne8'] = snps.end_gen[7:len(snps):10]
snps['ligne9'] = snps.start_gen[8:len(snps):10]
snps['Fligne9'] = snps.end_gen[8:len(snps):10]
snps['ligne10'] = snps.start_gen[9:len(snps):10]
snps['Fligne10'] = snps.end_gen[9:len(snps):10]
plot.segment(
snps.ligne1,
[-0.30] * (len(snps)),
snps.Fligne1,
[-0.30] * (len(snps)),
line_width=6,
line_color="#8b4513",
) #ligne 1
plot.text(snps.ligne1 + ((snps.Fligne1 - snps.ligne1) / 2),
[-0.25] * (len(snps)),
text=snps.gene,
text_color='black',
text_align='center',
text_font_size='1em',
text_font_style='bold')
plot.segment(
snps.ligne2,
[-0.55] * (len(snps)),
snps.Fligne2,
[-0.55] * (len(snps)),
line_width=6,
line_color="#8b4513",
) #ligne 2
plot.text(snps.ligne2 + ((snps.Fligne2 - snps.ligne2) / 2),
[-0.50] * (len(snps)),
text=snps.gene,
text_color='black',
text_align='center',
text_font_size='1em',
text_font_style='bold')
plot.segment(
snps.ligne3,
[-0.85] * (len(snps)),
snps.Fligne3,
[-0.85] * (len(snps)),
line_width=6,
line_color="#8b4513",
) #ligne 3
plot.text(snps.ligne3 + ((snps.Fligne3 - snps.ligne3) / 2),
[-0.80] * (len(snps)),
text=snps.gene,
text_color='black',
text_align='center',
text_font_size='1em',
text_font_style='bold')
plot.segment(
snps.ligne4,
[-1.15] * (len(snps)),
snps.Fligne4,
[-1.15] * (len(snps)),
line_width=6,
line_color="#8b4513",
) #ligne 4
plot.text(snps.ligne4 + ((snps.Fligne4 - snps.ligne4) / 2),
[-1.10] * (len(snps)),
text=snps.gene,
text_color='black',
text_align='center',
text_font_size='1em',
text_font_style='bold')
plot.segment(
snps.ligne10,
[-1.45] * (len(snps)),
snps.Fligne10,
[-1.45] * (len(snps)),
line_width=6,
line_color="#8b4513",
) #ligne 5
plot.text(snps.ligne10 + ((snps.Fligne10 - snps.ligne10) / 2),
[-1.40] * (len(snps)),
text=snps.gene,
text_color='black',
text_align='center',
text_font_size='1em',
text_font_style='bold')
plot.segment(
snps.ligne9,
[-1.75] * (len(snps)),
snps.Fligne9,
[-1.75] * (len(snps)),
line_width=6,
line_color="#8b4513",
) #ligne 6
plot.text(snps.ligne9 + ((snps.Fligne9 - snps.ligne9) / 2),
[-1.70] * (len(snps)),
text=snps.gene,
text_color='black',
text_align='center',
text_font_size='1em',
text_font_style='bold')
plot.segment(
snps.ligne8,
[-2.05] * (len(snps)),
snps.Fligne8,
[-2.05] * (len(snps)),
line_width=6,
line_color="#8b4513",
) #ligne 7
plot.text(snps.ligne8 + ((snps.Fligne8 - snps.ligne8) / 2),
[-2.00] * (len(snps)),
text=snps.gene,
text_color='black',
text_align='center',
text_font_size='1em',
text_font_style='bold')
plot.segment(
snps.ligne7,
[-2.35] * (len(snps)),
snps.Fligne7,
[-2.35] * (len(snps)),
line_width=6,
line_color="#8b4513",
) #ligne 8
plot.text(snps.ligne7 + ((snps.Fligne7 - snps.ligne7) / 2),
[-2.30] * (len(snps)),
text=snps.gene,
text_color='black',
text_align='center',
text_font_size='1em',
text_font_style='bold')
plot.segment(
snps.ligne6,
[-2.65] * (len(snps)),
snps.Fligne6,
[-2.65] * (len(snps)),
line_width=6,
line_color="#8b4513",
) #ligne 9
plot.text(snps.ligne6 + ((snps.Fligne6 - snps.ligne6) / 2),
[-2.60] * (len(snps)),
text=snps.gene,
text_color='black',
text_align='center',
text_font_size='1em',
text_font_style='bold')
plot.segment(
snps.ligne5,
[-2.95] * (len(snps)),
snps.Fligne5,
[-2.95] * (len(snps)),
line_width=6,
line_color="#8b4513",
) #ligne 10
plot.text(snps.ligne5 + ((snps.Fligne5 - snps.ligne5) / 2),
[-2.90] * (len(snps)),
text=snps.gene,
text_color='black',
text_align='center',
text_font_size='1em',
text_font_style='bold')
plot.grid.grid_line_color = None # TAKE GRID LINES OFF THE GRAPH
graph, div1 = components(plot, CDN)
return graph, div1
def create_plot(G, layout):
'''
Returns a bokeh plot using the given netowrkx graph and layout.
Depending on the layout the dimensions of the graphs grid change
Parameters:
G (networkx graph) : Netoworkx graph that will be plotted
layout (networkx layout): The layout of the network graph
Return:
plot (bokeh Plot): the plot generated using bokehs functions
'''
# the grouped layout is a special layout that uses the positions generated
# by makegraph.py
if layout == "grouped":
G, sidel = get_vertices()
hsidel = sidel / 2
plot = Plot(plot_width=1200,
plot_height=600,
x_range=Range1d(-(hsidel + .1), hsidel + .1),
y_range=Range1d(-(hsidel + .1), hsidel + .1),
align='center')
else:
plot = Plot(plot_width=1200,
plot_height=600,
x_range=Range1d(-2.1, 2.1),
y_range=Range1d(-2.1, 2.1),
align='center')
plot.title.text = "TV Shows Connected By Recommendation"
plot.background_fill_color = "black"
plot.background_fill_alpha = 0.1
if layout == "grouped":
pos_dict = {}
for node in G.nodes:
pos_dict[node] = G.nodes[node]["pos"]
graph_renderer = from_networkx(G,
pos_dict,
scale=hsidel,
center=(0, 0))
# The discover layout uses the positions assigned in discover.py
elif layout == "discover":
pos_dict = {}
for node in G.nodes:
pos_dict[node] = G.nodes[node]["pos"]
graph_renderer = from_networkx(G, pos_dict, scale=2, center=(0, 0))
else:
graph_renderer = from_networkx(G, layout, scale=2, center=(0, 0))
# The colors for each node is assigned using a scale and if the number of nodes goes over
# 256 the same color is used for the remaining nodes
if len(G.nodes) > 256:
Inferno = [Spectral4[1]] * len(G.nodes) - 256
Inferno.extend(viridis(len(G.nodes)))
else:
Inferno = list(viridis(len(G.nodes)))
source = graph_renderer.node_renderer.data_source
nodes = graph_renderer.node_renderer
edges = graph_renderer.edge_renderer
source.data['name'] = [x for x in source.data['index']]
source.data['colors'] = Inferno
nodes.glyph = Circle(size=15,
fill_color='colors',
fill_alpha=0.9,
line_color='colors')
nodes.selection_glyph = Circle(size=15,
fill_color=Plasma11[10],
fill_alpha=0.8)
nodes.hover_glyph = Circle(size=15, fill_color=Plasma11[9])
nodes.glyph.properties_with_values()
edges.glyph = MultiLine(line_color="black", line_alpha=0.1, line_width=2)
edges.selection_glyph = MultiLine(line_color=Plasma11[10], line_width=2)
edges.hover_glyph = MultiLine(line_color=Plasma11[9], line_width=2)
# This functions allow nodes to be highlighted when hovered over or clicked on
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = NodesAndLinkedEdges()
#graph_renderer.selection_policy = EdgesAndLinkedNodes()
# The tooltips to show the data for the plots
if layout == "grouped":
node_hover_tool = HoverTool(tooltips=[("", "@name"), ("", "@genre")])
else:
node_hover_tool = HoverTool(tooltips=[("", "@name")])
plot.add_tools(node_hover_tool, WheelZoomTool(), TapTool(),
BoxSelectTool())
plot.renderers.append(graph_renderer)
return plot
plot = GMapPlot(
x_range=DataRange1d(), y_range=DataRange1d(), map_options=map_options)
plot.title.text = "London Crime Correlation Heatmap"
# For GMaps to function, Google requires you obtain and enable an API key:
plot.api_key = "[ENTER YOUR GOOGLE MAP API KEY HERE]"
hover = HoverTool(tooltips=[("CountySel", "@acounty"),
("CountyComp", "@county"),
("Crime", "@acrime"),
("Lag","@lag")])
circle = Circle(x="longitude", y="latitude", size="size_mult", fill_color="color", fill_alpha=0.8, line_color=None)
plot.add_glyph(source, circle)
plot.add_tools(ResetTool(), PanTool(), WheelZoomTool(), BoxSelectTool(),hover)
def generic_update(attr,old, new):
global df, colors
df2 = df[(df.acounty==county_select.value) & (df.acrime == crime_select.value)]
source.data = dict(
acounty = df2.acounty,
acrime = df2.acrime,
county = df2.bcounty,
crime = df2.bcrime,
lag = df2.lag,
calc_cor = df2.calc_cor,
latitude= df2.latitude,
longitude = df2.longitude,
size_mult = df2.size_mult,
color = df2.color)
mapper = LinearColorMapper(palette=Purples9, low=user_node, high=0)
connections = list(node_color.values())
eigenv = list(eigenv.values())
between = list(between.values())
source = ColumnDataSource(pd.DataFrame.from_dict({k:v for k,v in BA.nodes(data=True)},orient='index'))
source.add(connections, "connections")
source.add(eigenv, "eigenv")
source.add(between, "between")
boxcolor = BoxAnnotation(fill_color='white', line_color='black')
plot_option = {
'background_fill_color': 'gray',
'background_fill_alpha': .5,
'tools': [PanTool(), WheelZoomTool(), TapTool(), BoxZoomTool(overlay=boxcolor), BoxSelectTool(overlay=boxcolor), ResetTool()],
'x_range': Range1d(-2,2),
'y_range': Range1d(-2,2),
}
plot = figure(**plot_option, x_axis_location=None, y_axis_location=None)
plot.title.text = "Barabasi-Albert Graph"
graph = from_networkx(BA, nx.spring_layout)
graph.node_renderer.data_source = source
graph.node_renderer.glyph = Circle(name="Node", size='node_size', fill_color={'field': 'node_color', 'transform': mapper})
graph.edge_renderer.selection_glyph = MultiLine(line_color='white', line_width=3)
plot.add_tools(HoverTool(name="Node", tooltips=[('Node', '$index'),
('Connections', '@connections'), ('Eigen Value', '@eigenv{.000000}'), ('Betweenness', '@between{.000000}'),
]))
graph.selection_policy = NodesAndLinkedEdges()
plot.renderers.append(graph)
def create(self):
manufacturers = sorted(mpg["manufacturer"].unique())
models = sorted(mpg["model"].unique())
transmissions = sorted(mpg["trans"].unique())
drives = sorted(mpg["drv"].unique())
classes = sorted(mpg["class"].unique())
manufacturer_select = Select(title="Manufacturer:", value="All", options=["All"] + manufacturers)
manufacturer_select.on_change('value', self.on_manufacturer_change)
model_select = Select(title="Model:", value="All", options=["All"] + models)
model_select.on_change('value', self.on_model_change)
transmission_select = Select(title="Transmission:", value="All", options=["All"] + transmissions)
transmission_select.on_change('value', self.on_transmission_change)
drive_select = Select(title="Drive:", value="All", options=["All"] + drives)
drive_select.on_change('value', self.on_drive_change)
class_select = Select(title="Class:", value="All", options=["All"] + classes)
class_select.on_change('value', self.on_class_change)
columns = [
TableColumn(field="manufacturer", title="Manufacturer", editor=SelectEditor(options=manufacturers), formatter=StringFormatter(font_style="bold")),
TableColumn(field="model", title="Model", editor=StringEditor(completions=models)),
TableColumn(field="displ", title="Displacement", editor=NumberEditor(step=0.1), formatter=NumberFormatter(format="0.0")),
TableColumn(field="year", title="Year", editor=IntEditor()),
TableColumn(field="cyl", title="Cylinders", editor=IntEditor()),
TableColumn(field="trans", title="Transmission", editor=SelectEditor(options=transmissions)),
TableColumn(field="drv", title="Drive", editor=SelectEditor(options=drives)),
TableColumn(field="class", title="Class", editor=SelectEditor(options=classes)),
TableColumn(field="cty", title="City MPG", editor=IntEditor()),
TableColumn(field="hwy", title="Highway MPG", editor=IntEditor()),
]
data_table = DataTable(source=self.source, columns=columns, editable=True)
plot = Plot(title=None, x_range= DataRange1d(), y_range=DataRange1d(), plot_width=1000, plot_height=300)
# Set up x & y axis
plot.add_layout(LinearAxis(), 'below')
yaxis = LinearAxis()
plot.add_layout(yaxis, 'left')
plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker))
# Add Glyphs
cty_glyph = Circle(x="index", y="cty", fill_color="#396285", size=8, fill_alpha=0.5, line_alpha=0.5)
hwy_glyph = Circle(x="index", y="hwy", fill_color="#CE603D", size=8, fill_alpha=0.5, line_alpha=0.5)
cty = plot.add_glyph(self.source, cty_glyph)
hwy = plot.add_glyph(self.source, hwy_glyph)
# Add the tools
tooltips = [
("Manufacturer", "@manufacturer"),
("Model", "@model"),
("Displacement", "@displ"),
("Year", "@year"),
("Cylinders", "@cyl"),
("Transmission", "@trans"),
("Drive", "@drv"),
("Class", "@class"),
]
cty_hover_tool = HoverTool(renderers=[cty], tooltips=tooltips + [("City MPG", "@cty")])
hwy_hover_tool = HoverTool(renderers=[hwy], tooltips=tooltips + [("Highway MPG", "@hwy")])
select_tool = BoxSelectTool(renderers=[cty, hwy], dimensions=['width'])
plot.add_tools(cty_hover_tool, hwy_hover_tool, select_tool)
controls = VBox(children=[
manufacturer_select, model_select, transmission_select,
drive_select, class_select])
top_panel = HBox(children=[controls, plot])
layout = VBox(children=[top_panel, data_table])
return layout
def make_pdf_plot(title, data, label='Temperature', pdf_function=norm):
x_length = 10000
if pdf_function == norm:
upper = data[1] + (data[2] * 5) #max(data[1] + 1,
lower = data[1] - (data[2] * 5
) #min(data[1] - 1, data[1] - (data[2] * 5))
elif pdf_function == beta:
upper = 1
lower = 0
else: #Gamma
lower = 0
upper = 1.5
step_size = (upper - lower) / x_length
x = np.linspace(lower, upper, x_length)
if pdf_function == gamma:
pdf = pdf_function.pdf(x, data[1], scale=data[2])
cdf = pdf_function.cdf(x, data[1], scale=data[2])
else:
pdf = pdf_function.pdf(x, data[1], data[2])
cdf = pdf_function.cdf(x, data[1], data[2])
if pdf_function != norm:
maximizer = lower + step_size * np.argmax(pdf)
else:
maximizer = data[1]
source = ColumnDataSource(
data=dict(x=[], y=[], width=[], height=[], prob=[], x0=[], x1=[]))
cdf = ColumnDataSource(data=dict(cdf=cdf))
bounds = ColumnDataSource(
data=dict(upper=[upper], lower=[lower], step=[step_size]))
#prob = ColumnDataSource(data=dict(prob=[0.0]))
callback = CustomJS(args=dict(source=source, cdf=cdf, bounds=bounds),
code="""
// get data source from Callback args
var data = source.data;
var cdf = cdf.data['cdf'];
//var prob = prob.data;
/// get BoxSelectTool dimensions from cb_data parameter of Callback
var geometry = cb_data['geometry'];
/// calculate Rect attributes
var x1 = geometry['x1']
var x0 = geometry['x0']
var width = geometry['x1'] - geometry['x0'];
var height = geometry['y1'] - geometry['y0'];
var x = geometry['x0'] + width/2;
//var y = geometry['y0'] + height/2;
var y = 0 + height/2;
var cdf1 = 0;
var cdf2 = 0;
var upper = bounds.data['upper'][0];
var lower = bounds.data['lower'][0];
var step = bounds.data['step'][0];
if (x0 >= upper) {
var cdf0 = cdf[9999];
} else if (x0 <= lower) {
var cdf0 = cdf[0];
} else {
var cdf0 = cdf[Math.round((x0 - lower) / step)];
}
if (x1 >= upper) {
var cdf1 = cdf[9999];
} else if (x1 <= lower) {
var cdf1 = cdf[0];
} else {
var cdf1 = cdf[Math.round((x1 - lower) / step)];
}
/// update data source with new Rect attributes
data['x'].pop();
data['y'].pop();
data['width'].pop();
data['height'].pop();
data['x'].push(x);
data['y'].push(y);
data['width'].push(width);
data['height'].push(height);
data['prob'].pop();
data['prob'].push(cdf1 - cdf0);
data['x0'].pop();
data['x1'].pop();
data['x0'].push(x0)
data['x1'].push(x1)
// emit update of data source
source.change.emit();
""")
box_select = BoxSelectTool(callback=callback, dimensions="width")
hover = HoverTool(tooltips=[
("Prob", "@prob"),
("(x0,x1)", "(@x0, @x1)"),
])
rect = Rect(
x='x',
y='y',
width='width',
height='height',
#tags=['cdf', cdf],
fill_alpha=0.3,
fill_color='#009933')
title = "%s: %f" % (title, maximizer)
p1 = figure(title=title,
tools="wheel_zoom,pan,reset,save",
background_fill_color="#E8DDCB",
toolbar_location="right")
p1.add_tools(box_select)
p1.add_tools(hover)
p1.toolbar.active_drag = box_select
p1.line(x, pdf, line_color="#D95B43", line_width=8,
alpha=0.7) #legend="PDF")
p1.legend.location = "center_right"
p1.legend.background_fill_color = "darkgrey"
p1.xaxis.axis_label = label
p1.yaxis.axis_label = 'Density' #'Pr(' + label + ')'
p1.add_glyph(source, rect, selection_glyph=rect, nonselection_glyph=rect)
return p1
plot_height=800,
plot_width=1500)
plot.title.text = "United States"
source = ColumnDataSource(data=dict(
lat=lat + 0.01 * np.random.normal(size=lat.size),
lon=lng + 0.01 * np.random.normal(size=lng.size),
ids=ids,
))
circle = Circle(x="lon",
y="lat",
size=8,
fill_color=(150, 0, 0),
fill_alpha=1,
line_color=None)
plot.add_glyph(source, circle)
hover = HoverTool()
hover.tooltips = collections.OrderedDict([
("ID", "@ids"),
])
plot.add_tools(hover, PanTool(), WheelZoomTool(), BoxSelectTool(), SaveTool())
output_file("gmap_plot.html", mode='inline')
show(plot) # opens a browser
# In[32]:
np.random.normal()
def clusterPlot(data_csv, l, kl, ku):
# data_csv = '../data/CA_WHS_HOUSEHOLD.csv'
# pick columns as field features
# l = ['HOUSEHOLD_CLAIMED_FAMILY_SIZE',
# 'HOUSEHOLD_REFUGEE_STATUS']
(kmeans, store_clusters, reduced_data,
clusters) = Cluster(data_csv, l, 2, 7)
colors = getcolors(clusters)
print(colors)
# clustering
output_file("clustering.html", title="Clustering Bokeh example")
#initialize our bokeh plot
x_min, x_max = reduced_data[:, 0].min() - 1, reduced_data[:, 0].max() + 1
y_min, y_max = reduced_data[:, 1].min() - 1, reduced_data[:, 1].max() + 1
tools = [
PanTool(),
BoxSelectTool(),
BoxZoomTool(),
ResetTool(),
HoverTool(tooltips=[("(x,y)", "($x, $y)")])
]
plot = figure(width=500,
height=500,
title='Clusters',
y_range=(y_min, y_max),
x_range=(x_min, x_max),
tools=tools)
#plot centroid / cluster center / group mean for each group
clus_xs = []
clus_ys = []
#we get the cluster x / y values from the k-means algorithm
for entry in kmeans.cluster_centers_:
clus_xs.append(entry[0])
clus_ys.append(entry[1])
#the cluster center is marked by a circle, with a cross in it
plot.circle_cross(x=clus_xs,
y=clus_ys,
size=40,
fill_alpha=0,
line_width=2,
color=colors)
plot.text(text=[''], x=clus_xs, y=clus_ys, text_font_size=['30pt'])
#text = ['setosa', 'versicolor', 'virginica']
i = 0 #counter
#begin plotting each petal length / width
#We get our x / y values from the original plot data.
#The k-means algorithm tells us which 'color' each plot point is,
#and therefore which group it is a member of.
for k, v in store_clusters.items():
v = np.asarray(v)
plot.scatter(v[:, 0], v[:, 1], color=colors[k], size=5)
#plot.select(dict(type=HoverTool)).tooltips = {"x":"$x", "y":"$y"}
script, div = components(plot)
#Export html construct for plotting in template
return script, div
##show(plot)
import networkx as nx
from bokeh.io import output_file, show
from bokeh.models import (BoxSelectTool, Circle, HoverTool, MultiLine,
NodesAndAdjacentNodes, Plot, Range1d, TapTool)
from bokeh.palettes import Spectral4
from bokeh.plotting import from_networkx
G=nx.karate_club_graph()
plot = Plot(width=400, height=400,
x_range=Range1d(-1.1,1.1), y_range=Range1d(-1.1,1.1))
plot.title.text = "Graph Interaction Demonstration"
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool())
graph_renderer = from_networkx(G, nx.circular_layout, scale=1, center=(0,0))
graph_renderer.node_renderer.glyph = Circle(size=15, fill_color=Spectral4[0])
graph_renderer.node_renderer.selection_glyph = Circle(size=15, fill_color=Spectral4[2])
graph_renderer.node_renderer.hover_glyph = Circle(size=15, fill_color=Spectral4[1])
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC", line_alpha=0.8, line_width=5)
graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color=Spectral4[2], line_width=5)
graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1], line_width=5)
graph_renderer.selection_policy = NodesAndAdjacentNodes()
graph_renderer.inspection_policy = NodesAndAdjacentNodes()
plot.renderers.append(graph_renderer)
def plot_hotspots(self,centroids, centroid_dictionary,num_datapoints, completed_rides=None, unfulfilled_rides=None):
'''
Takes in centroid values from self.create_centroids() and centroid_dictionary and plots the centroids relative to their
intensity. Optional inputs for the lat-long columns for completed_rides (green) and unfulfilled_rides(blue).
INPUT:
- centroids (numpy array)
- centroid_dict (dictionary)
- copmleted_rides (dataframe)(optional)
- unfulfilled_rides (dataframe)(optional)
OUTPUT:
-None
'''
#creating the plot
map_options = GMapOptions(lat=30.29, lng=-97.73, map_type="roadmap", zoom=11)
plot = GMapPlot(
x_range=DataRange1d(), y_range=DataRange1d(), map_options=map_options
)
plot.title.text = "Austin"
plot.api_key = "AIzaSyBx-cLXm4jxpg0aX_nnUnwd2hir3Ve0j9w"
#create alpha based on intensity
alpha = []
for key, value in centroid_dictionary.iteritems():
al_value = value[2]/float(num_datapoints)
al_fixed = al_value+.25
alpha.insert(key,al_fixed)
#try if completed_rides is populated
try:
completed_lats = list(completed_rides['start_location_lat'])
completed_longs = list(completed_rides['start_location_long'])
completed_source = ColumnDataSource( data=dict(
lat=completed_lats,
lon=completed_longs,))
completed_dots = Circle(x="lon", y="lat", size=15, fill_color="green", fill_alpha=0.1, line_color=None)
plot.add_glyph(completed_source, completed_dots)
except:
pass
#try if unfulfilled_rides is populated
try:
unfulfilled_lats = list(unfulfilled_rides['start_location_lat'])
unfulfilled_longs = list(unfulfilled_rides['start_location_long'])
unfulfilled_source = ColumnDataSource(
data=dict(
lat=unfulfilled_lats,
lon=unfulfilled_longs,))
unfulfilled_dots = Circle(x="lon", y="lat", size=15, fill_color="blue", fill_alpha=0.8, line_color=None)
plot.add_glyph(unfulfilled_source, unfulfilled_dots)
except:
pass
#creating centroid source and circle
centroidlats = centroids[:,0]
centroidlongs = centroids[:,1]
centroid_source = ColumnDataSource(
data=dict(
lat=centroidlats,
lon=centroidlongs,
alpha=alpha))
centroid_dots = Circle(x="lon", y="lat", size=45, fill_color='#8B008B', fill_alpha='alpha', line_color=None)
plot.add_glyph(centroid_source, centroid_dots)
#finishing the plot
plot.add_tools(PanTool(), WheelZoomTool(), BoxSelectTool())
show(plot)
def tripsPlot():
weights_y = None
df_solo_trips = []
df_companion_trips = []
try:
df_solo_trips = pd.read_sql_query("select * from trips where passenger_companion = '' ",
app.config['SQLALCHEMY_DATABASE_URI'])
except Exception as e:
pass
try:
df_companion_trips = pd.read_sql_query("select * from trips where passenger_companion != '' ",
app.config['SQLALCHEMY_DATABASE_URI'])
except Exception as e:
pass
if (len(df_solo_trips) == 0
and len(df_companion_trips) == 0):
return ["","",""]
# Make sure we have a default bar height
# in case there is no Weight data to show
weights_y = weights_y if weights_y is not None else [0,9]
highestWeight_y = int(sorted(weights_y)[-1])
lowestWeight_y = int(sorted(weights_y)[0])
# tripsBarHeight = height of the vertical bar
# which depends on max height of weights_y
# + 10%
# tripsBarStart = left start of the bar
# tripsBarEnd = right end of the bar
# tripsBarColors = global if one "color",
# individual if an array
# ["color_1", "color_2" [,...]]
# Solo trips horizontal bars data
tripsBarHeight = (highestWeight_y - lowestWeight_y) + (highestWeight_y - lowestWeight_y)*0.1
tripsBarStart = df_solo_trips['departure_date']
tripsBarEnd = df_solo_trips['return_date']
tripsBarColors = "red" # Or individual colors for each value ["Cyan", "red",...]
# Group trips horizontal bars data
tripsBarGroupStart = df_companion_trips['departure_date']
tripsBarGroupEnd = df_companion_trips['return_date']
tripsBarGroupColors = "blue"
# designing the plot style and information
hover = HoverTool(show_arrow=True,
point_policy='follow_mouse',
tooltips=[
("Trip from", " @left{%F}"),
("to", " @right{%F}")],
formatters={
# use 'datetime' formatter for 'date' fields
# default 'numeral' formatter for other fields
'@left' : 'datetime',
'@right' : 'datetime'})
box = BoxSelectTool()
wheel = WheelZoomTool()
panTool = PanTool()
boxZoomTool = BoxZoomTool()
resetTool = ResetTool()
TOOLS = [hover, box, wheel, panTool, boxZoomTool, resetTool]
fig = figure(title = 'Trips dates',
x_axis_label='Dates',
x_axis_type="datetime",
plot_width=650,
plot_height=450,
sizing_mode='scale_both',
tools=TOOLS)
fig.hbar(name = "red",
y = highestWeight_y*0.96,
height = tripsBarHeight,
left = tripsBarStart,
right = tripsBarEnd,
color = tripsBarColors)
fig.hbar(name = "blue",
y = highestWeight_y*0.96,
height = tripsBarHeight,
left = tripsBarGroupStart,
right = tripsBarGroupEnd,
color = tripsBarGroupColors)
# Technicalities to show the graph
curdoc().add_root(fig)
cdn_javascript = CDN.js_files[0]
bokehScriptComponent, bokehDivComponent = components(fig)
graph = [cdn_javascript, bokehScriptComponent, bokehDivComponent]
return graph
plot.title.text = "Austin"
source = ColumnDataSource(
data=dict(
lat=[30.2861, 30.2855, 30.2869],
lon=[-97.7394, -97.7390, -97.7405],
fill=['orange', 'blue', 'green']
)
)
circle = Circle(x="lon", y="lat", size=15, fill_color="fill", line_color="black")
plot.add_glyph(source, circle)
pan = PanTool()
wheel_zoom = WheelZoomTool()
box_select = BoxSelectTool()
plot.add_tools(pan, wheel_zoom, box_select)
xformatter = MercatorTickFormatter(dimension="lon")
xticker = MercatorTicker(dimension="lon")
xaxis = LinearAxis(formatter=xformatter, ticker=xticker)
plot.add_layout(xaxis, 'below')
yformatter = MercatorTickFormatter(dimension="lat")
yticker = MercatorTicker(dimension="lat")
yaxis = LinearAxis(formatter=yformatter, ticker=yticker)
plot.add_layout(yaxis, 'left')
doc = Document()
doc.add_root(plot)
def makeMatrix(self, ds, filterMin, filterMax, reorder):
# getting data from FileLoader and creating the right format
dataSetSort = DataSetSort()
if reorder == 0:
nodes = ds.getDoubleList(filterMin, filterMax, True)
elif reorder == 1:
dsCopy = DataSet(ds.getNodes())
dsCopy.makeUndirectionalAdd()
nodes = dsCopy.getDoubleList(filterMin, filterMax, True)
elif reorder == 2:
dataSetSort.DesConnectionSort(ds)
nodes = ds.getDoubleList(filterMin, filterMax, True)
elif reorder == 3:
dataSetSort.DesStrengthSort(ds)
nodes = ds.getDoubleList(filterMin, filterMax, True)
elif reorder == 4:
nodes = ds.distanceMatrix(True)
elif reorder == 5:
dataSetSort.robinsonSort(ds)
nodes = ds.getDoubleList(filterMin, filterMax, True)
names = ds.getNames()
yNames = names.copy()
yNames.reverse()
df = pd.DataFrame(
nodes,
columns=yNames,
index=names)
df.index.name = 'X'
df.columns.name = 'Y'
# Prepare data.frame in the right format
df = df.stack().rename("value").reset_index()
# Making the plot html file
output_file("matrixPlot.html")
# Creating the array containing the colors
colorList = []
i = 0
while i < 256:
color = wc.rgb_to_hex((255-(i-10), 255-(i-20), 255-(i-30)))
colorList.append(color)
i = i + 10
#colorList = [(23, 165, 137), (19, 141, 117), (40, 180, 99), (36, 113, 163)
# , (31, 97, 141), (17, 122, 101), (46, 134, 193), (34, 153, 84)]#,(202, 111, 30), (186, 74, 0)]
#colors = []
#for i in colorList:
# color = wc.rgb_to_hex(i)
# colors.append(color)
colors = colorList
# This part maps the colors at intervals
mapper = LinearColorMapper(
palette=colors, low=df.value.min(), high=df.value.max())
# Creating the figure
p = figure(
plot_width=500,
plot_height=500,
x_range=list(df.X.drop_duplicates()),
y_range=list(df.Y.drop_duplicates()),
# Adding a toolbar
#toolbar_location="right",
#tools="hover,pan,box_zoom,undo,redo,reset,save",
x_axis_location="above")
node_hover_tool = HoverTool(tooltips=[("Name X Axis", "@X"), ("Name Y Axis", "@Y"), ("Relation Strength", "@value")])
# plot.add_tools(node_hover_tool, BoxZoomTool(), ResetTool())
p.add_tools(node_hover_tool, TapTool(), BoxSelectTool(), BoxZoomTool(), UndoTool(), RedoTool())
p.toolbar_location = 'right'
# Create rectangle for heatmap
p.rect(
x="X",
y="Y",
width=1,
height=1,
source=ColumnDataSource(df),
line_color=None,
fill_color=transform('value', mapper))
# Add legend
color_bar = ColorBar(
color_mapper=mapper,
location=(0, 0),
ticker=BasicTicker(desired_num_ticks=len(colors)))
if len(list(df.X.drop_duplicates())) > p.plot_width / 10:
p.xaxis.visible = False
else:
pass
if len(list(df.Y.drop_duplicates())) > p.plot_height / 10:
p.yaxis.visible = False
else:
pass
p.xaxis.major_label_orientation = 'vertical'
p.add_layout(color_bar, 'right')
return p
line_alpha=0.5)
cty = plot.add_glyph(source, cty_glyph)
hwy = plot.add_glyph(source, hwy_glyph)
# Add the tools
tooltips = [
("Manufacturer", "@manufacturer"),
("Model", "@model"),
("Displacement", "@displ"),
("Year", "@year"),
("Cylinders", "@cyl"),
("Transmission", "@trans"),
("Drive", "@drv"),
("Class", "@class"),
]
cty_hover_tool = HoverTool(renderers=[cty],
tooltips=tooltips + [("City MPG", "@cty")])
hwy_hover_tool = HoverTool(renderers=[hwy],
tooltips=tooltips + [("Highway MPG", "@hwy")])
select_tool = BoxSelectTool(renderers=[cty, hwy], dimensions=['width'])
plot.add_tools(cty_hover_tool, hwy_hover_tool, select_tool)
layout = vplot(plot, data_table)
if __name__ == "__main__":
filename = "data_tables.html"
with open(filename, "w") as f:
f.write(file_html(layout, INLINE, "Data Tables"))
print("Wrote %s" % filename)
view(filename)
def large_plot(n):
from bokeh.models import (Plot, LinearAxis, Grid, GlyphRenderer,
ColumnDataSource, DataRange1d, PanTool,
ZoomInTool, ZoomOutTool, WheelZoomTool,
BoxZoomTool, BoxSelectTool, SaveTool, ResetTool)
from bokeh.models.layouts import Column
from bokeh.models.glyphs import Line
col = Column()
objects = set([col])
for i in xrange(n):
source = ColumnDataSource(data=dict(x=[0, i + 1], y=[0, i + 1]))
xdr = DataRange1d()
ydr = DataRange1d()
plot = Plot(x_range=xdr, y_range=ydr)
xaxis = LinearAxis(plot=plot)
yaxis = LinearAxis(plot=plot)
xgrid = Grid(plot=plot, dimension=0)
ygrid = Grid(plot=plot, dimension=1)
tickers = [
xaxis.ticker, xaxis.formatter, yaxis.ticker, yaxis.formatter
]
glyph = Line(x='x', y='y')
renderer = GlyphRenderer(data_source=source, glyph=glyph)
plot.renderers.append(renderer)
pan = PanTool()
zoom_in = ZoomInTool()
zoom_out = ZoomOutTool()
wheel_zoom = WheelZoomTool()
box_zoom = BoxZoomTool()
box_select = BoxSelectTool()
save = SaveTool()
reset = ResetTool()
tools = [
pan, zoom_in, zoom_out, wheel_zoom, box_zoom, box_select, save,
reset
]
plot.add_tools(*tools)
col.children.append(plot)
objects |= set([
xdr,
ydr,
xaxis,
yaxis,
xgrid,
ygrid,
renderer,
renderer.view,
glyph,
source,
source.selected,
source.selection_policy,
plot,
plot.x_scale,
plot.y_scale,
plot.toolbar,
plot.title,
box_zoom.overlay,
box_select.overlay,
] + tickers + tools)
return col, objects
