def create_transactor_figure(G):
plot = Plot(plot_width=800,
plot_height=600,
x_range=Range1d(-1.1, 1.1),
y_range=Range1d(-1.1, 1.1))
plot.title.text = "Transactor Visualization"
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool(),
WheelZoomTool(), PanTool())
graph_renderer = from_networkx(G, nx.spring_layout, scale=1, center=(0, 0))
graph_renderer.node_renderer.glyph = Circle(size=4,
fill_color=Spectral4[0])
graph_renderer.node_renderer.selection_glyph = Circle(
size=4, fill_color=Spectral4[2])
graph_renderer.node_renderer.hover_glyph = Circle(size=4,
fill_color=Spectral4[1])
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
line_alpha=0.8,
line_width=3)
graph_renderer.edge_renderer.selection_glyph = MultiLine(
line_color=Spectral4[2], line_width=3)
graph_renderer.edge_renderer.hover_glyph = MultiLine(
line_color=Spectral4[1], line_width=3)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
plot.renderers.append(graph_renderer)
return plot
def saveimg(smile, pltnm):
atorvastatin = Chem.MolFromSmiles(smile)
mh = Chem.AddHs(atorvastatin)
rdDistGeom.EmbedMolecule(mh)
_, res = rdEHTTools.RunMol(mh)
static_chgs = res.GetAtomicCharges()[:atorvastatin.GetNumAtoms()]
d = Draw.MolDraw2DCairo(400, 400)
SimilarityMaps.GetSimilarityMapFromWeights(atorvastatin,
list(static_chgs),
draw2d=d)
d.FinishDrawing()
thing = show_png(d.GetDrawingText())
name = "http://localhost:5006/fol/static/" + pltnm + ".png"
thing.save(
"C:\\Users\\patil.py\\Documents\\11F-Drive\\PFastWebLocalApp\\FlavorTool\\fol\\static\\"
+ pltnm + ".png")
p = figure(x_range=(0, 1),
y_range=(0, 1),
toolbar_location=None,
plot_width=200,
plot_height=200)
p.xgrid.grid_line_color = None
p.ygrid.grid_line_color = None
p.axis.visible = False
thing = WheelZoomTool()
p.add_tools(thing)
p.toolbar.active_scroll = thing
p.image_url(url=[name], x=0, y=1, w=1, h=1)
return p
def _set_tools(self):
wheel_zoom = WheelZoomTool()
pan = PanTool()
box_zoom = BoxZoomTool()
box_select = BoxSelectTool()
crosshair = CrosshairTool()
tap = TapTool()
save = SaveTool()
reset = ResetTool()
self.lasso_select = LassoSelectTool(
renderers=self.circles, # default = all available renderers
select_every_mousemove=False, # to enhance performance
)
self.lasso_select.overlay.line_alpha=0.9
self.lasso_select.overlay.line_color="black"
self.lasso_select.overlay.fill_alpha=0.2
self.lasso_select.overlay.fill_color="grey"
hover = self._get_hover_tool()
self.tools = (
pan, box_zoom, self.lasso_select, box_select,
crosshair, save, reset, tap, wheel_zoom
)
self.plot.add_tools(*self.tools)
def ridgeplot(courses_obj):
# first format 'courses_obj' into 'probly' DataFrame format
# courses_obj: [{'course_name': 'Calculus...', ...}, ...]
grades = [[100*y[2]/y[3] for y in x['assignments']] for x in courses_obj]
# turn this list of lists into a complete NumPy array
length = len(sorted(grades, key=len, reverse=True)[0])
grades = np.array([xi+[None]*(length-len(xi)) for xi in grades], dtype='float')
columns = [x['course_name'] for x in courses_obj]
grades = grades.transpose()
probly = pd.DataFrame(grades, columns=columns)
cats = list(reversed(probly.keys()))
palette = [cc.rainbow[i*15] for i in range(17)]
x = np.linspace(-20,110, 500)
source = ColumnDataSource(data=dict(x=x))
p = figure(y_range=cats, plot_width=900, plot_height = 300, x_range=(-5, 120))#, toolbar_location=None)
for i, cat in enumerate(reversed(cats)):
adjusted = probly[cat].replace([np.inf, -np.inf], np.nan).dropna(how="all")
if adjusted.size == 1 or pd.unique(adjusted).size == 1: # this means we can't compute
continue
pdf = gaussian_kde(adjusted)
#p = figure(plot_width=400, plot_height=400)
#p.line(x, pdf(x))
y = ridge(cat, pdf(x), scale=2)
#p.line(x, y, color='black')
#show(p)
source.add(y, cat)
p.patch('x', cat, color=palette[i], alpha=0.6, line_color="black", source=source)
p.outline_line_color = None
p.background_fill_color = "#efefef"
p.tools = [PanTool(), CrosshairTool(), HoverTool(), SaveTool(), BoxZoomTool(), WheelZoomTool(), ResetTool()]
ticks = list(np.array([np.array([0,3,7])+i*10 for i in range(10)]).flatten()) + [100]
p.xaxis.ticker = FixedTicker(ticks=ticks)
p.xaxis.formatter = PrintfTickFormatter(format="%d")
p.xaxis.axis_label = "Your Grade Distribution"
p.yaxis.axis_label = "Your Courses"
p.ygrid.grid_line_color = None
p.xgrid.grid_line_color = "Grey"
p.xgrid.ticker = p.xaxis[0].ticker
p.axis.minor_tick_line_color = None
p.axis.major_tick_line_color = None
p.axis.axis_line_color = None
p.y_range.range_padding = 0.12
return p
def create_viewer(title,
y_range,
toolbar_location=None,
toolbar_sticky=False,
tools="",
plot_width=annotatorSettings.viewerWidth,
plot_height=annotatorSettings.defaultViewerHeights,
x_axis_type='datetime',
add_tools=True):
viewer = figure(
title=title,
tools=tools,
plot_width=plot_width,
plot_height=plot_height,
toolbar_location=toolbar_location,
# toolbar_sticky=False,
x_axis_type=x_axis_type,
y_range=y_range,
)
viewer.xaxis.formatter = DatetimeTickFormatter(
years=["%F %T"],
months=["%F %T"],
days=["%F %T"],
hours=["%F %T"],
hourmin=["%F %T"],
minutes=["%F %T"],
minsec=["%F %T"],
seconds=["%F %T"],
milliseconds=["%F %T.%3N"],
)
# Create tools to add to ekgViewer.
wheel_zoom = WheelZoomTool()
tap_tool = TapTool()
resizeTool = ResizeTool()
box_select = BoxSelectTool(dimensions="width")
hover = HoverTool(
point_policy='snap_to_data',
line_policy='nearest',
tooltips=[
("index", "$index"),
("Time", "@x{%F %T.%3N %Z}"),
("Value", "@y"),
# ("Time", '@time'),
],
formatters={"x": "datetime"},
)
if add_tools:
viewer.add_tools(hover, box_select, tap_tool, resizeTool)
viewer.toolbar.active_drag = box_select
viewer.toolbar.active_scroll = wheel_zoom
viewer.toolbar.active_tap = tap_tool
return viewer
def _set_tools(self):
wheel_zoom = WheelZoomTool()
pan = PanTool()
box_zoom = BoxZoomTool()
box_select = BoxSelectTool()
crosshair = CrosshairTool()
tap = TapTool()
save = SaveTool()
lasso_select = LassoSelectTool(
select_every_mousemove=False, # enhance performance
)
code = """
var projections = require("core/util/projections");
var x = special_vars.x
var y = special_vars.y
var coords = projections.wgs84_mercator.inverse([x, y])
return coords[%d].toFixed(2)
"""
tooltips = '''
<style>
.bk-tooltip>div:not(:nth-child(-n+5)) {{
display:none;
}}
.bk-tooltip>div {{
background-color: #dff0d8;
padding: 5px;
}}
</style>
<b>STATION: </b> @{STNNBR} <br />
<b>LON: </b> @X_WMTS{custom} <br />
<b>LAT: </b> @Y_WMTS{custom} <br />
'''
hover = HoverTool(toggleable=True,
mode='mouse',
tooltips=tooltips,
renderers=[self.env.wmts_map_scatter],
formatters={
'X_WMTS': CustomJSHover(code=code % 0),
'Y_WMTS': CustomJSHover(code=code % 1),
})
tools = (pan, box_zoom, lasso_select, hover, crosshair, tap,
wheel_zoom)
self.env.wmts_map.add_tools(*tools)
# set defaults
self.env.wmts_map.toolbar.active_drag = pan
self.env.wmts_map.toolbar.active_inspect = [crosshair, hover]
self.env.wmts_map.toolbar.active_scroll = wheel_zoom
self.env.wmts_map.toolbar.active_tap = None
def workloadplot(courses_obj, is_ridge=True):
# we just need to first get a list of lists of dicts
# each sublist is a separate course
# within each sublist you're gonna have a bunch of datetimes
# for each datetime, you want to repeat it depending on the category
datetimes = [[[xi[5]]*repeat(xi[1].lower()) for xi in x['assignments']] for x in courses_obj]
datetimes = [list(itertools.chain.from_iterable(x)) for x in datetimes]
datetimes = pd.DataFrame(datetimes, index=[x['course_name'] for x in courses_obj]).transpose()
datetimes = datetimes.apply(pd.to_datetime) # convert to datetime
datetimes = pd.DataFrame([datetimes[x].dt.week for x in datetimes])
counts = pd.DataFrame([datetimes[x].value_counts() for x in datetimes]).transpose()
#counts =
# use something like a[0].combine(pd.Series([0 for x in range(50)]), lambda x1, x2: x1 if type(x1)==type(pd.to_datetime('8/8/2018')) else pd.to_datetime('1/1/2018' ))
assert(datetimes.shape[1] == len(courses_obj))
# for each course, need a list where each element is the number of assignments
# due that week (by index)
first_date = time.mktime(datetimes.apply(min).min().timetuple())
last_date = time.mktime(datetimes.apply(max).max().timetuple())
x = np.arange(first_date, last_date+DIVISION, TWO_WEEKS)
x_ = np.linspace(0,101,2)
source = ColumnDataSource(data=dict(x_=x_))
cats = list(datetimes.keys())
p.outline_line_color = None
p.background_fill_color = "#efefef"
p.tools = [PanTool(), CrosshairTool(), HoverTool(), SaveTool(), BoxZoomTool(), WheelZoomTool(), ResetTool()]
p.xaxis.axis_label = "Your Workload Over Time"
p.yaxis.axis_label = "Your Courses"
p.ygrid.grid_line_color = None
p.xgrid.grid_line_color = "Grey"
#ticks = ['Beginning', 'End']
#p.xaxis.ticker = FixedTicker(ticks=ticks)
p.xgrid.ticker = p.xaxis[0].ticker
p.axis.minor_tick_line_color = None
p.axis.major_tick_line_color = None
p.axis.axis_line_color = None
p.y_range.range_padding = 0.8
#p.y_range.group_padding = 3
return p
def gradesplot(course_obj):
assignment_array = course_obj['assignments']
assignment_array.reverse()
all_categories = get_categories(assignment_array)
# get a list of lists
# so each list within has all of the assignments belonging to that category/group
data = []
for category in all_categories:
category_data = []
for assignment in assignment_array:
if assignment[1] == category:
category_data.append(assignment)
data.append(category_data)
p = figure(x_axis_type="datetime", plot_width=1000, plot_height=300, y_range=(50,120))
p.title.text = "Grades over time"
colors = Spectral[len(all_categories)] if len(all_categories) >= 3 else Spectral[3][:len(all_categories)]
assert(len(data) == len(all_categories) == len(colors))
for datum, category, color in zip(data, all_categories, colors):
df = pd.DataFrame(datum)
df = df.rename({0:'name',1:'grouping', 2:'score', 3:'possible',4:'assigned',5:'due'}, axis='columns')
df['due'] = pd.to_datetime(df['due'])
source = ColumnDataSource(data=dict(
x=df['due'],
y=100*df['score']/df['possible'],
category=df['grouping'],
name=df['name']
))
p.line('x', 'y', line_width=2, color=color, source=source, legend=category, tags=[category])
p.circle('x', 'y', color=color, legend=category, source=source, tags=[category])
p.ygrid.grid_line_alpha = 0.75
p.ygrid.grid_line_color = "Black"
p.legend.location = "bottom_left"
p.legend.click_policy="hide"
p.legend.label_text_font_size = '8pt'
p.legend.spacing = -6
p.toolbar.logo = None
p.tools = [PanTool(), CrosshairTool(), HoverTool(), SaveTool(), BoxZoomTool(), WheelZoomTool(), ResetTool()]
hover = p.select(dict(type=HoverTool))
hover.tooltips = """
<style>
.bk-tooltip>div:not(:first-child) {display:none;}
</style>
<span style="font-size: 12px;">@name</span>
<span style="font-size: 10px;"> (@category) <br>
Grade: @y%</span>
"""
return p
def create_bar_chart(data,
title,
x_name,
y_name,
hover_tool=None,
width=1100,
height=400):
"""Creates a bar chart plot with the exact styling for the centcom
dashboard. Pass in data as a dictionary, desired plot title,
name of x axis, y axis and the hover tool HTML.
"""
source = ColumnDataSource(data)
xdr = FactorRange(factors=list(data[x_name]))
ydr = Range1d(start=0, end=max(data[y_name]) * 1.05)
tools = []
if hover_tool:
tools = [
hover_tool,
]
plot = figure(title=title,
x_range=xdr,
y_range=ydr,
plot_width=width,
plot_height=height,
min_border=0,
toolbar_location="above",
tools=tools,
outline_line_color="#666666")
glyph = VBar(x=x_name,
top=y_name,
bottom=0,
width=.8,
fill_color="#ffdf00")
plot.add_glyph(source, glyph)
plot.add_tools(WheelZoomTool())
plot.add_tools(BoxZoomTool())
plot.add_tools(ZoomOutTool())
xaxis = LinearAxis()
yaxis = LinearAxis()
plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker))
plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker))
plot.toolbar.logo = None
plot.min_border_top = 0
plot.xgrid.grid_line_color = None
plot.ygrid.grid_line_color = "#999999"
plot.yaxis.axis_label = "Weight"
plot.ygrid.grid_line_alpha = 0.1
plot.xaxis.axis_label = "Grouping"
plot.xaxis.major_label_orientation = 1
return plot
def makedoc(doc):
source = ColumnDataSource(dataframe)
image_holder = ColumnDataSource({
'image': [],
'x': [],
'y': [],
'dx': [],
'dy': []
})
tools = [
ResetTool(),
PanTool(),
WheelZoomTool(),
TapTool(),
BoxSelectTool(),
PolySelectTool(),
UndoTool(),
RedoTool()
]
pca = figure(title='PCA',
x_range=[minx - 0.05 * rangex, maxx + 0.05 * rangex],
y_range=[miny - 0.05 * rangey, maxy + 0.05 * rangey],
sizing_mode='scale_both',
tools=tools)
glyphs = pca.circle(source=source, x='x', y='y')
sel = figure(title='Selected image',
x_range=[0, 1],
y_range=[0, 1],
sizing_mode='scale_both')
image_canvas = sel.image_rgba('image',
'x',
'y',
'dx',
'dy',
source=image_holder)
def load_selected(attr, old, new):
print('new index: ', new.indices)
if len(new.indices) == 1: # could be empty selection
update_image_canvas_single(new.indices[0],
data=dataframe,
source=image_holder)
elif len(new.indices) > 1:
update_image_canvas_multi(new.indices,
data=dataframe,
source=image_holder)
glyphs.data_source.on_change('selected', load_selected)
fig = row([pca, sel], sizing_mode='stretch_both')
doc.title = 'Bokeh microscopium app'
doc.add_root(fig)
def create_figure(G, ntx):
plot = Plot(plot_width=800,
plot_height=600,
x_range=Range1d(-1.1, 1.1),
y_range=Range1d(-1.1, 1.1))
#plot.title.text = "BTC Block Visualization"
citation = Label(x=0, y=-20, x_units='screen', y_units='screen',
text='This block contains '+str(ntx)+\
' transactions between '+str(len(G.nodes()))+\
' addresses. The most active address transacted with '+str(max(list(dict(G.degree()).values())))+\
' addresses.',
render_mode='css',
border_line_color='red', border_line_alpha=1.0,
background_fill_color='white', background_fill_alpha=1.0)
#citation = Label(x=40, y=0, x_units='screen', y_units='screen',
# text='There were '+str(ntx)+' transactions total. The most active transactor was involved in '+str(max(list(dict(G.degree()).values())))+' transactions.',
# render_mode='css',
# border_line_color='black', border_line_alpha=1.0,
# background_fill_color='white', background_fill_alpha=1.0)
plot.add_layout(citation)
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool(),
WheelZoomTool(), PanTool())
graph_renderer = from_networkx(G,
nx.circular_layout,
scale=1,
center=(0, 0))
graph_renderer.node_renderer.glyph = Circle(size=4,
fill_color=Spectral4[0])
graph_renderer.node_renderer.selection_glyph = Circle(
size=4, fill_color=Spectral4[2])
graph_renderer.node_renderer.hover_glyph = Circle(size=4,
fill_color=Spectral4[1])
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
line_alpha=0.8,
line_width=3)
graph_renderer.edge_renderer.selection_glyph = MultiLine(
line_color=Spectral4[2], line_width=3)
graph_renderer.edge_renderer.hover_glyph = MultiLine(
line_color=Spectral4[1], line_width=3)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
plot.renderers.append(graph_renderer)
return plot
def _set_tools(self):
wheel_zoom = WheelZoomTool()
pan = PanTool()
box_zoom = BoxZoomTool()
box_select = BoxSelectTool()
crosshair = CrosshairTool()
tap = TapTool()
save = SaveTool()
reset = ResetTool() # TODO: add only to one plot, maybe with n_plot
self.lasso_select = LassoSelectTool(
renderers=self.circles, # default all available renderers
select_every_mousemove=False, # enhance performance
)
tooltips = '''
<style>
.bk-tooltip>div:not(:nth-child(-n+5)) {{
display:none;
}}
/* .bk-tooltip-custom + .bk-tooltip-custom {{
display: none; sometimes everything is hidden with this
}} */
.bk-tooltip>div {{
background-color: #dff0d8;
padding: 5px;
}}
</style>
<b>INDEX: </b> @INDEX <br>
<b>{x}: </b> @{x} <br>
<b>{x}_FLAG_W: </b> @{x}_FLAG_W <br>
<b>{y}: </b> @{y} <br>
<b>{y}_FLAG_W: </b> @{y}_FLAG_W <br>
'''.format(x=self.x, y=self.y)
hover = HoverTool( # TODO: try to make this toggleable
renderers=self.circles,
toggleable=True,
mode='mouse',
tooltips=tooltips,
)
tools = (
pan, box_zoom, self.lasso_select, box_select,
crosshair, save, reset, tap, wheel_zoom
)
self.plot.add_tools(*tools)
def plot_pulses2(self, km=False):
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from bokeh.resources import CDN
from bokeh.embed import components
from bokeh.mpl import to_bokeh
from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, HoverTool, SaveTool
lines = self.get_lines()
N = len(lines)
npoints = self.total_units / self.km2unit if km else self.total_units
fig = plt.figure(figsize=(12, 2 + N * 0.5))
ax = fig.add_subplot(111)
labels = ['IPP']
for i, line in enumerate(lines):
labels.append(line.get_name(channel=True))
l = ax.plot((0, npoints), (N - i - 1, N - i - 1))
points = [(tup[0], tup[1] - tup[0])
for tup in line.pulses_as_points(km=km) if tup != (0, 0)]
ax.broken_barh(points, (N - i - 1, 0.5),
edgecolor=l[0].get_color(),
facecolor='none')
n = 0
f = ((self.ntx + 50) / 100) * 5 if (
(self.ntx + 50) / 100) * 10 > 0 else 2
for x in np.arange(0, npoints,
self.ipp if km else self.ipp * self.km2unit):
if n % f == 0:
ax.text(x, N, '%s' % n, size=10)
n += 1
labels.reverse()
ax.set_yticks(range(len(labels)))
ax.set_yticklabels(labels)
ax.set_xlabel = 'Units'
plot = to_bokeh(fig, use_pandas=False)
plot.tools = [
PanTool(dimensions=['width']),
WheelZoomTool(dimensions=['width']),
ResetTool(),
SaveTool()
]
plot.toolbar_location = "above"
return components(plot, CDN)
def plot_layoult(title, grid1, save_figs=False, show_figs=True, grid2=None):
if title is None:
title='NOME DA FIGURA NAO FORNECIDO'
xwheel_zoom = WheelZoomTool(dimensions="width")
pan_tool = PanTool()
hover = HoverTool()
crosshair = CrosshairTool()
toolbar = Toolbar(
tools=[xwheel_zoom, pan_tool, hover, crosshair],
active_inspect=[crosshair],
# active_drag = # here you can assign the defaults
# active_scroll = # wheel_zoom sometimes is not working if it is set here
# active_tap
)
toolbar_box = ToolbarBox(toolbar=toolbar, toolbar_location="above")
if grid2 is None:
layout_2 = layout(children=[[
# toolbar_box,
grid1
]],
# sizing_mode="stretch_both",
# plot_width=400, plot_height=800,
)
else:
layout_2 = layout(children=[[
# toolbar_box,
[[grid1],
[grid2]]
]],
# sizing_mode="stretch_both",
# plot_width=3000, plot_height=1000,
)
if save_figs is True:
output_file(title + ".html")
if show_figs is True:
show(layout_2)
else:
save(layout_2)
else:
show(layout_2)
def addplot(self, curve, *args):
TOOLTIPS = [
("(curve)", "($name)"),
("(value)", "($x)")]
logIndex=len(self.plotlist)
r = lambda: random.randint(0,255)
colr='#{:02x}{:02x}{:02x}'.format(r(), r(), r())
if self.unitDict[curve] in ('ohmm', 'OHMM'):
self.figDict["fig{0}".format(logIndex)]=figure(x_axis_type="log", x_axis_location='above')
else:
self.figDict["fig{0}".format(logIndex)] = figure(tooltips=TOOLTIPS, x_axis_location='above')
# Define 1st LHS y-axis
self.figDict["fig{0}".format(logIndex)].yaxis.axis_label = str(self.curvename[0])+' (' + str(self.unitDict[self.curvename[0]])+ ')'
self.figDict["fig{0}".format(logIndex)].y_range = Range1d(start=max(self.df[self.curvename[0]]), end=min(self.df[self.curvename[0]]), bounds=(None,None))
# Define x-axis
self.figDict["fig{0}".format(logIndex)].xaxis.axis_label = str(curve) + ' ('+ str(self.unitDict[curve])+')'
self.figDict["fig{0}".format(logIndex)].x_range = Range1d(start=min(self.df[curve]), end=max(self.df[curve]))
#fig.xaxis.ticker=SingleIntervalTicker(interval=30)
self.figDict["fig{0}".format(logIndex)].xaxis.axis_label_text_color = colr
# Define x-axis curve
self.figDict["fig{0}".format(logIndex)].line(
y = self.df[self.curvename[0]],
x = self.df[curve],
name = str(curve),
color = colr
)
for curves in args:
colr='#{:02x}{:02x}{:02x}'.format(r(), r(), r())
#add more x-axis
self.figDict["fig{0}".format(logIndex)].extra_x_ranges [str(curves)] = Range1d(start=min(self.df[curves]), end=max(self.df[curves]))
self.figDict["fig{0}".format(logIndex)].add_layout(LinearAxis( x_range_name=curves,
axis_label=str(curves) + ' ('+ str(self.unitDict[curves])+')', axis_label_text_color = colr), 'above')
# Define other x-axis curve
self.figDict["fig{0}".format(logIndex)].line(
y = self.df[self.curvename[0]],
x = self.df[curves],
name = curves,
x_range_name = str(curves),
color = colr
)
self.plotlist.append(self.figDict["fig{0}".format(logIndex)])
self.figDict["fig{0}".format(logIndex)].tools=[WheelZoomTool(),PanTool(),ResetTool()]
self.figDict["fig{0}".format(logIndex)].add_tools(HoverTool(tooltips=TOOLTIPS))
return self.figDict["fig{0}".format(logIndex)]
def newplot(self, data, log, unit, *args):
curve= data[log]
TOOLTIPS = [
("(curve)", "($name)"),
("(value)", "($x)")]
logIndex=len(self.plotlist)
r = lambda: random.randint(0,255)
colr='#{:02x}{:02x}{:02x}'.format(r(), r(), r())
self.figDict["fig{0}".format(logIndex)] = figure(tooltips=TOOLTIPS, x_axis_location='above')
# Define 1st LHS y-axis
self.figDict["fig{0}".format(logIndex)].yaxis.axis_label = str(self.curvename[0])+' (' + str(self.unitDict[self.curvename[0]])+ ')'
self.figDict["fig{0}".format(logIndex)].y_range = Range1d(start=max(curve.index), end=min(curve.index), bounds=(None,None))
# Define x-axis
self.figDict["fig{0}".format(logIndex)].xaxis.axis_label = str(log) + ' ('+ str(unit)+')'
self.figDict["fig{0}".format(logIndex)].x_range = Range1d(start=min(curve), end=max(curve))
#fig.xaxis.ticker=SingleIntervalTicker(interval=30)
self.figDict["fig{0}".format(logIndex)].xaxis.axis_label_text_color = colr
# Define x-axis curve
self.figDict["fig{0}".format(logIndex)].line(
y = curve.index,
x = curve,
name = str(log),
color = colr
)
for curved in args:
curves=data[curved]
colr='#{:02x}{:02x}{:02x}'.format(r(), r(), r())
#add more x-axis
self.figDict["fig{0}".format(logIndex)].extra_x_ranges [str(curved)] = Range1d(start=min(curves), end=max(curves))
self.figDict["fig{0}".format(logIndex)].add_layout(LinearAxis( x_range_name=curved,
axis_label=str(curved) + ' ('+ str(unit)+')', axis_label_text_color = colr), 'above')
# Define other x-axis curve
self.figDict["fig{0}".format(logIndex)].line(
y = curves.index,
x = curves,
name = curved,
x_range_name = str(curved),
color = colr
)
self.plotlist.append(self.figDict["fig{0}".format(logIndex)])
self.figDict["fig{0}".format(logIndex)].tools=[WheelZoomTool(),PanTool(),ResetTool()]
self.figDict["fig{0}".format(logIndex)].add_tools(HoverTool(tooltips=TOOLTIPS))
return self.figDict["fig{0}".format(logIndex)]
def plot_perf(
data: pd.DataFrame,
mod: DirectReinforcementModel,
tail: int = config["chartTail"],
modelName: str = f"{config['modelName']} v{config['modelVersion']}",
) -> str: # returns HTML str
data = data.tail(tail)
data = DataVisualiser.add_positions_to_data(mod, data)
data = DataVisualiser.add_performance_to_data(mod, data)
p1 = figure(
x_axis_type="datetime",
title="Cumulative Returns by Strategy",
plot_width=800,
plot_height=500,
)
p1.grid.grid_line_alpha = 0.3
p1.xaxis.axis_label = "Date"
p1.yaxis.axis_label = "Cumulative Returns"
p1.toolbar.logo = None
p1.tools = [
PanTool(),
# SaveTool(),
WheelZoomTool(),
ResetTool(),
CrosshairTool(),
]
p1.line( # pylint: disable=too-many-function-args
datet(data.closeTimeIso),
data.modelReturnsCumSum,
color="#33A02C",
legend_label=modelName,
)
p1.line( # pylint: disable=too-many-function-args
datet(data.closeTimeIso),
data.buyHoldReturns,
color="#FB9A99",
legend_label="HODL",
)
return file_html(p1, CDN), data
def show_image(ds):
shape = ds['R'].shape
aspect = shape[1] / shape[0]
wheel_zoom = WheelZoomTool(zoom_on_axis=False)
image = (hv.RGB(ds, ['X', 'Y'], ['R', 'G', 'B'])).opts(
'RGB',
default_tools=['pan', wheel_zoom, 'tap', 'reset'],
active_tools=['tap', 'wheel_zoom'],
xaxis=None,
yaxis=None,
aspect=aspect,
responsive=True,
hooks=[remove_white_borders],
).opts(toolbar='above')
tap = hv.streams.Tap(source=image, x=shape[1], y=shape[0])
tap.param.watch(tap_update, ['x', 'y'])
return image
def render_from_fb_combined():
print('rendering from facebook_combined.txt')
df = pd.read_csv('facebook_combined.txt', sep=" ", header=None)
G = nx.from_pandas_edgelist(df.head(1000), 0, 1)
print(nx.info(G))
plot = Plot(background_fill_color="white",
sizing_mode="stretch_both",
x_range=Range1d(-0.5, 0.5), y_range=Range1d(-0.5, 0.5))
graph_renderer = from_networkx(
G, nx.spring_layout, scale=1, center=(0, 0))
graph_renderer.node_renderer.glyph = Circle(
size=15, fill_color=Spectral4[0])
graph_renderer.edge_renderer.glyph = MultiLine(
line_alpha=0.8, line_width=1)
plot.add_tools(WheelZoomTool())
plot.add_tools(ResetTool())
plot.add_tools(PanTool())
plot.add_tools(HoverTool(
tooltips=[("user", "datracka"), ("url", "https://twitter.com/datracka")]))
plot.add_tools(PointDrawTool(
renderers=[], empty_value='black'))
plot.axis.axis_line_width = 0
plot.grid.grid_line_width = 0
plot.xaxis.major_tick_line_color = None # turn off x-axis major ticks
plot.xaxis.minor_tick_line_color = None # turn off x-axis minor ticks
plot.yaxis.major_tick_line_color = None # turn off y-axis major ticks
plot.yaxis.minor_tick_line_color = None # turn off y-axis minor ticks
plot.xaxis.major_label_text_color = None # Remove label x axis
plot.yaxis.major_label_text_color = None # Remove label x axis
plot.border_fill_color = None
plot.outline_line_color = None
plot.renderers.append(graph_renderer)
return plot
def __create_tools(cls, **hoverkwargs):
return [
TapTool(),
BoxSelectTool(dimensions='width'),
BoxSelectTool(dimensions='height'),
BoxSelectTool(),
WheelZoomTool(),
BoxZoomTool(),
ResetTool(),
SaveTool(),
HoverTool(tooltips=[('workflow', '@Workflow'),
('activity', '@Activity'),
('result', '@Result'),
('duration', '@DurationStr'),
('started', '@StartedOnTimestampStr'),
('ended', '@EndedOnTimeStampStr')],
formatters={
'started': 'printf',
'ended': 'printf'
},
show_arrow=True,
**hoverkwargs)
]
def visualize(self):
# add axes titles
'''
# Seaborn viz
ax = sns.scatterplot(x = 0, y = 1, hue = 'clus_label', data = self.pca_frame)
plt.title('Example Plot')
plt.xlabel('PCA1')
plt.ylabel('PCA2')
plt.show()
'''
list_x = list(self.pca_frame[0].values)
list_y = list(self.pca_frame[1].values)
names = self.lookup.set_index(self.index_col)
names = names.reindex(index = self.pca_frame.index)
names.reset_index(inplace = True)
# desc = list(self.pca_frame.index.values)
desc = list(names[self.name_col].values)
labels = list(self.pca_frame['clus_label'].values)
source = ColumnDataSource(data=dict(x=list_x, y=list_y, desc=desc, color=labels))
hover = HoverTool(tooltips=[
# ("index", "$index"),
# ("(PCA1, PCA2)", "(@x, @y)"),
(self.index_col, '@desc'),
])
zoom = BoxZoomTool()
pan = PanTool()
wheel = WheelZoomTool()
mapper = LinearColorMapper(palette=plasma(256), low=min(labels), high=max(labels))
# mapper = CategoricalColorMapper(palette=plasma(256), low=min(labels), high=max(labels))
p = figure(plot_width=1000, plot_height=600, tools=[hover, zoom, pan, wheel], title="Clustering Test: " + self.index_col)
p.circle('x', 'y', size=10, source=source, color=transform('color', mapper)) # fill_color arg is okay but looks worse
output_file('cluster_viz_' + self.index_col + '.html')
show(p)
class GeoPlot(ElementPlot):
"""
Plotting baseclass for geographic plots with a cartopy projection.
"""
default_tools = param.List(
default=[
'save', 'pan',
WheelZoomTool(**({} if bokeh_version < '0.12.16' else {
'zoom_on_axis': False
})),
BoxZoomTool(match_aspect=True), 'reset'
],
doc="A list of plugin tools to use on the plot.")
show_grid = param.Boolean(default=False,
doc="""
Whether to show gridlines on the plot.""")
# Project operation to apply to the element
_project_operation = None
def __init__(self, element, **params):
super(GeoPlot, self).__init__(element, **params)
self.geographic = is_geographic(self.hmap.last)
def _axis_properties(self,
axis,
key,
plot,
dimension=None,
ax_mapping={
'x': 0,
'y': 1
}):
axis_props = super(GeoPlot,
self)._axis_properties(axis, key, plot, dimension,
ax_mapping)
if self.geographic:
dimension = 'lon' if axis == 'x' else 'lat'
axis_props['ticker'] = MercatorTicker(dimension=dimension)
axis_props['formatter'] = MercatorTickFormatter(
dimension=dimension)
return axis_props
def _postprocess_hover(self, renderer, source):
super(GeoPlot, self)._postprocess_hover(renderer, source)
hover = self.handles.get('hover')
try:
from bokeh.models import CustomJSHover
except:
CustomJSHover = None
if (not self.geographic or None in (hover, CustomJSHover)
or isinstance(hover.tooltips, basestring)):
return
element = self.current_frame
xdim, ydim = [dimension_sanitizer(kd.name) for kd in element.kdims]
code = """
var projections = require("core/util/projections");
var x = special_vars.data_x
var y = special_vars.data_y
var coords = projections.wgs84_mercator.inverse([x, y])
return "" + (coords[%d]).toFixed(4)
"""
formatters = {
xdim: CustomJSHover(formatter=code % 0),
ydim: CustomJSHover(formatter=code % 1),
}
tooltips = []
for name, formatter in hover.tooltips:
if formatter in ('@{%s}' % xdim, '@{%s}' % ydim):
formatter += '{custom}'
tooltips.append((name, formatter))
hover.tooltips = tooltips
hover.formatters = formatters
def get_extents(self, element, ranges):
"""
Subclasses the get_extents method using the GeoAxes
set_extent method to project the extents to the
Elements coordinate reference system.
"""
extents = super(GeoPlot, self).get_extents(element, ranges)
if not getattr(element, 'crs', None) or not self.geographic:
return extents
elif any(e is None or not np.isfinite(e) for e in extents):
extents = None
else:
try:
extents = project_extents(extents, element.crs, DEFAULT_PROJ)
except:
extents = None
return (np.NaN, ) * 4 if not extents else extents
def get_data(self, element, ranges, style):
if self._project_operation and self.geographic and element.crs != DEFAULT_PROJ:
element = self._project_operation(element)
return super(GeoPlot, self).get_data(element, ranges, style)
def update_plots(new):
print("Starting update")
nonlocal Estimators
if not isinstance(Estimators, (type(np.array), list)):
Estimators = np.array(Estimators)
estimator_names = np.array(list(estimator_select.value))
ix = np.isin(Estimator_Names, estimator_names)
estimator_indices = [int(i) for i in np.where(ix)[0].flatten()]
estimators = np.array(Estimators)[estimator_indices]
variable1 = drop1.value
variable2 = drop2.value
y = drop3.value
#Things to update:
# image background i.e. image source √
# observation source √
#Color mapper values√
#hover tool values √
#Figure ranges √
#Model score text things √
#Lets calculate all the image and observation data first
plots = [None for i in range(len(estimators))]
image_sources = [None for i in range(len(estimators))]
observation_sources = [None for i in range(len(estimators))]
hover_tools = [None for i in range(len(estimators))]
model_score_sources = [None for i in range(len(estimators))]
glyphs0 = [None for i in range(len(estimators))]
color_bars = [None for i in range(len(estimators))]
p_circles = [None for i in range(len(estimators))]
p_images = [None for i in range(len(estimators))]
#Iterate over the estimators
for idx, estimator in enumerate(estimators):
#Find the title for each plot
estimator_name = str(estimator()).split('(')[0]
#Extract the needed data
full_mat = X[[variable1, variable2, y]].dropna(how="any",
axis=0)
#Define a class bijection for class colour mapping
unique_classes, y_bijection = np.unique(full_mat[y],
return_inverse=True)
full_mat['y_bijection'] = y_bijection
#Rescale the X Data so that the data fits nicely on the axis/predictions are reliable
full_mat[variable1 + "_s"] = StandardScaler().fit_transform(
full_mat[variable1].values.reshape((-1, 1)))
full_mat[variable2 + "_s"] = StandardScaler().fit_transform(
full_mat[variable2].values.reshape((-1, 1)))
#Define the Step size in the mesh
delta = Delta
#Separate the data into arrays so it is easy to work with
X1 = full_mat[variable1 + "_s"].values
X2 = full_mat[variable2 + "_s"].values
Y = full_mat["y_bijection"].values
#Define the mesh-grid co-ordiantes over which to colour in
x1_min, x1_max = X1.min() - 0.5, X1.max() + 0.5
x2_min, x2_max = X2.min() - 0.5, X2.max() + 0.5
#Create the meshgrid itself
x1, x2 = np.arange(x1_min, x1_max,
delta), np.arange(x2_min, x2_max, delta)
x1x1, x2x2 = np.meshgrid(x1, x2)
#Create the train test split
X_train, X_test, y_train, y_test = train_test_split(
full_mat[[variable1 + "_s", variable2 + "_s"]],
Y,
test_size=Test_Size,
random_state=Random_State)
#Fit and predict/score the model
model = estimator().fit(X=X_train, y=y_train)
# train_preds = model.predict(X_train)
# test_preds = model.predict(X_test)
model_score = model.score(X_test, y_test)
model_score_text = "Model score: %.2f" % model_score
if hasattr(model, "decision_function"):
Z = model.decision_function(np.c_[x1x1.ravel(),
x2x2.ravel()])
elif hasattr(model, "predict_proba"):
Z = model.predict_proba(np.c_[x1x1.ravel(), x2x2.ravel()])
else:
print(
"This Estimator doesn't have a decision_function attribute and can't predict probabilities"
)
Z = np.argmax(Z, axis=1)
Z_uniques = np.unique(Z)
unique_predictions = unique_classes[Z_uniques]
Z = Z.reshape(x1x1.shape)
#Add in the probabilities and predicitions for the tooltips
full_mat["probability"] = np.amax(model.predict_proba(
full_mat[[variable1 + "_s", variable2 + "_s"]]),
axis=1)
bijected_predictions = model.predict(
full_mat[[variable1 + "_s", variable2 + "_s"]])
full_mat["prediction"] = unique_classes[bijected_predictions]
#Add an associated color to the predictions
number_of_colors = len(np.unique(y_bijection))
#Create the hover tool to be updated
hover = HoverTool(tooltips=[(
variable1, "@" +
variable1), (variable2, "@" +
variable2), ("Probability", "@probability"),
("Prediction",
"@prediction"), ("Actual",
"@" + y)])
#Create the axes for all the plots
plots[idx] = figure(x_axis_label=variable1,
y_axis_label=variable2,
title=estimator_name,
x_range=(x1x1.min(), x1x1.max()),
y_range=(x2x2.min(), x2x2.max()),
plot_height=600,
plot_width=600)
#Create all the image sources
image_data = dict()
image_data['x'] = np.array([x1x1.min()])
image_data["y"] = np.array([x2x2.min()])
image_data['dw'] = np.array([x1x1.max() - x1x1.min()])
image_data['dh'] = np.array([x2x2.max() - x2x2.min()])
image_data['boundaries'] = [Z]
image_sources[idx] = ColumnDataSource(image_data)
#Create all the updatable images (boundaries)
p_images[idx] = plots[idx].image(image='boundaries',
x='x',
y='y',
dw='dw',
dh='dh',
palette="RdBu11",
source=image_sources[idx])
#Create the sources to update the observation points
observation_sources[idx] = ColumnDataSource(data=full_mat)
#Create all the updatable points
low = full_mat["y_bijection"].min()
high = full_mat["y_bijection"].max()
cbar_mapper = LinearColorMapper(palette=RdBu[number_of_colors],
high=high,
low=low)
p_circles[idx] = plots[idx].circle(
x=variable1 + "_s",
y=variable2 + "_s",
color=dict(field='y_bijection', transform=cbar_mapper),
source=observation_sources[idx],
line_color="black")
#Create the hovertool for each plot
hover_tools[idx] = hover
#Add the hover tools to each plot
plots[idx].add_tools(hover_tools[idx])
#Create all the text sources (model scores) for the plots
model_score_sources[idx] = ColumnDataSource(
data=dict(x=[x1x1.min() + 0.3],
y=[x2x2.min() + 0.3],
text=[model_score_text]))
#Add the model scores to all the plots
score_as_text = Text(x="x", y="y", text="text")
glyphs0[idx] = plots[idx].add_glyph(model_score_sources[idx],
score_as_text)
#Add a colorbar
color_bars[idx] = ColorBar(
color_mapper=cbar_mapper,
ticker=BasicTicker(desired_num_ticks=number_of_colors),
label_standoff=12,
location=(0, 0),
bar_line_color="black")
plots[idx].add_layout(color_bars[idx], "right")
plots[idx].add_tools(LassoSelectTool(), WheelZoomTool())
# configure so that no drag tools are active
plots[idx].toolbar.tools = plots[idx].toolbar.tools[1:]
plots[idx].toolbar.tools[0], plots[idx].toolbar.tools[
-2] = plots[idx].toolbar.tools[-2], plots[
idx].toolbar.tools[0]
layout = gridplot([
widgetbox(drop1, drop2, drop3, estimator_select, update_drop)
], [row(plot) for plot in plots])
return layout
#Finished the callback
print("Ending Update")
push_notebook(handle=handle0)
def make_region_plot(src, src_gene, src_tss, src_rna, fixed_yaxis=None):
'''
Construct pileup plot based on src
'''
# output_file(html_output)
# flatten list of lists in count column of src, find max value of absolute expression
frag_count_range = max(
map(abs, [x for count in src.data['count'] for x in count]))
if len(src_rna.data['y_plus']) > 0:
rna_count_range = max(max(src_rna.data['y_plus']),
max(abs(src_rna.data['y_minus'])))
else:
rna_count_range = 0
count_range = max(frag_count_range, rna_count_range)
if fixed_yaxis:
ymin = -1 * (fixed_yaxis)
ymax = fixed_yaxis
else:
ymin = -(count_range + 1)
ymax = count_range + 1
# draw blank figure of correct size with tools
p = figure(y_range=(ymin, ymax),
plot_width=900,
plot_height=700,
tools=[
BoxSelectTool(),
BoxZoomTool(),
PanTool(),
WheelZoomTool(),
SaveTool(),
ResetTool()
],
toolbar_location='above')
legends = []
# format axis and colors
p.xaxis.axis_label = 'position'
p.xaxis.major_label_orientation = pi / 4
p.xaxis[0].formatter.use_scientific = False
# p.xaxis[0].ticker=FixedTicker(ticks=range(start, end, 100))
p.yaxis.axis_label = 'log normalized activity'
patches = p.patches(source=src,
xs='position',
ys='count',
fill_color='color',
line_color=None,
alpha=0.50)
legends.append(
LegendItem(label='promoter activity (plus strand)',
renderers=[patches],
index=0))
legends.append(
LegendItem(label='promoter activity (minus strand)',
renderers=[patches],
index=1))
# draw RNA lines
if len(src_rna.data['x_minus']) > 0:
plus_line = p.line(x='x_plus',
y='y_plus',
line_color='#528ecb',
line_width=2,
source=src_rna)
legends.append(
LegendItem(label='RNA-seq (plus strand)',
renderers=[plus_line],
index=0))
minus_line = p.line(x='x_minus',
y='y_minus',
line_color='#ef8137',
line_width=2,
source=src_rna)
legends.append(
LegendItem(label='RNA-seq (minus strand)',
renderers=[minus_line],
index=1))
# add second y-axis for TSS strength
max_tss = max(map(abs, src_tss.data['y0']))
p.extra_y_ranges = {
'tss': Range1d(start=-(max_tss * 4), end=(max_tss * 4))
}
p.add_layout(LinearAxis(y_range_name='tss', axis_label='TSS expression'),
'right')
# draw vertical rectangle
p.quad(top='top',
bottom='bottom',
left='left',
right='right',
color='color',
source=src_tss,
y_range_name='tss')
# draw horizontal line for arrow
p.segment(x0='x0',
y0='y0',
x1='x1',
y1='y1',
color='color',
source=src_tss,
line_width=4,
y_range_name='tss')
# center of triangle is endpoint of segment
tri = p.triangle(x='x1',
y='y1',
size=9,
angle='angle',
angle_units='deg',
color='color',
source=src_tss,
y_range_name='tss')
legends.append(LegendItem(label='inactive TSS', renderers=[tri], index=9))
legends.append(LegendItem(label='active TSS', renderers=[tri], index=0))
# plot genes
p.rect(x='gene_center',
y='gene_center_y',
width='gene_width',
color='gene_color',
height=10,
height_units='screen',
source=src_gene)
p.triangle(x='tri_x',
y=0,
size=20,
angle='angle',
angle_units='deg',
fill_color='gene_color',
line_color=None,
source=src_gene)
p.text(x='gene_center',
y='gene_center_y',
text='gene_name',
text_color='black',
text_align='center',
text_baseline='middle',
text_font_size='10pt',
source=src_gene)
p.add_layout(Legend(items=legends), 'below')
return p
ppgLineMarkers = mainViewer.circle(x=[], y=[], color='navy', alpha=0.5, visible=False)
qosMarkers = mainViewer.circle(x=[], y=[], color='red', y_range_name='qosRange')
annotation = mainViewer.line(x=[], y=[], color='navy', visible=True, line_width=3)
ppgDataSource = ppgLine.data_source
ppgLineMarkersDataSource = ppgLineMarkers.data_source
qosDataSource = qosMarkers.data_source
annotatedDataSource = annotation.data_source
#### Describe how selected data are handled. ####
selected_circle = Circle(fill_color='navy', visible=True)
nonselected_circle = Circle(fill_color='navy', visible=False)
ppgLineMarkers.selection_glyph = selected_circle
ppgLineMarkers.nonselection_glyph = nonselected_circle
wheel_zoom = WheelZoomTool()
tap_tool = TapTool()
box_select = BoxSelectTool(dimensions="width")
hover = HoverTool(
point_policy='snap_to_data',
line_policy='nearest',
tooltips=[
("index", "$index"),
("Value", "@y"),
# ("desc", "@desc"),
("Time", '@time'),
("Note", "@notes"),
],
renderers=[
qosMarkers,
ppgLineMarkers,
class GeoPlot(ProjectionPlot, ElementPlot):
"""
Plotting baseclass for geographic plots with a cartopy projection.
"""
default_tools = param.List(
default=[
'save', 'pan',
WheelZoomTool(**({} if bokeh_version < '0.12.16' else {
'zoom_on_axis': False
})),
BoxZoomTool(match_aspect=True), 'reset'
],
doc="A list of plugin tools to use on the plot.")
fixed_bounds = param.Boolean(default=True,
doc="""
Whether to prevent zooming beyond the projections defined bounds.""")
global_extent = param.Boolean(default=False,
doc="""
Whether the plot should display the whole globe.""")
infer_projection = param.Boolean(default=False,
doc="""
Whether the projection should be inferred from the element crs.""")
show_grid = param.Boolean(default=False,
doc="""
Whether to show gridlines on the plot.""")
show_bounds = param.Boolean(default=False,
doc="""
Whether to show gridlines on the plot.""")
projection = param.Parameter(default=GOOGLE_MERCATOR,
doc="""
Allows supplying a custom projection to transform the axis
coordinates during display. Defaults to GOOGLE_MERCATOR.""")
# Project operation to apply to the element
_project_operation = None
_hover_code = """
var projections = require("core/util/projections");
var x = special_vars.data_x
var y = special_vars.data_y
var coords = projections.wgs84_mercator.inverse([x, y])
return "" + (coords[%d]).toFixed(4)
"""
def __init__(self, element, **params):
super(GeoPlot, self).__init__(element, **params)
self.geographic = is_geographic(self.hmap.last)
if self.geographic and not isinstance(self.projection,
(PlateCarree, Mercator)):
self.xaxis = None
self.yaxis = None
self.show_frame = False
show_bounds = self._traverse_options(element,
'plot', ['show_bounds'],
defaults=False)
self.show_bounds = not any(not sb
for sb in show_bounds['show_bounds'])
if self.show_grid:
param.main.warning(
'Grid lines do not reflect {0}; to do so '
'multiply the current element by gv.feature.grid() '
'and disable the show_grid option.'.format(
self.projection))
def _axis_properties(self,
axis,
key,
plot,
dimension=None,
ax_mapping={
'x': 0,
'y': 1
}):
axis_props = super(GeoPlot,
self)._axis_properties(axis, key, plot, dimension,
ax_mapping)
proj = self.projection
if self.geographic and proj is GOOGLE_MERCATOR:
dimension = 'lon' if axis == 'x' else 'lat'
axis_props['ticker'] = MercatorTicker(dimension=dimension)
axis_props['formatter'] = MercatorTickFormatter(
dimension=dimension)
return axis_props
def _update_ranges(self, element, ranges):
super(GeoPlot, self)._update_ranges(element, ranges)
if not self.geographic:
return
if self.fixed_bounds:
self.handles['x_range'].bounds = self.projection.x_limits
self.handles['y_range'].bounds = self.projection.y_limits
if self.projection is GOOGLE_MERCATOR:
# Avoid zooming in beyond tile and axis resolution (causing JS errors)
options = self._traverse_options(element,
'plot', ['default_span'],
defaults=False)
min_interval = options['default_span'][0] if options.get(
'default_span') else 5
for r in ('x_range', 'y_range'):
ax_range = self.handles[r]
start, end = ax_range.start, ax_range.end
if (end - start) < min_interval:
mid = (start + end) / 2.
ax_range.start = mid - min_interval / 2.
ax_range.start = mid + min_interval / 2.
ax_range.min_interval = min_interval
def initialize_plot(self, ranges=None, plot=None, plots=None, source=None):
opts = {} if isinstance(self, HvOverlayPlot) else {'source': source}
fig = super(GeoPlot, self).initialize_plot(ranges, plot, plots, **opts)
if self.geographic and self.show_bounds and not self.overlaid:
from . import GeoShapePlot
shape = Shape(self.projection.boundary,
crs=self.projection).options(fill_alpha=0)
shapeplot = GeoShapePlot(shape,
projection=self.projection,
overlaid=True,
renderer=self.renderer)
shapeplot.geographic = False
shapeplot.initialize_plot(plot=fig)
return fig
def _postprocess_hover(self, renderer, source):
super(GeoPlot, self)._postprocess_hover(renderer, source)
hover = self.handles.get('hover')
try:
from bokeh.models import CustomJSHover
except:
CustomJSHover = None
if (not self.geographic or None in (hover, CustomJSHover)
or isinstance(hover.tooltips, basestring)
or self.projection is not GOOGLE_MERCATOR
or hover.tooltips is None):
return
element = self.current_frame
xdim, ydim = [dimension_sanitizer(kd.name) for kd in element.kdims]
formatters, tooltips = {}, []
xhover = CustomJSHover(code=self._hover_code % 0)
yhover = CustomJSHover(code=self._hover_code % 1)
for name, formatter in hover.tooltips:
customjs = None
if formatter in ('@{%s}' % xdim, '$x'):
dim = xdim
customjs = xhover
elif formatter in ('@{%s}' % ydim, '$y'):
dim = ydim
customjs = yhover
if customjs:
key = formatter if formatter in ('$x', '$y') else dim
formatters[key] = customjs
formatter += '{custom}'
tooltips.append((name, formatter))
hover.tooltips = tooltips
hover.formatters = formatters
def get_data(self, element, ranges, style):
proj = self.projection
if self._project_operation and self.geographic:
element = self._project_operation(element, projection=proj)
return super(GeoPlot, self).get_data(element, ranges, style)
def plot():
# Read data as if uploaded file is now used, Data set 1
data1 = read_csv('app/static/uploads/Data1.csv', sep=',', skipinitialspace=1)
xdata1 = data1.values[:,1] # Extract Data
ydata1 = data1.values[:,2]
colour1 = ['black']*len(xdata1)
# Read data as if uploaded file is now used, Data set 2
data2 = read_csv('app/static/uploads/Data2.csv', sep=',', skipinitialspace=1)
xdata2 = data2.values[:,1]
ydata2 = data2.values[:,2]
colour2 = ['green']*len(xdata2)
# Read data as if uploaded file is now used, Data set 3
data3 = read_csv('app/static/uploads/Data3.csv', sep=',', skipinitialspace=1)
xdata3 = data3.values[:,1]
ydata3 = data3.values[:,2]
colour3 = ['red']*len(xdata3)
# Prepare Data3
# xdata3 = linspace(0, 100, 10)
# ydata3 = sin(10*xdata3)
# Data_pandas = DataFrame({'Time': xdata3,
# 'Value': ydata3})
# Data_pandas.to_csv('app/static/uploads/Data3.csv')
# Assign read data to ColumnDataSource objects
sourceData1 = ColumnDataSource(data=dict(x=xdata1, y=ydata1, color=colour1))
sourceData2 = ColumnDataSource(data=dict(x=xdata2, y=ydata2, color=colour2))
sourceData3 = ColumnDataSource(data=dict(x=xdata3, y=ydata3, color=colour3))
my_plot = figure(tools=[BoxSelectTool(dimensions=['width'], select_every_mousemove=True), PanTool(), ResetTool(), WheelZoomTool(), BoxZoomTool()],
title='Time series data',
x_range=(xdata1.min(), xdata1.max()),
y_range=(ydata1.min(), ydata1.max()),
width=1200) # Create figure object; DEBUG: select_every_mousemove=False
my_plot.extra_y_ranges = {# 'Data1': Range1d(start=ydata1.min(), end=ydata1.max()),
'Data2': Range1d(start=ydata2.min(), end=ydata2.max()),
'Data3': Range1d(start=ydata3.min(), end=ydata3.max())}
my_plot.circle(x='x', y='y', color='color', source=sourceData1,
size=8, alpha=0.8, legend='Data 1') # Add circle elements (glyphs) to the figure
my_plot.circle(x='x', y='y', color='color', source=sourceData2,
size=5, alpha=0.8, y_range_name='Data2', legend='Data 2')
my_plot.circle(x='x', y='y', color='color', source=sourceData3,
size=8, alpha=0.5, y_range_name='Data3', legend='Data 3')
my_plot.line(x='x', y='y', color='red', source= sourceData3,
alpha=0.5, y_range_name='Data3', legend='Data 3')
sourceFit = ColumnDataSource(data=dict(xfit=[], yfit=[]))
my_plot.circle(x='xfit', y='yfit', source=sourceFit, color='orange', alpha=0.3)
# my_plot.add_layout(LinearAxis(y_range_name='Data1', axis_line_color=colour1[0]), 'left')
my_plot.add_layout(LinearAxis(y_range_name='Data2', axis_line_color=colour2[0], axis_line_width=3), 'left')
my_plot.add_layout(LinearAxis(y_range_name='Data3', axis_line_color=colour3[0], axis_line_width=3), 'left')
# sourceAnnotate = ColumnDataSource(data=dict(text=['Foo', 'Bah'], x=[50, 50], y=[0.5, 0], x_offset=[0,0], y_offset=[0,0], text_font_size=['15pt', '15pt'],
# text_color=['orange', 'orange']))
# my_plot.text(source=sourceAnnotate, text='text', x='x', y='y', x_offset='x_offset', y_offset='y_offset', text_font_size='text_font_size', text_color='text_color')
sourceData1.callback = CustomJS(args=dict(sourceFit=sourceFit), code=("""FirstOrderEyeball(cb_obj, sourceFit)"""))
# sourceData.callback = CustomJS(args=dict(sourceFit=sourceFit, sourceAnnotate=sourceAnnotate), code=("""FirstOrderEyeball(cb_obj, sourceFit, sourceAnnotate)"""))
script, div = components(my_plot) # Break figure up into component HTML to be added to template
return render_template("int_scatter.html", myScript=script, myDiv=div)
def __init__(self, dataset, parameters):
self.dataset = dataset
# Set up the controls
self.specials = Selector(
name="Specials",
kind="specials",
css_classes=["specials"],
entries={
"Color-magnitude diagram": "cmd",
"Period vs. radius": "pr",
"Period vs. transit duration": "pdt",
},
default="Color-magnitude diagram",
)
self.data = Selector(
name="Datasets",
kind="datasets",
css_classes=["data"],
entries={"TOI Catalog": "toi", "Confirmed Planets": "confirmed"},
default="Confirmed Planets",
)
self.xaxis = Selector(
name="Build-Your-Own",
kind="parameters",
css_classes=["build-your-own"],
entries=parameters,
default="ra",
title="X Axis",
)
self.yaxis = Selector(
kind="parameters",
css_classes=["build-your-own"],
entries=parameters,
default="dec",
title="Y Axis",
)
self.size = Selector(
name="Sides",
kind="parameters",
css_classes=["sides"],
entries=parameters,
default="dist",
title="Marker Size",
none_allowed=True,
)
self.color = Selector(
kind="parameters",
css_classes=["sides"],
entries=parameters,
default="dist",
title="Marker Color",
none_allowed=True,
)
# Set up the plot
self.source = ColumnDataSource(
data=dict(x=[], y=[], size=[], color=[])
)
self.plot = figure(
plot_height=600,
plot_width=700,
title="",
tooltips=[("TIC ID", "@ticid")],
sizing_mode="scale_both",
)
self.plot.circle(
x="x",
y="y",
source=self.source,
size="size",
color=linear_cmap(
field_name="color", palette=Viridis256, low=0, high=1
),
line_color=None,
)
self.plot.add_tools(
BoxSelectTool(),
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
PolySelectTool(),
TapTool(),
WheelZoomTool(),
WheelPanTool(),
ZoomInTool(),
ZoomOutTool(),
HoverTool(),
CrosshairTool(),
ResetTool(),
)
# Register the callback
for control in [
self.specials,
self.data,
self.xaxis,
self.yaxis,
self.size,
self.color,
]:
control.widget.on_change("value", self.callback)
# Load and display the data
self.callback(None, None, None)
mean.add_layout(span)
# =============================================================================
multi_plot = Plot(plot_width=800,
plot_height=400,
background_fill_color='silver')
multi_glyph = MultiLine(xs='waves', ys='ys', line_width=2, line_color='label')
multi_plot.add_glyph(spectra_visible_multi, multi_glyph)
xaxis, yaxis = LinearAxis(), LinearAxis()
multi_plot.add_layout(xaxis, 'below')
multi_plot.xaxis.axis_label = 'Wavelength (nm)'
multi_plot.add_layout(yaxis, 'left')
multi_plot.yaxis.axis_label = 'Intensity (CPS)'
multi_plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker))
multi_plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker))
multi_plot.add_tools(BoxZoomTool())
multi_plot.add_tools(WheelZoomTool())
multi_plot.add_tools(ResetTool())
multi_plot.add_tools(SaveTool())
multi_plot.add_layout(span)
# =============================================================================
# ~~ Clustering figures
# ~ labeled_materials_image: map image of predicted material labels
# ~ elbow inertia vs n_materials plot
# ~ varBar bar plot of pca explained variances
# =============================================================================
labeled_materials_image, label_mapper = basicMap(labeled_materials, 400,
'image')
# elbow = figure(x_axis_label='Number of Materials', y_axis_label='Learning Inertia',
# plot_width=400, plot_height=200, toolbar_location=None)
# elbow.line('num_clusters', 'inertia', source=elbow_plot)
varBar = figure(plot_width=400, plot_height=200, toolbar_location=None)
def create_bk_fig(x=None, xlab=None, x_min=None, x_max=None,
ylab=None, fh=None, fw=None,
title=None, pw=None, ph=None, x_axis_type="linear",
y_axis_type="linear", x_name=None, y_name=None, **kwargs):
""" Generates a bokeh figure
Parameters
----------
x :obj:`DataArray`
Contains x-axis data
xlab : :obj:`str`
X-axis label
x_min : :obj:`float`
Min x value
x_max : :obj:`float`
Max x value
ylab : :obj:`str`
Y-axis label
fh: :obj:`int`
True height of figure without legends, axes titles etc
fw: :obj:`int`
True width of figure without legends, axes etc
title: :obj:`str`
Title of plot
pw: :obj:`int`
Plot width including legends, axes etc
ph: :obj:`int`
Plot height including legends, axes etc
x_axis_type: :obj:`str`
Type of x-axis can be linear, log, or datetime
y_axis_type: :obj:`str`
Can be linear, log or datetime
x_name: :obj:`str`
Name of the column used for the x-axis. Mostly used to form tooltips
y_name: :obj:`str`
Name of the column used for the y-axis. Also used for tooltips
add_grid: :obj:`bool`
Whether or not to add grid
add_title: :obj:`bool`
Whether or not to add title to plot
add_xaxis: :obj:`bool`
Whether or not to add x-axis and tick marks
add_yaxis: :obj:`bool`
Add y-axis or not
fix_plotsize: :obj:`bool`
Enforce certain dimensions on plot. This is useful for ensuring a plot
is not obscure by axes and other things. If activated, plot's
dimensions will not be responsive. It utilises fw and fh.
Returns
-------
p : :obj:`Plot`
A bokeh Plot object
"""
add_grid = kwargs.pop("add_grid", False)
add_title = kwargs.pop("add_title", True)
add_xaxis = kwargs.pop("add_xaxis", False)
add_yaxis = kwargs.pop("add_yaxis", False)
fix_plotsize = kwargs.pop("fix_plotsize", True)
# addition plot specs
pl_specs = kwargs.pop("pl_specs", {})
# additional axis specs
ax_specs = kwargs.pop("ax_specs", {})
# ticker specs
ti_specs = kwargs.pop("ti_specs", {})
plot_specs = dict(background="white", border_fill_alpha=0.1,
border_fill_color="white", min_border=3,
name="plot", outline_line_dash="solid",
outline_line_width=2, outline_line_color="#017afe",
outline_line_alpha=0.4, output_backend="canvas",
sizing_mode="stretch_width", title_location="above",
toolbar_location="above")
plot_specs.update(pl_specs)
axis_specs = dict(minor_tick_line_alpha=0, axis_label_text_align="center",
axis_label_text_font="monospace",
axis_label_text_font_size="10px",
axis_label_text_font_style="normal",
major_label_orientation="horizontal")
axis_specs.update(ax_specs)
tick_specs = dict(desired_num_ticks=5)
tick_specs.update(ti_specs)
# Define frame width and height
# This is the actual size of the plot without the titles et al
if fix_plotsize and not(fh or fw):
fw = int(0.98 * pw)
fh = int(0.93 * ph)
# define the axes ranges
x_range = DataRange1d(name="p_x_range", only_visible=True)
y_range = DataRange1d(name="p_y_range", only_visible=True)
if x_min is not None and x_max is not None and x_name.lower() in ["channel", "frequency"]:
x_range = Range1d(name="p_x_range", start=x_min, end=x_max)
y_range.only_visible = False
# define items to add on the plot
p_htool = HoverTool(tooltips=[(x_name, "$x"),
(y_name, "$y")],
name="p_htool", point_policy="snap_to_data")
if x_name.lower() == "time":
p_htool.tooltips[0] = (x_name, "$x{%d-%m-%Y %H:%M}")
p_htool.formatters = {"$x": "datetime"}
p_toolbar = Toolbar(name="p_toolbar",
tools=[p_htool, BoxSelectTool(), BoxZoomTool(),
# EditTool(), # BoxEditTool(), # RangeTool(),
LassoSelectTool(), PanTool(), ResetTool(),
SaveTool(), UndoTool(), WheelZoomTool()])
p_ticker = BasicTicker(name="p_ticker", **tick_specs)
# select the axis scales for x and y
if x_axis_type == "linear":
x_scale = LinearScale(name="p_x_scale")
# define the axes and tickers
p_x_axis = LinearAxis(axis_label=xlab, name="p_x_axis",
ticker=p_ticker, **axis_specs)
elif x_axis_type == "datetime":
x_scale = LinearScale(name="p_x_scale")
# define the axes and tickers
p_x_axis = DatetimeAxis(axis_label=xlab, name="p_x_axis",
ticker=p_ticker, **axis_specs)
elif x_axis_type == "log":
x_scale = LogScale(name="p_x_scale")
p_x_axis = LogAxis(axis_label=xlab, name="p_x_axis",
ticker=p_ticker, **axis_specs)
if y_axis_type == "linear":
y_scale = LinearScale(name="p_y_scale")
# define the axes and tickers
p_y_axis = LinearAxis(axis_label=ylab, name="p_y_axis",
ticker=p_ticker, **axis_specs)
elif x_axis_type == "datetime":
y_scale = LinearScale(name="p_y_scale")
# define the axes and tickers
p_y_axis = DatetimeAxis(axis_label=xlab, name="p_y_axis",
ticker=p_ticker, **axis_specs)
elif y_axis_type == "log":
y_scale = LogScale(name="p_y_scale")
# define the axes and tickers
p_y_axis = LogAxis(axis_label=ylab, name="p_y_axis",
ticker=p_ticker, **axis_specs)
# Create the plot object
p = Plot(plot_width=pw, plot_height=ph, frame_height=fh, frame_width=fw,
toolbar=p_toolbar, x_range=x_range, x_scale=x_scale,
y_range=y_range, y_scale=y_scale, **plot_specs)
if add_title:
p_title = Title(align="center", name="p_title", text=title,
text_font_size="24px",
text_font="monospace", text_font_style="bold",)
p.add_layout(p_title, "above")
if add_xaxis:
p.add_layout(p_x_axis, "below")
if add_yaxis:
p.add_layout(p_y_axis, "left")
if add_grid:
p_x_grid = Grid(dimension=0, ticker=p_ticker)
p_y_grid = Grid(dimension=1, ticker=p_ticker)
p.add_layout(p_x_grid)
p.add_layout(p_y_grid)
return p
