def classical_gear(module, large_teeth, small_teeth):
xdr = Range1d(start=-300, end=150)
ydr = Range1d(start=-100, end=100)
plot = Plot(x_range=xdr, y_range=ydr, plot_width=800, plot_height=800)
plot.add_tools(PanTool(), WheelZoomTool(), BoxZoomTool(), UndoTool(),
RedoTool(), ResetTool())
radius = pitch_radius(module, large_teeth)
angle = 0
glyph = Gear(x=-radius,
y=0,
module=module,
teeth=large_teeth,
angle=angle,
fill_color=fill_color[0],
line_color=line_color)
plot.add_glyph(glyph)
radius = pitch_radius(module, small_teeth)
angle = half_tooth(small_teeth)
glyph = Gear(x=radius,
y=0,
module=module,
teeth=small_teeth,
angle=angle,
fill_color=fill_color[1],
line_color=line_color)
plot.add_glyph(glyph)
return plot
def main():
"""Invoke when run directly as a program."""
args = parse_arguments()
df = pd.read_csv(args.infile, sep='\s+', names=["amplicon", "meancov", "gene"])
df['offsetcov'] = df['meancov'] + 0.1 # shift zero values by 0.1
df = df.dropna().reset_index(drop=True)
# Make a hover (show amplicon name on mouse-over)
hover = HoverTool(tooltips=[("Amplicon", "@names"), ("Y value", "$y")])
tools = [PanTool(), BoxZoomTool(), WheelZoomTool(), RedoTool(), UndoTool(), ResetTool(), hover, SaveTool()]
# Produce plot
output_file(args.outfile)
fig = figure(tools=tools, width=1200, height=600, y_axis_type='log')
# Fill plot with one point for each amplicon:
xvals, yvals, labels, colors = [], [], [], []
for i, (name, group) in enumerate(df.groupby('gene', sort=False)):
xvals.extend(list(group.index))
yvals.extend(list(group.offsetcov))
labels.extend(list(group.amplicon))
# Elements in the same group should have the same color. Cycle between colors in COLOR_CYCLE:
colors.extend([COLOR_CYCLE[i % len(COLOR_CYCLE)]] * len(list(group.index)))
data = ColumnDataSource(data=dict(x=xvals, y=yvals, names=labels))
fig.circle('x', 'y', size=10, source=data, color=colors)
# Make span lines on 0.05, 0.1, 0.2, 1 and 5 mutiples of mean amplicon coverage:
mean_coverage = df.offsetcov.mean()
span_lines = [(5.0, 'Blue'), (1.0, 'Green'), (0.2, 'Red'), (0.1, 'Purple'), (0.05, 'Magenta')]
xmin, xmax = min(xvals) - 1, max(xvals) + 1
for ratio, color in span_lines:
fig.line([xmin, xmax], [mean_coverage * ratio] * 2, line_color=color, line_dash='dashed',
legend='{:.0f} % of mean coverage'.format(ratio * 100))
# Customize plot:
ymax = 2.0 * max(df.offsetcov.max() + 1000, mean_coverage * 5)
ymin = 0.2
fig.y_range = Range1d(ymin, ymax)
fig.x_range = Range1d(xmin, xmax)
fig.xaxis.major_tick_line_color = None # Turn off x-axis major ticks
fig.xaxis.minor_tick_line_color = None # Turn off x-axis minor ticks
fig.xaxis.major_label_text_font_size = '0pt' # Hack to remove tick labels
fig.xaxis.axis_label = 'Amplicon'
fig.yaxis.axis_label = 'Log10 (Amplicon coverage)'
fig.legend.location = "bottom_right"
script, div = components(layouts.row(fig))
with open(os.path.join(os.path.dirname(args.outfile), 'plot.js'), 'wt') as jfile:
jfile.write('\n'.join(script.split('\n')[2:-1]))
with open(args.outfile, 'wt') as ofile:
env = Environment(loader=FileSystemLoader(os.path.dirname(args.template)))
page_template = env.get_template(os.path.basename(args.template))
html_text = page_template.render({'bokeh_div': div}) # pylint: disable=no-member
ofile.write(html_text)
def sample_gear():
xdr = Range1d(start=-30, end=30)
ydr = Range1d(start=-30, end=30)
plot = Plot(x_range=xdr, y_range=ydr, plot_width=800, plot_height=800)
plot.add_tools(PanTool(), WheelZoomTool(), BoxZoomTool(), UndoTool(), RedoTool(), ResetTool())
glyph = Gear(x=0, y=0, module=5, teeth=8, angle=0, shaft_size=0.2, fill_color=fill_color[2], line_color=line_color)
plot.add_glyph(glyph)
return plot
def epicyclic_gear(module, sun_teeth, planet_teeth):
xdr = Range1d(start=-150, end=150)
ydr = Range1d(start=-150, end=150)
plot = Plot(title=None,
x_range=xdr,
y_range=ydr,
plot_width=800,
plot_height=800)
plot.add_tools(PanTool(), WheelZoomTool(), BoxZoomTool(), UndoTool(),
RedoTool(), ResetTool())
annulus_teeth = sun_teeth + 2 * planet_teeth
glyph = Gear(x=0,
y=0,
module=module,
teeth=annulus_teeth,
angle=0,
fill_color=fill_color[0],
line_color=line_color,
internal=True)
plot.add_glyph(glyph)
glyph = Gear(x=0,
y=0,
module=module,
teeth=sun_teeth,
angle=0,
fill_color=fill_color[2],
line_color=line_color)
plot.add_glyph(glyph)
sun_radius = pitch_radius(module, sun_teeth)
planet_radius = pitch_radius(module, planet_teeth)
radius = sun_radius + planet_radius
angle = half_tooth(planet_teeth)
for i, j in [(+1, 0), (0, +1), (-1, 0), (0, -1)]:
glyph = Gear(x=radius * i,
y=radius * j,
module=module,
teeth=planet_teeth,
angle=angle,
fill_color=fill_color[1],
line_color=line_color)
plot.add_glyph(glyph)
return plot
def NLD_add_tools(plot):
plot.add_tools(WheelZoomTool())
plot.add_tools(ZoomInTool())
plot.add_tools(ZoomOutTool())
plot.add_tools(ResetTool())
plot.add_tools(UndoTool())
plot.add_tools(RedoTool())
plot.add_tools(PanTool())
plot.add_tools(TapTool())
plot.add_tools(SaveTool())
plot.add_tools(BoxSelectTool())
plot.add_tools(LassoSelectTool())
plot.add_tools(BoxZoomTool())
# !!! Hover the node attributes !!!
node_hover = HoverTool(tooltips=[('Name', '@index'), ('Degree', '@degree'),
('Min Weight', '@minweight'), ('Max Weight', '@maxweight'),
('Average Weight', '@avrweight'), ('Sum Weight', '@sumweight')])
plot.add_tools(node_hover)
hover_bar = HoverTool(tooltips=[('Rating','@x1'),
('Number of Business','@y1')
])
hover_pie = HoverTool(tooltips=[('Percentage','@ratio')
])
select_day = Select(
options=['Sunday','Monday', 'Tuesday', 'Wednesday', 'Thursday','Friday','Saturday'],
value='Monday',
title='Day of the Week'
)
chosen_tools =[hover,ResetTool(),BoxSelectTool(),
SaveTool(),PanTool(),
UndoTool(),RedoTool(),ZoomInTool(),
ZoomOutTool()
]
#data
data = pd.read_csv(r'~/Desktop/yelp/yelp_business.csv',index_col='business_id')
hour = pd.read_csv(r'~/Desktop/yelp/yelp_business_hours.csv',index_col='business_id')
#data = pd.read_csv(r'E:\project\CIS4170\yelp\yelp_business.csv',index_col='business_id')
#hour = pd.read_csv(r'E:\project\CIS4170\yelp\yelp_business_hours.csv',index_col='business_id')
whole = pd.merge(data,hour, left_index=True, right_index=True)
#data = pd.read_csv(r'E:\Software\WinPython\notebooks\yelp\yelp_business.csv',index_col='business_id')
state_data = whole[whole.state=='NV']
categoricaldata = state_data.categories.str.contains('')
open_data = state_data.loc[state_data[select_day.value.lower()] != 'None']
new_data = open_data.where(categoricaldata).dropna(thresh = 19).sort_values(by=['stars'],ascending=False)
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
if not os.path.isdir(simOutDir):
raise Exception, "simOutDir does not currently exist as a directory"
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
sim_data = cPickle.load(open(simDataFile))
constraintIsKcatOnly = sim_data.process.metabolism.constraintIsKcatOnly
constrainedReactions = np.array(
sim_data.process.metabolism.constrainedReactionList)
# read constraint data
enzymeKineticsReader = TableReader(
os.path.join(simOutDir, "EnzymeKinetics"))
targetFluxes = enzymeKineticsReader.readColumn("targetFluxes")
actualFluxes = enzymeKineticsReader.readColumn("actualFluxes")
reactionConstraint = enzymeKineticsReader.readColumn(
"reactionConstraint")
enzymeKineticsReader.close()
initialTime = TableReader(os.path.join(
simOutDir, "Main")).readAttribute("initialTime")
time = TableReader(os.path.join(
simOutDir, "Main")).readColumn("time") - initialTime
targetAve = np.mean(targetFluxes[BURN_IN_STEPS:, :], axis=0)
actualAve = np.mean(actualFluxes[BURN_IN_STEPS:, :], axis=0)
relError = np.abs(
(actualFluxes[BURN_IN_STEPS:, :] - targetFluxes[BURN_IN_STEPS:, :])
/ (targetFluxes[BURN_IN_STEPS:, :] + 1e-15))
aveError = np.mean(relError, axis=0)
kcatOnlyReactions = np.all(
constraintIsKcatOnly[reactionConstraint[BURN_IN_STEPS:, :]],
axis=0)
kmAndKcatReactions = ~np.any(
constraintIsKcatOnly[reactionConstraint[BURN_IN_STEPS:, :]],
axis=0)
mixedReactions = ~(kcatOnlyReactions ^ kmAndKcatReactions)
kmAndKcatThresholds = [2, 10]
kmAndKcatCategorization = np.zeros(np.sum(kmAndKcatReactions))
for i, threshold in enumerate(kmAndKcatThresholds):
kmAndKcatCategorization[
targetAve[kmAndKcatReactions] /
actualAve[kmAndKcatReactions] > threshold] = i + 1
kmAndKcatCategorization[
actualAve[kmAndKcatReactions] /
targetAve[kmAndKcatReactions] > threshold] = i + 1
kmAndKcatCategorization[actualAve[kmAndKcatReactions] == 0] = -1
kcatOnlyThresholds = [2, 10]
kcatOnlyCategorization = np.zeros(np.sum(kcatOnlyReactions))
for i, threshold in enumerate(kcatOnlyThresholds):
kcatOnlyCategorization[
actualAve[kcatOnlyReactions] /
targetAve[kcatOnlyReactions] > threshold] = i + 1
kcatOnlyCategorization[actualAve[kcatOnlyReactions] == 0] = -1
targetAve += 1e-13
actualAve += 1e-13
plt.figure(figsize=(8, 8))
targetPearson = targetAve[kmAndKcatReactions]
actualPearson = actualAve[kmAndKcatReactions]
# plt.title(pearsonr(np.log10(targetPearson[actualPearson > 0]), np.log10(actualPearson[actualPearson > 0])))
plt.loglog(targetAve[kcatOnlyReactions][kcatOnlyCategorization == 0],
actualAve[kcatOnlyReactions][kcatOnlyCategorization == 0],
"og")
plt.loglog(targetAve[kcatOnlyReactions][kcatOnlyCategorization == 1],
actualAve[kcatOnlyReactions][kcatOnlyCategorization == 1],
"o")
plt.loglog(targetAve[kcatOnlyReactions][kcatOnlyCategorization == 2],
actualAve[kcatOnlyReactions][kcatOnlyCategorization == 2],
"or")
# plt.loglog(targetAve[kmAndKcatReactions], actualAve[kmAndKcatReactions], "o")
# plt.loglog(targetAve[kcatOnlyReactions], actualAve[kcatOnlyReactions], "ro")
plt.loglog([1e-12, 1], [1e-12, 1], '--g')
plt.loglog([1e-12, 1], [1e-11, 10], '--r')
plt.xlabel("Target Flux (dmol/L/s)")
plt.ylabel("Actual Flux (dmol/L/s)")
exportFigure(plt, plotOutDir, plotOutFileName)
plt.close("all")
return
source = ColumnDataSource(data=dict(
x=targetAve, y=actualAve, reactionName=constrainedReactions))
hover = HoverTool(tooltips=[
("Reaction", "@reactionName"),
])
TOOLS = [
hover,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(),
"reset",
]
p1 = figure(
x_axis_label="Target",
x_axis_type="log",
x_range=[min(targetAve[targetAve > 0]),
max(targetAve)],
y_axis_label="Actual",
y_axis_type="log",
y_range=[min(actualAve[actualAve > 0]),
max(actualAve)],
width=800,
height=800,
tools=TOOLS,
)
p1.scatter(targetAve, actualAve, source=source, size=8)
p1.line([1e-15, 10], [1e-15, 10], line_color="red", line_dash="dashed")
## bar plot of error
# sortedReactions = [constrainedReactions[x] for x in np.argsort(aveError)[::-1]]
# aveError[np.log10(aveError) == -np.inf] = 0
# source = ColumnDataSource(
# data = dict(
# x = sorted(relError, reverse = True),
# reactionName = sortedReactions
# )
# )
# p2 = Bar(data, values = "x")
# hover2 = p2.select(dict(type=HoverTool))
# hover2.tooltips = [("Reaction", "@reactionName")]
## flux for each reaction
hover2 = HoverTool(tooltips=[
("Reaction", "@reactionName"),
])
TOOLS2 = [
hover2,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(),
"reset",
]
p2 = figure(
x_axis_label="Time(s)",
y_axis_label="Flux",
y_axis_type="log",
y_range=[1e-8, 1],
width=800,
height=800,
tools=TOOLS2,
)
colors = COLORS_LARGE
nTimesteps = len(time[BURN_IN_STEPS:])
x = time[BURN_IN_STEPS:]
y = actualFluxes[BURN_IN_STEPS:, 0]
reactionName = np.repeat(constrainedReactions[0], nTimesteps)
source = ColumnDataSource(
data=dict(x=x, y=y, reactionName=reactionName))
p2.line(x, y, line_color=colors[0], source=source)
# Plot remaining metabolites onto initialized figure
for m in np.arange(1, actualFluxes.shape[1]):
y = actualFluxes[BURN_IN_STEPS:, m]
reactionName = np.repeat(constrainedReactions[m], nTimesteps)
source = ColumnDataSource(
data=dict(x=x, y=y, reactionName=reactionName))
p2.line(x, y, line_color=colors[m % len(colors)], source=source)
if not os.path.exists(os.path.join(plotOutDir, "html_plots")):
os.makedirs(os.path.join(plotOutDir, "html_plots"))
p = bokeh.io.vplot(p1, p2)
bokeh.io.output_file(os.path.join(plotOutDir, "html_plots",
plotOutFileName + ".html"),
title=plotOutFileName,
autosave=False)
bokeh.io.save(p)
bokeh.io.curstate().reset()
def drawgraph(self, ds, filterMin, filterMax, layout):
G = nx.Graph() # create an empty graph with no nodes and no edges
# nodes = []
# for i in range(len(ds.getNodes())):
# nodes.append([])
# # print(ds.getNodes()[i].getName())
# for j in range(len(ds.getNodes())):
# nodes[i].append(ds.getNodes()[i].getLinks()[j][1])
# # print(" " + str(ds.getNodes()[i].getLinks()[j][1]))
# ds.toMinSpanTree()
nodes = ds.getDoubleList(filterMin, filterMax, False)
x = filterMin
adj = np.array(nodes)
G = nx.from_numpy_matrix(adj)
for i in range(len(G.node)):
G.node[i]['name'] = ds.getNames()[i]
#pos = nx.drawing.layout.circular_layout(G, 1, None, 2)
#nx.draw_networkx(G, pos, with_labels=True)
# pt.show()
#plt.show()
plot = Plot(plot_width=500, plot_height=500,
x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1))
node_hover_tool = HoverTool(tooltips=[("Name of this node", "@name")])
# plot.add_tools(node_hover_tool, BoxZoomTool(), ResetTool())
plot.add_tools(node_hover_tool, TapTool(), BoxSelectTool(), BoxZoomTool(), UndoTool(), RedoTool(), SaveTool(),
ResetTool())
plot.toolbar_location = 'left'
if layout == 0:
graph_renderer = from_networkx(G, nx.circular_layout, scale=1, center=(0, 0))
elif layout == 1:
graph_renderer = from_networkx(G, nx.spring_layout, scale=1, center=(0, 0))
else:
graph_renderer = from_networkx(G, nx.random_layout)
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 = NodesAndLinkedEdges()
#graph_renderer.inspection_policy = EdgesAndLinkedNodes()
plot.renderers.append(graph_renderer)
output_file("interactive_graphs.html")
return 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
graph_circle.edge_renderer.glyph = MultiLine(line_width=3, line_alpha=0.8, line_color='color')
graph_circle.edge_renderer.selection_glyph = MultiLine(line_width=4, line_alpha=0.8, line_color='red')
graph_circle.edge_renderer.hover_glyph = MultiLine(line_width=4, line_alpha=0.8, line_color='yellow')
graph_circle.edge_renderer.glyph.line_width = {'field': 'weight'}
graph_circle.selection_policy = NodesAndLinkedEdges()
graph_circle.inspection_policy = NodesAndLinkedEdges()
plot_circle.add_tools(WheelZoomTool())
plot_circle.add_tools(ZoomOutTool())
plot_circle.add_tools(ZoomInTool())
plot_circle.add_tools(ResetTool())
plot_circle.add_tools(UndoTool())
plot_circle.add_tools(RedoTool())
plot_circle.add_tools(PanTool())
plot_circle.add_tools(TapTool())
plot_circle.add_tools(SaveTool())
plot_circle.add_tools(BoxSelectTool())
plot_circle.add_tools(LassoSelectTool())
# !!! Hover the node attributes !!!
node_hover = HoverTool(tooltips=[('Name', '@index'), ('Degree', '@degree'),
('Min Weight', '@minweight'), ('Max Weight', '@maxweight'), ('Sum Weight', '@sumweight')])
plot_circle.add_tools(node_hover)
plot_circle.add_layout(color_bar, 'right')
plot_circle.renderers.append(graph_circle)
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
if not os.path.isdir(inputDir):
raise Exception, "inputDir does not currently exist as a directory"
ap = AnalysisPaths(inputDir, variant_plot=True)
variants = sorted(ap._path_data['variant'].tolist()
) # Sorry for accessing private data
if len(variants) <= 1:
return
all_cells = sorted(
ap.get_cells(variant=variants, seed=[0], generation=[0]))
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
#make structures to hold mean flux values
mean_fluxes = []
BURN_IN_STEPS = 20
n_variants = 0
IDs = []
#Puts you into the specific simulation's data. Pull fluxes from here #TODO LEARN HOW TO PULL FLUXES FROM LISTENER FILE (see kineticsflux comparison)
for variant, simDir in zip(variants, all_cells):
sim_data = cPickle.load(open(ap.get_variant_kb(variant), "rb"))
simOutDir = os.path.join(simDir, "simOut")
#crafting area
enzymeKineticsReader = TableReader(
os.path.join(simOutDir, "FBAResults")) # "EnzymeKinetics"))
actualFluxes = enzymeKineticsReader.readColumn(
"reactionFluxes") #"actualFluxes")
IDs = enzymeKineticsReader.readAttribute("reactionIDs")
enzymeKineticsReader.close()
actualAve = np.mean(actualFluxes[BURN_IN_STEPS:, :], axis=0)
mean_fluxes.append(actualAve)
n_variants = n_variants + 1
###Plot the fluxes
plt.figure(figsize=(8.5, 11))
#Generalizred plotting
for j in range(0, n_variants):
for k in range(0, n_variants):
if j <= k:
continue
plt.subplot(n_variants - 1, n_variants - 1, j + k)
plt.plot(np.log10(mean_fluxes[j][:]),
np.log10(mean_fluxes[k][:]), 'o')
plt.plot([-12, 0], [-12, 0],
color='k',
linestyle='-',
linewidth=2)
plt.xlabel('Variant ' + str(j) + ' Flux')
plt.ylabel('Variant ' + str(k) + ' Flux')
plt.ylim((-11, 0))
plt.xlim((-11, 0))
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close("all")
#nifty fun tool
# Bokeh
if len(mean_fluxes) < 2:
return
# Plot first metabolite to initialize plot settings
x = np.log10(mean_fluxes[0][:])
y = np.log10(mean_fluxes[1][:])
source = ColumnDataSource(data=dict(x=x, y=y, rxn=IDs))
hover = HoverTool(tooltips=[
("ID", "@rxn"),
])
TOOLS = [
hover,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(), "reset"
]
p = figure(
x_axis_label="Variant 0 Flux",
y_axis_label="Variant 1 Flux",
width=800,
height=800,
tools=TOOLS,
)
p.circle(
'x', 'y', size=5, source=source
) #np.log10(mean_fluxes[0][:]),np.log10(mean_fluxes[1][:]), size=10)
p.line([-12, 0], [-12, 0], color="firebrick", line_width=2)
if not os.path.exists(os.path.join(plotOutDir, "html_plots")):
os.makedirs(os.path.join(plotOutDir, "html_plots"))
bokeh.io.output_file(os.path.join(plotOutDir, "html_plots",
plotOutFileName + ".html"),
title=plotOutFileName,
autosave=False)
bokeh.io.save(p)
bokeh.io.curstate().reset()
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
if metadata["variant"] != "tfActivity":
print "This plot only runs for the 'tfActivity' variant."
return
if not os.path.isdir(inputDir):
raise Exception, "inputDir does not currently exist as a directory"
ap = AnalysisPaths(inputDir, variant_plot=True)
variants = sorted(ap._path_data['variant'].tolist()
) # Sorry for accessing private data
if 0 in variants:
variants.remove(0)
if len(variants) == 0:
return
all_cells = sorted(
ap.get_cells(variant=variants, seed=[0], generation=[0]))
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
expectedProbBound = []
simulatedProbBound = []
expectedSynthProb = []
simulatedSynthProb = []
targetId = []
targetCondition = []
targetToTfType = {}
for variant, simDir in zip(variants, all_cells):
sim_data = cPickle.load(open(ap.get_variant_kb(variant), "rb"))
shape = sim_data.process.transcription_regulation.recruitmentData[
"shape"]
hI = sim_data.process.transcription_regulation.recruitmentData[
"hI"]
hJ = sim_data.process.transcription_regulation.recruitmentData[
"hJ"]
hV = sim_data.process.transcription_regulation.recruitmentData[
"hV"]
H = np.zeros(shape, np.float64)
H[hI, hJ] = hV
colNames = sim_data.process.transcription_regulation.recruitmentColNames
tfList = ["basal (no TF)"] + sorted(
sim_data.tfToActiveInactiveConds)
simOutDir = os.path.join(simDir, "simOut")
tf = tfList[(variant + 1) // 2]
tfStatus = None
if variant % 2 == 1:
tfStatus = "active"
else:
tfStatus = "inactive"
bulkMoleculesReader = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
bulkMoleculeIds = bulkMoleculesReader.readAttribute("objectNames")
rnaSynthProbReader = TableReader(
os.path.join(simOutDir, "RnaSynthProb"))
rnaIds = rnaSynthProbReader.readAttribute("rnaIds")
tfTargetBoundIds = []
tfTargetBoundIndices = []
tfTargetSynthProbIds = []
tfTargetSynthProbIndices = []
for tfTarget in sorted(sim_data.tfToFC[tf]):
tfTargetBoundIds.append(tfTarget + "__" + tf)
tfTargetBoundIndices.append(
bulkMoleculeIds.index(tfTargetBoundIds[-1]))
tfTargetSynthProbIds.append(tfTarget + "[c]")
tfTargetSynthProbIndices.append(
rnaIds.index(tfTargetSynthProbIds[-1]))
tfTargetBoundCountsAll = bulkMoleculesReader.readColumn(
"counts")[:, tfTargetBoundIndices]
tfTargetSynthProbAll = rnaSynthProbReader.readColumn(
"rnaSynthProb")[:, tfTargetSynthProbIndices]
for targetIdx, tfTarget in enumerate(sorted(sim_data.tfToFC[tf])):
tfTargetBoundCounts = tfTargetBoundCountsAll[:,
targetIdx].reshape(
-1)
expectedProbBound.append(sim_data.pPromoterBound[tf + "__" +
tfStatus][tf])
simulatedProbBound.append(tfTargetBoundCounts[5:].mean())
tfTargetSynthProbId = [tfTarget + "[c]"]
tfTargetSynthProbIndex = np.array(
[rnaIds.index(x) for x in tfTargetSynthProbId])
tfTargetSynthProb = tfTargetSynthProbAll[:,
targetIdx].reshape(-1)
rnaIdx = np.where(
sim_data.process.transcription.rnaData["id"] == tfTarget +
"[c]")[0][0]
regulatingTfIdxs = np.where(H[rnaIdx, :])
for i in regulatingTfIdxs[0]:
if colNames[i].split("__")[1] != "alpha":
if tfTarget not in targetToTfType:
targetToTfType[tfTarget] = []
targetToTfType[tfTarget].append(
sim_data.process.transcription_regulation.
tfToTfType[colNames[i].split("__")[1]])
expectedSynthProb.append(
sim_data.process.transcription.rnaSynthProb[
tf + "__" + tfStatus][rnaIdx])
simulatedSynthProb.append(tfTargetSynthProb[5:].mean())
targetId.append(tfTarget)
targetCondition.append(tf + "__" + tfStatus)
bulkMoleculesReader.close()
rnaSynthProbReader.close()
expectedProbBound = np.array(expectedProbBound)
simulatedProbBound = np.array(simulatedProbBound)
expectedSynthProb = np.array(expectedSynthProb)
simulatedSynthProb = np.array(simulatedSynthProb)
regressionResult = scipy.stats.linregress(
np.log10(expectedProbBound[expectedProbBound > NUMERICAL_ZERO]),
np.log10(simulatedProbBound[expectedProbBound > NUMERICAL_ZERO]))
regressionResultLargeValues = scipy.stats.linregress(
np.log10(expectedProbBound[expectedProbBound > 1e-2]),
np.log10(simulatedProbBound[expectedProbBound > 1e-2]))
ax = plt.subplot(2, 1, 1)
ax.scatter(np.log10(expectedProbBound), np.log10(simulatedProbBound))
plt.xlabel("log10(Expected probability bound)", fontsize=6)
plt.ylabel("log10(Simulated probability bound)", fontsize=6)
plt.title(
"Slope: %0.3f Intercept: %0.3e (Without Small Values: Slope: %0.3f Intercept: %0.3e)"
% (regressionResult.slope, regressionResult.intercept,
regressionResultLargeValues.slope,
regressionResultLargeValues.intercept),
fontsize=6)
ax.tick_params(which='both', direction='out', labelsize=6)
regressionResult = scipy.stats.linregress(
np.log10(expectedSynthProb[expectedSynthProb > NUMERICAL_ZERO]),
np.log10(simulatedSynthProb[expectedSynthProb > NUMERICAL_ZERO]))
ax = plt.subplot(2, 1, 2)
ax.scatter(np.log10(expectedSynthProb), np.log10(simulatedSynthProb))
plt.xlabel("log10(Expected synthesis probability)", fontsize=6)
plt.ylabel("log10(Simulated synthesis probability)", fontsize=6)
plt.title("Slope: %0.3f Intercept: %0.3e" %
(regressionResult.slope, regressionResult.intercept),
fontsize=6)
ax.tick_params(which='both', direction='out', labelsize=6)
plt.tight_layout()
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close("all")
# Probability bound - hover for ID
source1 = ColumnDataSource(data=dict(x=np.log10(expectedProbBound),
y=np.log10(simulatedProbBound),
ID=targetId,
condition=targetCondition))
hover1 = HoverTool(tooltips=[("ID", "@ID"), ("condition",
"@condition")])
tools1 = [
hover1,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(), "reset"
]
s1 = figure(x_axis_label="log10(Expected probability bound)",
y_axis_label="log10(Simulated probability bound)",
width=800,
height=500,
tools=tools1)
s1.scatter("x", "y", source=source1)
if not os.path.exists(os.path.join(plotOutDir, "html_plots")):
os.makedirs(os.path.join(plotOutDir, "html_plots"))
bokeh.io.output_file(os.path.join(
plotOutDir, "html_plots",
plotOutFileName + "__probBound" + ".html"),
title=plotOutFileName,
autosave=False)
bokeh.io.save(s1)
# Synthesis probability - hover for ID
source2 = ColumnDataSource(data=dict(x=np.log10(expectedSynthProb),
y=np.log10(simulatedSynthProb),
ID=targetId,
condition=targetCondition))
hover2 = HoverTool(tooltips=[("ID", "@ID"), ("condition",
"@condition")])
tools2 = [
hover2,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(), "reset"
]
s2 = figure(x_axis_label="log10(Expected synthesis probability)",
y_axis_label="log10(Simulated synthesis probability)",
width=800,
height=500,
tools=tools2)
s2.scatter("x", "y", source=source2)
bokeh.io.output_file(os.path.join(
plotOutDir, "html_plots",
plotOutFileName + "__synthProb" + ".html"),
title=plotOutFileName,
autosave=False)
bokeh.io.save(s2)
# Synthesis probability - filter targets by TF type
bokeh.io.output_file(os.path.join(
plotOutDir, "html_plots",
plotOutFileName + "__synthProb__interactive" + ".html"),
title=plotOutFileName,
autosave=False)
tfTypes = []
for i in targetId:
if i in targetToTfType:
uniqueSet = np.unique(targetToTfType[i])
if uniqueSet.shape[0] == 1:
tfTypes.append(uniqueSet[0])
elif uniqueSet.shape[0] == 3:
tfTypes.append("all")
else:
tfTypes.append(uniqueSet[0] + "_" + uniqueSet[1])
else:
tfTypes.append("none")
tfTypes = np.array(tfTypes)
x0 = np.copy(expectedSynthProb)
x0[np.where(tfTypes != "0CS")] = np.nan
x1 = np.copy(expectedSynthProb)
x1[np.where(tfTypes != "1CS")] = np.nan
x2 = np.copy(expectedSynthProb)
x2[np.where(tfTypes != "2CS")] = np.nan
x01 = np.copy(expectedSynthProb)
x01[np.where(tfTypes != "0CS_1CS")] = np.nan
x02 = np.copy(expectedSynthProb)
x02[np.where(tfTypes != "0CS_2CS")] = np.nan
x12 = np.copy(expectedSynthProb)
x12[np.where(tfTypes != "1CS_2CS")] = np.nan
y0 = np.copy(simulatedSynthProb)
y0[np.where(tfTypes != "0CS")] = np.nan
y1 = np.copy(simulatedSynthProb)
y1[np.where(tfTypes != "1CS")] = np.nan
y2 = np.copy(simulatedSynthProb)
y2[np.where(tfTypes != "2CS")] = np.nan
y01 = np.copy(simulatedSynthProb)
y01[np.where(tfTypes != "0CS_1CS")] = np.nan
y02 = np.copy(simulatedSynthProb)
y02[np.where(tfTypes != "0CS_2CS")] = np.nan
y12 = np.copy(simulatedSynthProb)
x12[np.where(tfTypes != "1CS_2CS")] = np.nan
source_all = ColumnDataSource(data=dict(x=np.log10(expectedSynthProb),
y=np.log10(simulatedSynthProb),
ID=targetId,
condition=targetCondition))
source_tf = ColumnDataSource(
data=dict(x0=np.log10(x0),
y0=np.log10(y0),
x1=np.log10(x1),
y1=np.log10(y1),
x2=np.log10(x2),
y2=np.log10(y2),
x01=np.log10(x01),
y01=np.log10(y01),
x02=np.log10(x02),
y02=np.log10(y02),
x12=np.log10(x12),
y12=np.log10(y12),
x123=np.log10(expectedSynthProb),
y123=np.log10(simulatedSynthProb),
ID=targetId,
condition=targetCondition))
hover3 = HoverTool(tooltips=[("ID", "@ID"), ("condition",
"@condition")])
tools3 = [
hover3,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(), "reset"
]
axis_max = np.ceil(np.log10(expectedSynthProb).max())
for i in np.sort(expectedSynthProb):
if i > 0:
break
axis_min = np.floor(np.log10(i))
s3 = figure(
x_axis_label="log10(Expected synthesis probability)",
y_axis_label="log10(Simulated synthesis probability)",
plot_width=800,
plot_height=500,
x_range=(axis_min, axis_max),
y_range=(axis_min, axis_max),
tools=tools3,
)
s3.scatter("x", "y", source=source_all)
callback = CustomJS(args=dict(source_all=source_all,
source_tf=source_tf),
code="""
var data_all = source_all.get('data');
var data_tf = source_tf.get('data');
data_all['x'] = data_tf['x' + cb_obj.get("name")];
data_all['y'] = data_tf['y' + cb_obj.get("name")];
source_all.trigger('change');
""")
toggle0 = Button(label="0CS", callback=callback, name="0")
toggle1 = Button(label="1CS", callback=callback, name="1")
toggle2 = Button(label="2CS", callback=callback, name="2")
toggle3 = Button(label="0CS and 1CS", callback=callback, name="01")
toggle4 = Button(label="0CS and 2CS", callback=callback, name="02")
toggle5 = Button(label="1CS and 2CS", callback=callback, name="12")
toggle6 = Button(label="All", callback=callback, name="123")
layout = vplot(toggle0, toggle1, toggle2, toggle3, toggle4, toggle5,
toggle6, s3)
bokeh.io.save(layout)
bokeh.io.curstate().reset()
zoom=13)
plot = GMapPlot(x_range=DataRange1d(),
y_range=DataRange1d(),
map_options=map_options,
title="Washington, DC",
plot_width=1280,
plot_height=1280,
responsive=True)
# Finally plot it
lines = MultiLine(xs="lons",
ys="lats",
line_alpha="line_alpha",
line_width="line_width",
line_color="red",
line_cap="round")
circle = Circle(x="lon",
y="lat",
size=10,
fill_color="blue",
fill_alpha=0.8,
line_color=None)
plot.add_glyph(source, circle)
plot.add_glyph(line_source, lines)
plot.add_tools(PanTool(), WheelZoomTool(), BoxZoomTool(), hover, ResetTool(),
UndoTool(), RedoTool(), PreviewSaveTool())
output_file("gmap_plot.html")
show(plot)
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
if not os.path.isdir(inputDir):
raise Exception, "inputDir does not currently exist as a directory"
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
ap = AnalysisPaths(inputDir, variant_plot=True)
variants = sorted(ap._path_data['variant'].tolist()
) # Sorry for accessing private data
variant = variants[0]
sim_data = cPickle.load(open(ap.get_variant_kb(variant), "rb"))
targetToFC = {}
targetToFCTF = {}
for tf in sim_data.tfToActiveInactiveConds:
for target in sim_data.tfToFC[tf]:
if target not in targetToFC:
targetToFC[target] = []
targetToFCTF[target] = []
targetToFC[target].append(np.log2(sim_data.tfToFC[tf][target]))
targetToFCTF[target].append(tf)
for target in targetToFC:
targetToFC[target] = np.array(targetToFC[target])
targets = sorted(targetToFC)
x = []
y = []
maxVals = []
tfs = []
targetIds = []
for idx, target in enumerate(targets):
for FC, tf in zip(targetToFC[target], targetToFCTF[target]):
x.append(idx)
y.append(FC)
if targetToFC[target].max() >= -1. * targetToFC[target].min():
maxVals.append(targetToFC[target].max())
else:
maxVals.append(targetToFC[target].min())
tfs.append(tf)
targetIds.append(target)
conditions = [
sim_data.conditions[tf + "__active"]["nutrients"] for tf in tfs
]
x = np.array(x)
y = np.array(y)
maxVals = np.array(maxVals)
sortedIdxs = np.argsort(maxVals)
conditions = [conditions[i] for i in sortedIdxs]
tfs = [tfs[i] for i in sortedIdxs]
targetIds = [targetIds[i] for i in sortedIdxs]
fig = plt.figure(figsize=(11, 8.5))
ax = plt.subplot(1, 1, 1)
ax.plot(x, y[sortedIdxs], ".")
xlabel = "Gene targets (sorted)"
ylabel = "log2 (Target expression fold change)"
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close("all")
source = ColumnDataSource(data=dict(x=x,
y=y[sortedIdxs],
targetId=targetIds,
tfId=tfs,
condition=conditions))
hover = HoverTool(
tooltips=[("target",
"@targetId"), ("TF",
"@tfId"), ("condition", "@condition")])
tools = [
hover,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(), "reset"
]
plot = figure(x_axis_label=xlabel,
y_axis_label=ylabel,
width=800,
height=500,
tools=tools)
plot.scatter("x", "y", source=source)
if not os.path.exists(os.path.join(plotOutDir, "html_plots")):
os.makedirs(os.path.join(plotOutDir, "html_plots"))
bokeh.io.output_file(os.path.join(
plotOutDir, "html_plots",
plotOutFileName + "__probBound" + ".html"),
title=plotOutFileName,
autosave=False)
bokeh.io.save(plot)
bokeh.io.curstate().reset()
select_day = Select(options=[
'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',
'Saturday'
],
value='Monday',
title='Day of the Week')
chosen_tools = [
hover,
ResetTool(),
BoxSelectTool(),
SaveTool(),
PanTool(),
UndoTool(),
RedoTool(),
ZoomInTool(),
ZoomOutTool()
]
#data
data = pd.read_csv(r'~/Desktop/yelp/yelp_business.csv',
index_col='business_id')
hour = pd.read_csv(r'~/Desktop/yelp/yelp_business_hours.csv',
index_col='business_id')
whole = pd.merge(data, hour, left_index=True, right_index=True)
#data = pd.read_csv(r'E:\Software\WinPython\notebooks\yelp\yelp_business.csv',index_col='business_id')
state_data = whole[whole.state == 'NV']
categoricaldata = state_data.categories.str.contains('')
plot_width=1200,
title='S&P 500',
x_axis_label='Date',
y_axis_label='Close (in USD)')
p.line(sp500_df['Date'], sp500_df['Close'], color='blue', legend='')
# Hover tool with vline mode
hover = HoverTool(
tooltips=[('Close', '$@{Close}{%0.2f}'), ('Date', '@date{%F}')],
formatters={
'date': 'datetime', # use 'datetime' formatter for 'date' field
'Close': 'printf', # use 'printf' formatter for 'adj close' field
# use default 'numeral' formatter for other fields
},
mode='vline')
p.add_tools(hover)
p.add_tools(LassoSelectTool())
p.add_tools(PolySelectTool())
p.add_tools(TapTool())
p.add_tools(UndoTool())
p.add_tools(RedoTool())
p.add_tools(ResetTool())
p.add_tools(ZoomInTool())
p.add_tools(ZoomOutTool())
p.add_tools(CrosshairTool())
html = file_html(p, CDN, "my plot")
with open("./test_bokeh.html", "w") as html_file:
html_file.write(html)
def make_plot(self,title, x, y):
"""
:param title:
:param x:
:param y:
:return:
"""
print(title,x,y)
t0 = time()
pt = PanTool()
lst = LassoSelectTool()
pst = PolySelectTool()
bst = BoxSelectTool()
wzt = WheelZoomTool()
tt = TapTool()
st = SaveTool()
ut = UndoTool()
rt = RedoTool()
p = figure(
tools=[pt,lst,pst,bst,wzt,tt,st,ut,rt],
plot_width=400,
plot_height=400,
title=self.initial_plot_2_data_mapper[x]+" vs. "+self.initial_plot_2_data_mapper[y],
webgl=accelerator)
# configure so that no drag tools are active
p.toolbar.active_drag = pt
# configure so that Bokeh chooses what (if any) scroll tool is active
p.toolbar.active_scroll = wzt
# configure so that a specific PolySelect tap tool is active
p.toolbar.active_tap = tt
p.xaxis.axis_label = self.initial_plot_2_data_mapper[x]
p.yaxis.axis_label = self.initial_plot_2_data_mapper[y]
c = p.circle(x=x, y=y, size=5, color="__COLOR__", alpha=.75, source=self.source,
hover_color='white', hover_alpha=1, hover_line_color='grey')
c.data_source.on_change('selected', self.update)
# Edge generator
'''
self.graph_set = [{i: [[1,0.15],[2,0.5],[3,0.99]] for i in range(self.n)}]
self.edge_colors = qual_2_color(['g'+str(i) for i,_ in enumerate(self.graph_set)])
self.edge_sources = [ColumnDataSource({'x0': [],
'y0': [],
'x1': [],
'y1': [],
'alpha': []})
for i in self.graph_set]
self.edge_segments = [p.segment(x0='x0',
y0='y0',
x1='x1',
y1='y1',
color=self.edge_colors[i],
alpha='alpha',
line_width=3,
#line_dash=[1,1],
source=self.edge_sources[i])
for i, _ in enumerate(self.graph_set)]
for i, _ in enumerate(self.graph_set):
code1 = """
var links = %s;
var data = {'x0': [], 'y0': [], 'x1': [], 'y1': [], 'alpha': []};
var cdata = circle.get('data');
var indices = cb_data.index['1d'].indices;
for (i=0; i < indices.length; i++) {
ind0 = indices[i]
for (j=0; j < links[ind0].length; j++) {
ind1 = links[ind0][j][0];
w = links[ind0][j][1];
""" % self.graph_set[i]
code2 = "data['x0'].push(cdata['" + x + "'][ind0]);\n" + \
"data['y0'].push(cdata['" + y + "'][ind0]);\n" + \
"data['x1'].push(cdata['" + x + "'][ind1]);\n" + \
"data['y1'].push(cdata['" + y + "'][ind1]);\n" + \
"data['alpha'].push([w]);\n"
code3 = "}}segment.set('data', data);"
code = code1 + code2 + code3
callback = CustomJS(args={'circle': c.data_source,
'segment': self.edge_segments[i].data_source},
code=code)
p.add_tools(HoverTool(tooltips=None, callback=callback, renderers=[c]))
'''
p.select(BoxSelectTool).select_every_mousemove = False
p.select(LassoSelectTool).select_every_mousemove = False
# Plot Controls
xdim_select = Select(title="X Dim", options=self.data_dict.keys(), value=self.initial_plot_2_data_mapper[x],width=400)
ydim_select = Select(title="Y Dim", options=self.data_dict.keys(), value=self.initial_plot_2_data_mapper[y],width=400)
xdim_select.on_change('value', self.plot_update)
ydim_select.on_change('value', self.plot_update)
remove = Button(label="Remove", button_type="danger",width=400)
remove.on_click(partial(self.remove_plot,title,x,y))
self.plot_control_dict[title] = {'x':xdim_select,
'y':ydim_select,
'xprev':xdim_select.value,
'yprev':ydim_select.value,
'figure':p,
'tooltip':HoverTool(tooltips=self.tooltip_list,point_policy='snap_to_data',show_arrow=False)}
# Give the hover tool a tool tip
self.plot_control_dict[title]['figure'].add_tools(self.plot_control_dict[title]['tooltip'])
# Form Tab
plot_options = WidgetBox(xdim_select,ydim_select,remove)
tab1 = Panel(child=self.plot_control_dict[title]['figure'], title=title,width=400,height=400)
tab2 = Panel(child=plot_options, title="options",width=400,height=400)
tabs = Tabs(tabs=[tab1, tab2],width=400,height=400)
self.tab_list.append(tabs)
self.circle_list.append(c)
print('Plot Time: ' + str(time() - t0))
return tabs, c
def metric_rank_bar_graph(exoplanet_array, tooltip_dict=dict()):
'''Funtion to generate html for an interactive bokeh bar graph, specifically for metric score vs rank'''
# append to tooltip arrays
for planet in exoplanet_array:
for prop, vals in tooltip_dict.items():
vals.append(rgetattr(planet, prop))
# axis scale
x_axis_type = 'linear'
y_axis_type = 'log'
# create tooltip table
tooltips = [('(rank, metric)', '(@rank, @decision_metric)')]
for prop in tooltip_dict.keys():
tooltips.append((prop, '@%s' % prop))
# create plot figure
plot = figure(
x_axis_type=x_axis_type,
y_axis_type=y_axis_type,
plot_height=400,
sizing_mode='stretch_width',
tools=[
PanTool(),
BoxZoomTool(),
WheelZoomTool(),
TapTool(),
UndoTool(),
RedoTool(),
CrosshairTool(),
HoverTool(mode='vline'),
SaveTool(),
ResetTool()
],
tooltips=tooltips,
background_fill_alpha=0.7,
border_fill_alpha=0.7,
)
# link points to exoplanet.eu
url = 'http://www.exoplanet.eu/catalog/@name'
taptool = plot.select(type=TapTool)
taptool.callback = OpenURL(url=url.replace(' ', '_'))
# label axes
plot.xaxis.axis_label = 'Rank'
plot.yaxis.axis_label = 'Decision Metric'
fontsize = '12pt'
plot.xaxis.axis_label_text_font_size = fontsize
plot.yaxis.axis_label_text_font_size = fontsize
# make data source
source_dict = dict(
rank=[i for i in range(1,
len(exoplanet_array) + 1)],
decision_metric=[planet.decision_metric for planet in exoplanet_array],
)
source_dict.update(tooltip_dict) # add tooltip info to data source
source = ColumnDataSource(data=source_dict)
# make colormap
detection_methods = [
'Primary Transit',
'Radial Velocity',
'Imaging',
'Microlensing',
'Timing',
'Astrometry',
'TTV',
'Default',
'Primary Transit, TTV',
'Controversial',
]
cmap = factor_cmap('detection_type',
palette=Category10[10],
factors=detection_methods)
# plot graph
plot.vbar(
x='rank',
top='decision_metric',
color=cmap,
bottom=1, # so that log scale can work,
width=0.9,
legend_field='detection_type',
source=source)
# legend
plot.legend.title = 'Detection method'
plot.legend.location = 'top_right'
plot.legend.background_fill_alpha = 0
return file_html(gridplot([[plot]], sizing_mode='stretch_both'), CDN)
def linked_scatter_graph(master_source_dict, xproperties, yproperties,
cproperties, sproperties, xlogs, ylogs, clogs, slogs,
errorbar_xs, errorbar_ys, x_hists, y_hists,
tooltip_list):
'''Funtion to generate html for an interactive bokeh scatter/errorbar graph'''
# copy source_dict to avoid overmapping
source_dict = copy.deepcopy(master_source_dict)
# size mapping (do before making the data source)
for i, (sproperty, slog) in enumerate(zip(sproperties, slogs)):
if sproperty == 'None':
source_dict.update({'smap%i' % i: [4] * len(source_dict['name'])
}) # size 4 is default
else:
arr = source_dict[sproperty]
if slog: arr = np.log(arr)
source_dict.update({
'smap%i' % i:
np.nan_to_num(
np.multiply(np.subtract(arr, np.nanmin(arr)),
15 / np.nanmax(arr))).tolist()
})
# make data source
source = ColumnDataSource(data=source_dict)
plots = []
for i in range(len(xproperties)): # don't use i for loops inside this
xproperty, yproperty, cproperty, sproperty, xlog, ylog, clog, slog, errorbar_x, errorbar_y, x_hist, y_hist = xproperties[
i], yproperties[i], cproperties[i], sproperties[i], xlogs[
i], ylogs[i], clogs[i], slogs[i], errorbar_xs[i], errorbar_ys[
i], x_hists[i], y_hists[i]
if xproperty != 'None' and yproperty != 'None':
# units
units = [''] * 4
properties = [xproperty, yproperty, cproperty, sproperty]
for j, prop in enumerate(
properties): # must use enumerate, not zip
if prop != 'None':
if 'host.' in prop:
units[j] = Star.property_dict[prop.replace(
'host.', '')]
else:
units[j] = Exoplanet.property_dict[prop]
(xunit, yunit, cunit, sunit) = (unit for unit in units)
formatters = [''] * 4 # for datetime formatting in tooltips
for j, unit in enumerate(units):
if unit == 'date': formatters[j] = '{%F}'
if unit == 'year': formatters[j] = '{%Y}'
# axis scale
if xlog: x_axis_type = 'log'
else: x_axis_type = 'linear'
if ylog: y_axis_type = 'log'
else: y_axis_type = 'linear'
if xunit == 'date' or xunit == 'year': x_axis_type = 'datetime'
if yunit == 'date' or yunit == 'year': y_axis_type = 'datetime'
# create tooltip table
tooltips = [
('(%s, %s)' %
(xproperty.replace('.', '_'), yproperty.replace('.', '_')),
'(@{%s}%s, @{%s}%s)' %
(xproperty, formatters[0], yproperty, formatters[1])),
('(%s, %s)' %
(cproperty.replace('.', '_'), sproperty.replace('.', '_')),
'(@{%s}%s, @{%s}%s)' %
(cproperty, formatters[2], sproperty, formatters[3])),
]
for prop in tooltip_list:
tooltips.append((prop, '@%s' % prop))
# create plot figure
plot = figure(
x_axis_type=x_axis_type,
y_axis_type=y_axis_type,
sizing_mode='stretch_both',
tools=[
PanTool(),
BoxZoomTool(),
BoxSelectTool(),
LassoSelectTool(),
WheelZoomTool(),
TapTool(),
UndoTool(),
RedoTool(),
CrosshairTool(),
SaveTool(),
ResetTool(),
HoverTool(tooltips=tooltips,
formatters={
'@{discovered}': 'datetime',
'@{updated}': 'datetime'
})
],
toolbar_location='above',
# title=str(datetime.date.today()),
background_fill_alpha=0.7,
border_fill_alpha=0.7,
)
# invert scales for magnitudes
if 'mag_' in xproperty: plot.x_range.flipped = True
if 'mag_' in yproperty: plot.y_range.flipped = True
# link points to exoplanet.eu
url = 'http://www.exoplanet.eu/catalog/@name'
taptool = plot.select(type=TapTool)
taptool.callback = OpenURL(url=url.replace(' ', '_'))
# label axes
plot.xaxis.axis_label = xproperty.replace('_', ' ').replace(
'.', ' ').capitalize() + ' (%s)' % xunit
plot.yaxis.axis_label = yproperty.replace('_', ' ').replace(
'.', ' ').capitalize() + ' (%s)' % yunit
# font sizes
fontsize = '12pt'
plot.xaxis.axis_label_text_font_size = fontsize
plot.yaxis.axis_label_text_font_size = fontsize
# color mapping
if cproperty == 'None': cmap = Category10[10][0]
elif cproperty == 'detection_type':
# detection type is categorical so needs special treatment
detection_methods = [
'Primary Transit', 'Radial Velocity', 'Imaging',
'Microlensing', 'Timing', 'Astrometry', 'TTV', 'Default',
'Primary Transit, TTV', 'Controversial'
]
cmap = factor_cmap('detection_type',
palette=Category10[10],
factors=detection_methods)
# counts
counts = {method: 0 for method in detection_methods}
for j, method in enumerate(source_dict['detection_type']):
if np.isfinite(source_dict[xproperty][j]) and np.isfinite(
source_dict[yproperty][j]):
counts[method] += 1
# need to create legend manually so we can place it outside the plot area
# legend placement depends on whether histograms are present
if y_hist:
blank = figure(
width_policy='min',
height_policy='min',
width=205,
height=290,
outline_line_color=None,
background_fill_alpha=0.7,
border_fill_alpha=0.7,
)
legend = categorical_legend(detection_methods,
counts.values(),
'',
Category10[10],
fig=blank)
else:
legend = categorical_legend(detection_methods,
counts.values(),
'',
Category10[10],
fig=plot)
plot.add_layout(legend, 'right')
else:
if clog:
cmap = log_cmap(cproperty,
palette=Turbo256,
low=np.nanmin(source_dict[cproperty]),
high=np.nanmax(source_dict[cproperty]))
color_bar = ColorBar(color_mapper=cmap['transform'],
ticker=LogTicker(),
width=8,
location=(0, 0),
background_fill_alpha=0)
else:
cmap = linear_cmap(cproperty,
palette=Turbo256,
low=np.nanmin(source_dict[cproperty]),
high=np.nanmax(source_dict[cproperty]))
color_bar = ColorBar(color_mapper=cmap['transform'],
width=8,
location=(0, 0),
background_fill_alpha=0)
plot.add_layout(color_bar, 'right')
# bokeh does not have a native colorbar label item so we will use a plot title as a substitute
plot.title.text = cproperty.replace('_', ' ').replace(
'.', ' ').capitalize() + ' (%s)' % cunit
plot.title_location = 'right'
plot.title.align = 'center'
plot.title.text_font_size = fontsize
plot.title.text_font_style = 'italic'
# plot graph
plot.scatter(
xproperty,
yproperty,
color=cmap,
size='smap%i' % i,
source=source,
)
# errorbars
if xproperty + '_error_min' in Exoplanet.property_dict or xproperty.replace(
'host.', '') + '_error_min' in Star.property_dict:
wx = Whisker(
source=source,
dimension='width',
visible=errorbar_x,
base=yproperty,
upper=xproperty + '_error_max',
lower=xproperty + '_error_min',
line_color=cmap,
upper_head=None,
lower_head=None,
)
plot.add_layout(wx)
if yproperty + '_error_min' in Exoplanet.property_dict or yproperty.replace(
'host.', '') + '_error_min' in Star.property_dict:
wy = Whisker(
source=source,
dimension='height',
visible=errorbar_y,
base=xproperty,
upper=yproperty + '_error_max',
lower=yproperty + '_error_min',
line_color=cmap,
upper_head=None,
lower_head=None,
)
plot.add_layout(wy)
# histograms
full_colour = '#756bb1'
sample_colour = '#74c476'
if x_hist:
# list setup
full_list = source_dict[xproperty]
short_list = [
xval for xval, yval in zip(source_dict[xproperty],
source_dict[yproperty])
if not np.isnan(yval)
]
min_ = np.nanmin(full_list)
max_ = np.nanmax(full_list)
# plot setup
hxplot = figure(
x_range=plot.x_range,
x_axis_type=x_axis_type,
height=300,
sizing_mode='stretch_width',
background_fill_alpha=0.7,
border_fill_alpha=0.7,
)
hxplot.xaxis.axis_label = xproperty.replace('_', ' ').replace(
'.', ' ').capitalize() + ' (%s)' % xunit
hxplot.yaxis.axis_label = 'Frequency'
hxplot.xaxis.axis_label_text_font_size = fontsize
hxplot.yaxis.axis_label_text_font_size = fontsize
# bins
if xlog:
bins = np.logspace(np.log10(min_), np.log10(max_), 100)
else:
bins = np.linspace(min_, max_, 100)
# full range histogram
hist, edges = np.histogram(full_list, bins=bins)
hxplot.quad(top=hist,
bottom=0,
left=edges[:-1],
right=edges[1:],
color=full_colour,
fill_alpha=0.5,
legend_label='All')
# only plotted histogram
hist, edges = np.histogram(short_list, bins=bins)
hxplot.quad(top=hist,
bottom=0,
left=edges[:-1],
right=edges[1:],
color=sample_colour,
fill_alpha=0.5,
legend_label='Shown')
# legend setup
hxplot.legend.click_policy = 'hide'
hxplot.legend.background_fill_alpha = 0
if y_hist:
# list setup
full_list = source_dict[yproperty]
short_list = [
yval for xval, yval in zip(source_dict[xproperty],
source_dict[yproperty])
if not np.isnan(xval)
]
min_ = np.nanmin(full_list)
max_ = np.nanmax(full_list)
# plot setup
hyplot = figure(
y_range=plot.y_range,
y_axis_type=y_axis_type,
width=300,
sizing_mode='stretch_height',
background_fill_alpha=0.7,
border_fill_alpha=0.7,
)
hyplot.yaxis.axis_label = yproperty.replace('_', ' ').replace(
'.', ' ').capitalize() + ' (%s)' % yunit
hyplot.xaxis.axis_label = 'Frequency'
hyplot.xaxis.axis_label_text_font_size = fontsize
hyplot.yaxis.axis_label_text_font_size = fontsize
# bins
if xlog:
bins = np.logspace(np.log10(min_), np.log10(max_), 100)
else:
bins = np.linspace(min_, max_, 100)
# full range histogram
hist, edges = np.histogram(full_list, bins=bins)
hyplot.quad(right=hist,
left=0,
top=edges[:-1],
bottom=edges[1:],
color=full_colour,
fill_alpha=0.5,
legend_label='All')
# only plotted histogram
hist, edges = np.histogram(short_list, bins=bins)
hyplot.quad(right=hist,
left=0,
top=edges[:-1],
bottom=edges[1:],
color=sample_colour,
fill_alpha=0.5,
legend_label='Shown')
# legend setup
hyplot.legend.click_policy = 'hide'
hyplot.legend.background_fill_alpha = 0
# layouts
if cproperty != 'detection_type':
blank = None # don't need this plot if no legend is present
if x_hist and y_hist:
layout = gridplot([[hxplot, blank], [plot, hyplot]],
sizing_mode='stretch_both')
elif x_hist:
layout = gridplot([[hxplot], [plot]],
sizing_mode='stretch_both')
elif y_hist:
layout = gridplot([[plot, hyplot, blank]],
sizing_mode='stretch_both')
else:
layout = gridplot([[plot]], sizing_mode='stretch_both')
plots.append(layout)
# layout
layout = column(row(plots), sizing_mode='stretch_both')
return file_html(layout, CDN)
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata):
if not os.path.isdir(simOutDir):
raise Exception, "simOutDir does not currently exist as a directory"
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
sim_data = cPickle.load(open(simDataFile))
constraintIsKcatOnly = sim_data.process.metabolism.constraintIsKcatOnly
mainListener = TableReader(os.path.join(simOutDir, "Main"))
initialTime = mainListener.readAttribute("initialTime")
time = mainListener.readColumn("time") - initialTime
mainListener.close()
massListener = TableReader(os.path.join(simOutDir, "Mass"))
cellMass = massListener.readColumn("cellMass")
dryMass = massListener.readColumn("dryMass")
massListener.close()
coefficient = dryMass / cellMass * sim_data.constants.cellDensity.asNumber(MASS_UNITS / VOLUME_UNITS)
# read constraint data
enzymeKineticsReader = TableReader(os.path.join(simOutDir, "EnzymeKinetics"))
targetFluxes = (COUNTS_UNITS / MASS_UNITS / TIME_UNITS) * (enzymeKineticsReader.readColumn("targetFluxes").T / coefficient).T
actualFluxes = (COUNTS_UNITS / MASS_UNITS / TIME_UNITS) * (enzymeKineticsReader.readColumn("actualFluxes").T / coefficient).T
reactionConstraint = enzymeKineticsReader.readColumn("reactionConstraint")
constrainedReactions = np.array(enzymeKineticsReader.readAttribute("constrainedReactions"))
enzymeKineticsReader.close()
targetFluxes = targetFluxes.asNumber(units.mmol / units.g / units.h)
actualFluxes = actualFluxes.asNumber(units.mmol / units.g / units.h)
targetAve = np.mean(targetFluxes[BURN_IN_STEPS:, :], axis = 0)
actualAve = np.mean(actualFluxes[BURN_IN_STEPS:, :], axis = 0)
kcatOnlyReactions = np.all(constraintIsKcatOnly[reactionConstraint[BURN_IN_STEPS:,:]], axis = 0)
kmAndKcatReactions = ~np.any(constraintIsKcatOnly[reactionConstraint[BURN_IN_STEPS:,:]], axis = 0)
mixedReactions = ~(kcatOnlyReactions ^ kmAndKcatReactions)
thresholds = [2, 10]
categorization = np.zeros(reactionConstraint.shape[1])
categorization[actualAve == 0] = -2
categorization[actualAve == targetAve] = -1
for i, threshold in enumerate(thresholds):
# categorization[targetAve / actualAve > threshold] = i + 1
categorization[actualAve / targetAve > threshold] = i + 1
# url for ecocyc to highlight fluxes that are 0 on metabolic network diagram
siteStr = "https://ecocyc.org/overviewsWeb/celOv.shtml?zoomlevel=1&orgid=ECOLI"
excluded = ['RXN0-2201', 'RXN-16000', 'RXN-12583', 'RXN-11496', 'DIMESULFREDUCT-RXN', '3.6.1.41-R[4/63051]5-NUCLEOTID-RXN'] # reactions not recognized by ecocyc
rxns = []
for i, reaction in enumerate(constrainedReactions):
if actualAve[i] == 0:
rxn = re.findall(".+RXN", reaction)
if len(rxn) == 0:
rxn = re.findall("RXN[^-]*-[0-9]+", reaction)
if rxn[0] not in excluded:
siteStr += "&rnids=%s" % rxn[0]
rxns.append(rxn[0])
# print siteStr
csvFile = open(os.path.join(plotOutDir, plotOutFileName + ".tsv"), "wb")
output = csv.writer(csvFile, delimiter = "\t")
output.writerow(["ecocyc link:", siteStr])
output.writerow(["Km and kcat", "Target", "Actual", "Category"])
for reaction, target, flux, category in zip(constrainedReactions[kmAndKcatReactions], targetAve[kmAndKcatReactions], actualAve[kmAndKcatReactions], categorization[kmAndKcatReactions]):
output.writerow([reaction, target, flux, category])
output.writerow(["kcat only"])
for reaction, target, flux, category in zip(constrainedReactions[kcatOnlyReactions], targetAve[kcatOnlyReactions], actualAve[kcatOnlyReactions], categorization[kcatOnlyReactions]):
output.writerow([reaction, target, flux, category])
if np.sum(mixedReactions):
output.writerow(["mixed constraints"])
for reaction, target, flux, category in zip(constrainedReactions[mixedReactions], targetAve[mixedReactions], actualAve[mixedReactions], categorization[mixedReactions]):
output.writerow([reaction, target, flux, category])
csvFile.close()
targetAve += 1e-6
actualAve += 1e-6
axes_limits = [1e-7, 1e4]
plt.figure(figsize = (8, 8))
ax = plt.axes()
plt.loglog(axes_limits, axes_limits, 'k')
plt.loglog(targetAve, actualAve, "ob", markeredgewidth = 0.25, alpha = 0.25)
plt.xlabel("Target Flux (mmol/g/hr)")
plt.ylabel("Actual Flux (mmol/g/hr)")
plt.minorticks_off()
whitePadSparklineAxis(ax)
ax.set_ylim(axes_limits)
ax.set_xlim(axes_limits)
ax.set_yticks(axes_limits)
ax.set_xticks(axes_limits)
exportFigure(plt, plotOutDir, plotOutFileName)
plt.close("all")
source = ColumnDataSource(
data = dict(
x = targetAve,
y = actualAve,
reactionName = constrainedReactions)
)
hover = HoverTool(
tooltips = [
("Reaction", "@reactionName"),
]
)
TOOLS = [hover,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(),
"reset",
]
p1 = figure(x_axis_label = "Target",
x_axis_type = "log",
x_range = [min(targetAve[targetAve > 0]), max(targetAve)],
y_axis_label = "Actual",
y_axis_type = "log",
y_range = [min(actualAve[actualAve > 0]), max(actualAve)],
width = 800,
height = 800,
tools = TOOLS,
)
p1.scatter(targetAve, actualAve, source = source, size = 8)
p1.line([1e-15, 10], [1e-15, 10], line_color = "red", line_dash = "dashed")
## bar plot of error
# sortedReactions = [constrainedReactions[x] for x in np.argsort(aveError)[::-1]]
# aveError[np.log10(aveError) == -np.inf] = 0
# source = ColumnDataSource(
# data = dict(
# x = sorted(relError, reverse = True),
# reactionName = sortedReactions
# )
# )
# p2 = Bar(data, values = "x")
# hover2 = p2.select(dict(type=HoverTool))
# hover2.tooltips = [("Reaction", "@reactionName")]
## flux for each reaction
hover2 = HoverTool(
tooltips = [
("Reaction", "@reactionName"),
]
)
TOOLS2 = [hover2,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(),
"reset",
]
p2 = figure(x_axis_label = "Time(s)",
y_axis_label = "Flux",
y_axis_type = "log",
y_range = [1e-8, 1],
width = 800,
height = 800,
tools = TOOLS2,
)
colors = COLORS_LARGE
nTimesteps = len(time[BURN_IN_STEPS:])
x = time[BURN_IN_STEPS:]
y = actualFluxes[BURN_IN_STEPS:, 0]
reactionName = np.repeat(constrainedReactions[0], nTimesteps)
source = ColumnDataSource(
data = dict(
x = x,
y = y,
reactionName = reactionName)
)
p2.line(x, y, line_color = colors[0], source = source)
# Plot remaining metabolites onto initialized figure
for m in np.arange(1, actualFluxes.shape[1]):
y = actualFluxes[BURN_IN_STEPS:, m]
reactionName = np.repeat(constrainedReactions[m], nTimesteps)
source = ColumnDataSource(
data = dict(
x = x,
y = y,
reactionName = reactionName)
)
p2.line(x, y, line_color = colors[m % len(colors)], source = source)
if not os.path.exists(os.path.join(plotOutDir, "html_plots")):
os.makedirs(os.path.join(plotOutDir, "html_plots"))
p = bokeh.io.vplot(p1, p2)
bokeh.io.output_file(os.path.join(plotOutDir, "html_plots", plotOutFileName + ".html"), title=plotOutFileName, autosave=False)
bokeh.io.save(p)
bokeh.io.curstate().reset()
def modify_doc(doc):
initial_points = {"x": [0, 1, 2], "y": [1, 3, 4]}
source_points = ColumnDataSource(initial_points)
source_line_rough = ColumnDataSource(compute(source_points, 10))
source_line_smooth = ColumnDataSource(compute(source_points, 100))
plot = figure(toolbar_location="above", x_range=Range1d(-10, 10, bounds=(-10, 10)),
y_range=Range1d(-10, 10, bounds=(-10, 10)))
line_rough = plot.line('x', 'y', source=source_line_rough, line_dash="dotted")
line_smooth = plot.line('x', 'y', source=source_line_smooth, line_color="green")
circles = plot.circle('x', 'y', source=source_points,
size=10,
nonselection_fill_alpha=0.5,
nonselection_fill_color="blue",
nonselection_line_color="firebrick",
nonselection_line_alpha=1.0,
selection_fill_alpha=0.9,
selection_fill_color="red",
selection_line_color="firebrick"
)
plot2 = figure(toolbar_location="above")
line_smooth2 = plot2.line('y', 'x', source=source_line_smooth, line_width=5)
line_smooth2.glyph.line_color = "green"
line_rough2 = plot2.line('y', 'x', source=source_line_rough, line_dash="dotted")
circles2 = plot2.circle('y', 'x', source=source_points,
size=10,
nonselection_fill_alpha=0.5,
nonselection_fill_color="blue",
nonselection_line_color="firebrick",
nonselection_line_alpha=1.0,
selection_fill_alpha=0.9,
selection_fill_color="red",
selection_line_color="firebrick"
)
def recompute():
source_line_smooth.data = compute(source_points, 100)
line_smooth.glyph.line_dash = [1, 0]
line_smooth.glyph.line_color = "green"
line_smooth2.glyph.line_color = "green"
def update_data(attr, old, new):
source_line_rough.data = compute(source_points, 10)
line_smooth.glyph.line_dash = [6, 3]
line_smooth.glyph.line_color = "red"
line_smooth2.glyph.line_color = "red"
draw_tool = PointDrawTool(renderers=[circles])
undo_tool = UndoTool()
redo_tool = RedoTool()
plot.add_tools(draw_tool, undo_tool, redo_tool)
plot.toolbar.active_drag = draw_tool
draw_tool2 = PointDrawTool(renderers=[circles2])
plot2.add_tools(draw_tool2, undo_tool, redo_tool)
plot2.toolbar.active_drag = draw_tool2
source_points.on_change("data", update_data)
def undo(event):
print("TODO : implement callback on undo tools")
def redo(event):
print("TODO : implement callback on undo tools")
#undo_tool.on_event("click", undo)
#redo_tool.on_event("click", redo)
columns = [TableColumn(field="x", title="x"),
TableColumn(field="y", title="y")]
table_points = DataTable(source=source_points, columns=columns, editable=True)
button = Button(label="Recompute")
button.on_click(recompute)
doc.add_root(column(button, row(plot, plot2), table_points))