def show(sample_size):
global session
global scatter_plot
global source
global pie_chart_source
global line_chart_source
global slider
DB.__init__(sample_size)
min_time = DB.min_time()
max_time = DB.max_time()
print min_time
print min_time
xs, ys, color, time = DB.get_current()
xs = [xs[i] for i,v in enumerate(time) if time[i] == min_time]
ys = [ys[i] for i,v in enumerate(time) if time[i] == min_time]
color = [color[i] for i,v in enumerate(time) if time[i] == min_time]
time_dict = Counter(time)
pie_chart_source = ColumnDataSource(data=ChartMath.compute_color_distribution('x', 'y', 'color', color))
line_chart_source = ColumnDataSource(data=dict(x=[key for key in time_dict], y=[time_dict[key] for key in time_dict]))
source = ColumnDataSource(data=dict(x=xs, y=ys, color=color))
scatter_plot = Figure(plot_height=800,
plot_width=1200,
title="Plot of Voters",
tools="pan, reset, resize, save, wheel_zoom",
)
scatter_plot.circle('x', 'y', color='color', source=source, line_width=0, line_alpha=0.001, fill_alpha=0.5, size=15)
scatter_plot.patches('x', 'y', source=state_source, fill_alpha=0.1, line_width=3, line_alpha=1)
scatter_plot.x_range.on_change('end', update_coordinates)
line_chart = Figure(title="Distribution over Time", plot_width=350, plot_height=350)
line_chart.line(x='x', y='y', source=line_chart_source)
pie_chart_plot = Figure(plot_height=350,
plot_width=350,
title="Voter Distribution",
x_range=(-1, 1),
y_range=(-1, 1))
pie_chart_plot.wedge(x=0, y=0, source=pie_chart_source, radius=1, start_angle="x", end_angle="y", color="color")
slider = Slider(start=min_time, end=max_time, value=min_time, step=1, title="Time")
slider.on_change('value', update_coordinates)
h = hplot(scatter_plot, vplot(pie_chart_plot, line_chart))
vplot(slider, h, width=1600, height=1800)
session = push_session(curdoc())
session.show()
#script = autoload_server(scatter_plot, session_id=session.id)
session.loop_until_closed()
def use_server_to_change_glyphs(self):
source_original = ColumnDataSource(
dict(average_grades=[7, 8, 10],
exam_grades=[6, 9, 8],
student_names=["Stephan", "Helder", "Riazudidn"]))
source = ColumnDataSource(
dict(average_grades=[7, 8, 10],
exam_grades=[6, 9, 8],
student_names=["Stephan", "Helder", "Riazudidn"]))
# create the figure
f = figure(x_range=Range1d(start=0, end=12),
y_range=Range1d(start=0, end=12))
# add labels for glyphs
labels = LabelSet(x="average_grades",
y="exam_grades",
text="student_names",
x_offset=5,
y_offset=5,
source=source)
f.add_layout(labels)
# create glyphs
f.circle(x="average_grades", y="exam_grades", source=source, size=8)
# create filtering function
def filter_grades(attr, old, new):
source.data = {
key: [
value for i, value in enumerate(source_original.data[key])
if source_original.data["exam_grades"][i] >= slider.value
]
for key in source_original.data
}
print(slider.value)
# create label function
def update_labels(attr, old, new):
labels.text = select.value
# create select widget
options = [("average_grades", "Average Grades"),
("exam_grades", "Exam Grades"),
("student_names", "Student Names")]
select = Select(title="Attribute", options=options)
select.on_change("value", update_labels)
slider = Slider(start=min(source_original.data["exam_grades"]) - 1,
end=max(source_original.data["exam_grades"]) + 1,
value=8,
step=0.1,
title="Exam Grade: ")
slider.on_change("value", filter_grades)
# create layout and add to curdoc
lay_out = layout([[select], [slider]])
curdoc().add_root(f)
curdoc().add_root(lay_out)
class DynamicSimulRow:
"""Clase DynamicSimulRow para representar una fila dinámica con slider y textbox.
Attributes:
start: Valor inicial del slider
end: Valor final del slider
value: Valor por defecto del slider y el textbox
title: Título del slider
"""
def __init__(self, start, end, value, title):
self.start = start
self.end = end
self.value = value
self.title = title
self.slider = Slider(start=self.start,
end=self.end,
value=self.value,
step=0.1,
title=self.title,
min_width=580)
self.text_input = TextInput(value=f"{self.value:.2f}", max_width=100)
self.dyn_row = row([self.slider, self.text_input],
sizing_mode='stretch_height')
self.slider.on_change('value', self.slider_handler)
self.text_input.on_change('value', self.text_handler)
def slider_handler(self, attrname, old, new):
self.text_input.value = f"{new:.2f}"
def text_handler(self, attrname, old, new):
self.slider.value = float(new)
def make_page_flow(doc):
# return make_document(doc)
# if __name__=='__main__':
# df = pd.read_csv('salary_data.csv')
# else:
# # df = pd.read_csv('./bokeh_pages/salary_data.csv')
df = pd.read_csv(fileName_csv_source)
#
source = ColumnDataSource(data=dict())
def update():
print ("slider update")
# current = df[df['salary'] <= slider.value].dropna() # df ##
# adjustment by https://groups.google.com/a/continuum.io/forum/#!topic/bokeh/fPAoHTyMcuQ
current = df[df['salary'] <= slider.value].dropna() # df ##
# print (list(current.name))
# print (type(current.salary)) # <class 'pandas.core.series.Series'>
# print (type(current.years_experience))
source.data = {
'name' : list(current.name),
'salary' : list(current.salary),
'years_experience' : list(current.years_experience),
}
slider = Slider(title="values range", start=0, end=100000, value=20000, step=1)
slider.on_change('value', lambda attr, old, new: update())
def on_button_change():
print("visiting on button change")
button = Button(label="Phase #1 ", button_type="success") # button_type: ‘default’, ‘primary’, ‘success’, ‘warning’, ‘danger’, ‘link’
button.on_click(on_button_change)
# button.callback = CustomJS(args=dict(source=source),
# code=open(join(dirname(__file__), "download.js")).read())
columns = [
TableColumn(field="name", title="Employee Name"),
TableColumn(field="salary", title="Income", formatter=NumberFormatter(format="$0,0.00")),
TableColumn(field="years_experience", title="Experience (years)")
]
data_table = DataTable(source=source, columns=columns, width=800)
controls = widgetbox(slider, button)
table = widgetbox(data_table)
total_row = row(controls, table)
doc_add_root(doc, total_row, title = 'work flow page')
# if __name__!='__main__':
# print("doc : ", str(doc))
# print("name : ",__name__)
# doc().add_root(row(controls, table))
# doc().title = "work flow page, from caller"
# elif __name__=='__main__':
# print("doc : ", str(doc))
# doc.add_root(row(controls, table))
# doc.title = "work flow page, from main"
update()
def init_solar_wx(self):
sun_luminos_slider = Slider(
start=0.1,
end=10,
step=0.1,
value=self.rel_solar_lum,
title='Relative Solar Luminosity (Solar Units)')
earth_radius_slider = Slider(start=0.1,
end=10,
step=0.1,
value=self.dist_from_sun_au,
title='Distance from Sun (AU)')
def _lum_handler(attr, old, new):
self.rel_solar_lum = new
self.update_solar_in()
self.update_input_rays()
self._update_atm_refl()
def _radius_handler(attr, old, new):
self.dist_from_sun_au = new
self.update_solar_in()
self.update_input_rays()
self._update_atm_refl()
sun_luminos_slider.on_change('value', _lum_handler)
earth_radius_slider.on_change('value', _radius_handler)
solar_sliders = WidgetBox(sun_luminos_slider, earth_radius_slider)
return [solar_sliders]
def add_slider(self, min, max, step, init, title, callback=None):
slider = Slider(start=min, end=max, value=init, step=step, title=title)
slider.on_change('value', self.slider_handler_callback)
self.slider_callback = callback
self.layout = column(self.plot, widgetbox(slider))
def app(doc):
# Set up data
N = 200
x = np.linspace(0, 4*np.pi, N)
y = np.sin(x)
source = ColumnDataSource(data=dict(x=x, y=y))
# Set up plot
plot = figure(plot_height=400, plot_width=400, title="my sine wave",
tools="crosshair,pan,reset,save,wheel_zoom",
x_range=[0, 4*np.pi], y_range=[-2.5, 2.5])
plot.line('x', 'y', source=source, line_width=3, line_alpha=0.6)
freq = Slider(title="frequency", value=1.0, start=0.1, end=5.1, step=0.1)
def update_data(attrname, old, new):
k = freq.value
# Generate the new curve
x = np.linspace(0, 4*np.pi, N)
y = np.sin(k*x)
source.data = dict(x=x, y=y)
freq.on_change('value', update_data)
widget_box = widgetbox(freq)
doc.add_root(row(widget_box, plot, width=800))
doc.title = "Sliders"
def createSnakeControls(self):
#snake mode controls
snakeModeControls = RadioButtonGroup(labels=["Square", "LED"],
active=0,
width=400,
button_type="primary")
# snakeModeControls.on_change("active",self.visibilityCallback)
self.snakeSpeed = 500
snakeSpeedSlider = Slider(title="Speed",
show_value=False,
value=self.snakeSpeed,
start=30,
end=1000,
step=5)
snakeSpeedSlider.on_change("value", self.snakeSpeedCallback)
snakeNumberControls = RadioButtonGroup(labels=["1", "2"],
active=0,
width=400,
button_type="primary",
name="Num Snakes")
snakeColorWindow = self.createColorOutputWindow(2)
sendSnakeButton = Button(label="Send")
sendSnakeButton.on_click(self.postSnake)
return [
snakeModeControls, snakeNumberControls, snakeSpeedSlider,
snakeColorWindow, sendSnakeButton
]
class DerivViewer(object):
def __init__(self):
self.xs = np.linspace(-2.0, 2.0, 100)
self.ys = test_func(self.xs)
self.source1 = ColumnDataSource(data=dict(xs=self.xs,
ys=self.ys))
a = 0
txs, tys = get_tangentdata(a)
self.source2 = ColumnDataSource(data=dict(txs=txs,
tys=tys))
self.source3 = ColumnDataSource(data=dict(x=[a], y=[test_func(a)]))
self.fig = figure(title='view tangent line',
x_range=(-2.0, 2.0),
y_range=(-0.2, 1.2))
self.fig.line('xs', 'ys', source=self.source1)
self.fig.line('txs', 'tys', source=self.source2, color='orange')
self.fig.circle('x', 'y', source=self.source3, color='red')
self.slider = Slider(title='position',
value=0,
start=-1.5,
end=1.5,
step=0.1)
self.slider.on_change('value', self.update_data)
self.plot = column(self.slider, self.fig)
def update_data(self, attr, old, new):
a = self.slider.value
txs, tys = get_tangentdata(a)
self.source2.data = dict(txs=txs, tys=tys)
self.source3.data = dict(x=[a], y=[test_func(a)])
class slider():
def __init__(self, widget_lst, label, start, end, step, callback_throttle,
default):
self.label = label
self.start = start
self.end = end
self.step = step
self.callback_throttle = callback_throttle
self.default = default
self.slider = None
self.callback = None
# self.initialize(label, start, end, step, callback_throttle, default)
widget_lst.append(self)
def initialize(self, widget_lst):
self.slider = Slider(start=self.start,
end=self.end,
value=self.default,
step=self.step,
title=self.label)
widget_lst.append(self.slider)
if self.callback is not None:
self.slider.on_change('value', self.callback)
def add_callback(self, callback):
self.callback = callback
if self.slider is not None:
self.slider.on_change('value',
self.callback) #May not keep that one
def set_value(self, value):
if self.slider is not None:
self.slider.value = value
self.default = value
class DerivViewer(object):
def __init__(self):
self.xs = np.linspace(-2.0, 2.0, 100)
self.ys = test_func(self.xs)
self.source1 = ColumnDataSource(data=dict(xs=self.xs, ys=self.ys))
a = 0
txs, tys = get_tangentdata(a)
self.source2 = ColumnDataSource(data=dict(txs=txs, tys=tys))
self.source3 = ColumnDataSource(data=dict(x=[a], y=[test_func(a)]))
self.fig = figure(title='view tangent line',
x_range=(-2.0, 2.0),
y_range=(-0.2, 1.2))
self.fig.line('xs', 'ys', source=self.source1)
self.fig.line('txs', 'tys', source=self.source2, color='orange')
self.fig.circle('x', 'y', source=self.source3, color='red')
self.slider = Slider(title='position',
value=0,
start=-1.5,
end=1.5,
step=0.1)
self.slider.on_change('value', self.update_data)
self.plot = column(self.slider, self.fig)
def update_data(self, attr, old, new):
a = self.slider.value
txs, tys = get_tangentdata(a)
self.source2.data = dict(txs=txs, tys=tys)
self.source3.data = dict(x=[a], y=[test_func(a)])
def interactive_field_history(doc, fld=None, islice=0, dgrid=0):
"""
Use with code similar to:
my_fld = parsers.parse_genesis_fld(fld_fname, g.input_params['ncar'], nslice)
from bokeh.plotting import show, output_notebook
output_notebook()
def app(doc):
return interactive_field_history(doc, fld=my_fld, dgrid=dgrid, slice = 0)
show(app)
"""
nhist = fld.shape[3]
ihist = nhist - 1
fdat = fld[:, :, islice, ihist]
d = np.angle(fdat)
ds = ColumnDataSource(data=dict(image=[d]))
xyrange = (-1000 * dgrid, 1000 * dgrid)
p = figure(x_range=xyrange,
y_range=xyrange,
title='Phase',
plot_width=500,
plot_height=500,
x_axis_label='x (mm)',
y_axis_label='y (mm)')
p.image(image='image',
source=ds,
x=-dgrid * 1000,
y=-dgrid * 1000,
dw=2 * dgrid * 1000,
dh=2 * dgrid * 1000,
palette=pal)
slider = Slider(start=0,
end=nhist - 1,
value=ihist,
step=1,
title='History')
def handler(attr, old, new):
fdat = fld[:, :, islice, new]
d = np.angle(fdat)
ds.data = dict(ColumnDataSource(data=dict(image=[d])).data)
slider.on_change('value', handler)
doc.add_root(column(slider, p))
class Create():
def __init__(self):
dateNow = datetime.now()
self.startDay = DatePicker(title="Start Date",
min_date=datetime(2000, 1, 1),
max_date=datetime(2030, 12, 31),
value=datetime(dateNow.year, dateNow.month,
dateNow.day))
# snapshot time hours minutes
self.Hour = Slider(title="Time of day [h]",
value=1.0,
start=1.0,
end=24.0,
step=0.25)
self.timeStep = Slider(title="Time step [min]",
value=15.0,
start=1.0,
end=60.0,
step=1.0)
self.timeStep.on_change('value', self.updateHourSlider)
r1 = row(self.startDay, self.Hour, self.timeStep)
self.Vul = Slider(title="Voltage upper limit [p.u]",
value=1.05,
start=0.9,
end=1.1,
step=0.005)
self.Vll = Slider(title="Voltage lower limit [p.u]",
value=0.95,
start=0.9,
end=1.1,
step=0.005)
self.Lul = Slider(title="Loading upper limit [%]",
value=90,
start=0,
end=120,
step=1)
r2 = row(self.Vll, self.Vul, self.Lul)
self.final_layout = column(r1, r2)
return
def GetLineSliders(self):
return self.Vll, self.Vul, self.Lul
def layout(self):
return self.final_layout
def updateHourSlider(self, attr, old, new):
self.Hour.step = self.timeStep.value / 60
return
def UpdatePlot(self):
return
def gamma_shape(doc):
alpha = 3
x = np.linspace(0, gamma.ppf(0.999, alpha), 100)
y = gamma.pdf(x, alpha)
source = ColumnDataSource(data={'x_1': x, 'y_1': y})
# tooltips_formatting =[('random variable', '@x_1'), ('PD', '@y_1')]
# or
tooltips_formatting = """
<div>
<div>
<span style="font-size: 14px; color: #3c6978">random variable: </span>
<span style="font-size: 14px; float: right; margin: 0px 0px 0px 15px">@x_1</span>
</div>
<div>
<span style="font-size: 14px; color: #3c6978">max:</span>
<span style="font-size: 14px; float: right; margin: 0px 0px 0px 15px">@y_1</span>
</div>
</div>
"""
p = figure(plot_width=700,
plot_height=600,
title="Gamma distribution",
tooltips=tooltips_formatting)
p.line(x='x_1', y='y_1', line_width=2, source=source)
p.x_range.start = 0
p.xaxis.axis_label = 'Random variable'
p.yaxis.axis_label = 'Probability density'
def callback_shape(attr, old, new):
x_updated = np.linspace(0, gamma.ppf(0.999, new), 100)
y_updated = gamma.pdf(source.data['x_1'], new)
new_source = ColumnDataSource(data={
'x_1': x_updated,
'y_1': y_updated
})
source.data.update(new_source.data)
slider_shape = Slider(start=1,
end=30,
value=3,
step=.1,
title="Gamma shape")
slider_shape.on_change('value', callback_shape)
doc.add_root(column(slider_shape, p))
doc.theme = Theme(json=yaml.load("""
attrs:
Figure:
height: 600
width: 800
"""))
def index():
slider_freq = Slider(orientation="horizontal", start=1, end=5, value=1, step=1, name="freq1", title = "Frequency")
slider_freq.on_change('value', eventHandler, 'input_change')
layout = HBox(
children = [slider_freq]
)
script, div = components(layout)
return render_template('index.html', script = script, div = div)
def make_slider(self, callback_func, title, init_val, start_val, end_val,
step):
#スライダーを作る関数
slider = Slider(title=title,
value=init_val,
start=start_val,
end=end_val,
step=step)
slider.on_change('value', callback_func)
return slider
def render_vizard(doc):
args = doc.session_context.request.arguments
req_path = args["req_path"][0].decode('utf-8')
data = logparser.read_output_log(req_path)
hover = create_hover_tool()
score_plot, score_source = create_score_chart(data, title="Scores", x_name="Step", y_name="Average Score",
text_font_size="20pt")
molecule_plot = create_2d_molecule(data, position=-1)
slider = Slider(start=-1, end=len(data) - 1, value=-1, step=1, title="Step")
template = """<span data-toggle="tooltip" title="<%= value %>"><%= svg %></span>"""
columns = [
TableColumn(field="Step", title="Step"),
TableColumn(field="Score", title="Score"),
TableColumn(field="SMILES", title="SMILES", formatter=HTMLTemplateFormatter(template=template)),
]
smiles, score = extract_compounds(data, -1)
molsvg = [create_hover_svg(smi) for smi in smiles]
tabledf = dict(Step=[get_position(data, -1)] * len(smiles), SMILES=smiles, Score=score, svg=molsvg)
table_source = ColumnDataSource(data=tabledf)
data_table = DataTable(source=table_source, columns=columns, width=900, height=400)
def slider_callback(attr, old, new):
new = int(new)
data = score_source.data["raw_data"]
new_molecule_plot = create_2d_molecule(data, position=new)
molecule_plot.text = new_molecule_plot.text
smiles, score = extract_compounds(data, new)
molsvg = [create_hover_svg(smi) for smi in smiles]
tabledf = dict(Step=[get_position(data, new)] * len(smiles), SMILES=smiles, Score=score, svg=molsvg)
table_source.data = tabledf
def redraw_new_sliderend(attr, old, new):
if slider.value == -1:
slider_callback(attr, -1, -1)
slider.on_change('value', slider_callback)
slider.on_change('end', redraw_new_sliderend)
bokehlayout = layout([row(column(molecule_plot, slider), score_plot), ], sizing_mode="fixed")
doc.add_root(bokehlayout)
def check_new_data():
newdata = logparser.read_output_log(req_path)
if len(newdata) > len(score_source.data["raw_data"]):
x, y = extract_average_scores(newdata)
y_mean = running_average(y, 50)
score_source.data.update(x=x.tolist(), y=y.tolist(), y_mean=y_mean.tolist(), raw_data=newdata)
slider.end = len(x) - 1
doc.add_periodic_callback(check_new_data, 1000)
doc.theme = Theme(filename=os.path.dirname(os.path.realpath(__file__)) + "/templates/theme.yaml")
def create_layout(self):
# create figure
self.x_range = Range1d(start=self.model.map_extent[0],
end=self.model.map_extent[2], bounds=None)
self.y_range = Range1d(start=self.model.map_extent[1],
end=self.model.map_extent[3], bounds=None)
self.fig = Figure(tools='wheel_zoom,pan', x_range=self.x_range,
y_range=self.y_range)
self.fig.plot_height = 660
self.fig.plot_width = 990
self.fig.axis.visible = False
# add tiled basemap
self.tile_source = WMTSTileSource(url=self.model.basemap)
self.tile_renderer = TileRenderer(tile_source=self.tile_source)
self.fig.renderers.append(self.tile_renderer)
# add datashader layer
self.image_source = ImageSource(url=self.model.service_url,
extra_url_vars=self.model.shader_url_vars)
self.image_renderer = DynamicImageRenderer(image_source=self.image_source)
self.fig.renderers.append(self.image_renderer)
# add ui components
axes_select = Select.create(name='Axes',
options=self.model.axes)
axes_select.on_change('value', self.on_axes_change)
field_select = Select.create(name='Field', options=self.model.fields)
field_select.on_change('value', self.on_field_change)
aggregate_select = Select.create(name='Aggregate',
options=self.model.aggregate_functions)
aggregate_select.on_change('value', self.on_aggregate_change)
transfer_select = Select.create(name='Transfer Function',
options=self.model.transfer_functions)
transfer_select.on_change('value', self.on_transfer_function_change)
basemap_select = Select.create(name='Basemap', value='Toner',
options=self.model.basemaps)
basemap_select.on_change('value', self.on_basemap_change)
opacity_slider = Slider(title="Opacity", value=100, start=0,
end=100, step=1)
opacity_slider.on_change('value', self.on_opacity_slider_change)
controls = [axes_select, field_select, aggregate_select,
transfer_select, basemap_select, opacity_slider]
self.controls = HBox(width=self.fig.plot_width, children=controls)
self.layout = VBox(width=self.fig.plot_width,
height=self.fig.plot_height,
children=[self.controls, self.fig])
def make_page_flow(doc):
# return make_document(doc)
# if __name__=='__main__':
# df = pd.read_csv('salary_data.csv')
# else:
# # df = pd.read_csv('./bokeh_pages/salary_data.csv')
df = pd.read_csv(fileName)
#
source = ColumnDataSource(data=dict())
def update():
print ("slider update")
current = df[df['salary'] <= slider.value].dropna() # df ##
source.data = {
'name' : current.name,
'salary' : current.salary,
'years_experience' : current.years_experience,
}
slider = Slider(title="values range", start=0, end=100000, value=50000, step=1)
slider.on_change('value', lambda attr, old, new: update())
def on_button_change():
print("visiting on button change")
button = Button(label="phase #1 ", button_type="success") # button_type: ‘default’, ‘primary’, ‘success’, ‘warning’, ‘danger’, ‘link’
button.on_click(on_button_change)
# button.callback = CustomJS(args=dict(source=source),
# code=open(join(dirname(__file__), "download.js")).read())
columns = [
TableColumn(field="name", title="Employee Name"),
TableColumn(field="salary", title="Income", formatter=NumberFormatter(format="$0,0.00")),
TableColumn(field="years_experience", title="Experience (years)")
]
data_table = DataTable(source=source, columns=columns, width=800)
controls = widgetbox(slider, button)
table = widgetbox(data_table)
if __name__!='__main__':
print("doc : ", doc)
print("name : ",__name__)
doc().add_root(row(controls, table))
doc().title = "work flow page, from caller"
elif __name__=='__main__':
doc.add_root(row(controls, table))
doc.title = "work flow page, from main"
# if __name__=='__main__':
update()
def modify_doc(doc):
p = Paragraph(text=""" """, width=800, height=100)
def callback(attr, old, new):
print(
"called"
) # This outputs to console (In Jupyter goes back to UI via Jupyter websocket)
p.text = "{}:{}->{}".format(
attr, old, new) # This outputs to widget UI via bokeh websocket
slider_bokeh = Slider(start=0, end=100, value=1, step=.1, title="Stuff")
# widget on_change event can only with bokeh server
slider_bokeh.on_change("value", callback)
doc.add_root(widgetbox(p, slider_bokeh))
def init_controls(self):
btnStop = Button(label="Stop", type="danger")
btnStart = Button(label="Start", type="success")
btnStop.on_click(self.handle_btnStop_press)
btnStart.on_click(self.handle_btnStart_press)
curdoc().add_root(btnStop)
curdoc().add_root(btnStart)
sliderHPThreshold = Slider(start=0, end=500, value=100, step=1, title="High pass threshold")
sliderHPThreshold.on_change('value', self.onChangeHPThreshold)
curdoc().add_root(vplot(sliderHPThreshold))
class RotationViewer(object):
def __init__(self):
xs = np.linspace(-np.pi, np.pi, 11)
ys = xs
Xs, Ys = np.meshgrid(xs, ys)
self.Xs, self.Ys = Xs.flatten(), Ys.flatten()
initdegree = 0
mat = rot_mat(initdegree)
transXs, transYs = mat @ np.array([self.Xs, self.Ys])
TOOLS = "pan,lasso_select,save,reset"
self.source = ColumnDataSource(data=dict(
Xs=self.Xs, Ys=self.Ys, transXs=transXs, transYs=transYs))
self.fig = figure(tools=TOOLS,
title="target",
x_range=(-np.pi * np.sqrt(2) - 1,
np.pi * np.sqrt(2) + 1),
y_range=(-np.pi * np.sqrt(2) - 1,
np.pi * np.sqrt(2) + 1))
self.fig.circle('Xs', 'Ys', source=self.source)
self.transfig = figure(tools=TOOLS,
title="transformed",
x_range=self.fig.x_range,
y_range=self.fig.y_range)
self.transfig.circle('transXs', 'transYs', source=self.source, size=6)
self.rot_param = Slider(title="degree",
value=0,
start=0,
end=360,
step=1)
self.rot_param.on_change('value', self.update_data)
self.plot = column(self.rot_param, gridplot([[self.fig,
self.transfig]]))
def update_data(self, attr, old, new):
mat = rot_mat(self.rot_param.value)
transXs, transYs = mat @ np.array([self.Xs, self.Ys])
self.source.data = dict(Xs=self.Xs,
Ys=self.Ys,
transXs=transXs,
transYs=transYs)
self.transfig.title.text = "degree {}".format(self.rot_param.value)
def make_table():
if __name__ == '__main__':
df = pd.read_csv('salary_data.csv')
else:
# df = pd.read_csv('./bokeh_pages/salary_data.csv')
df = pd.read_csv('salary_data.csv')
source = ColumnDataSource(data=dict())
def update():
current = df[df['salary'] <= slider.value].dropna()
source.data = {
'name': current.name,
'salary': current.salary,
'years_experience': current.years_experience,
}
slider = Slider(title="Max Salary",
start=10000,
end=250000,
value=150000,
step=1000)
slider.on_change('value', lambda attr, old, new: update())
button = Button(label="Download", button_type="success")
button.callback = CustomJS(args=dict(source=source),
code=open(join(dirname(__file__),
"download.js")).read())
columns = [
TableColumn(field="name", title="Employee Name"),
TableColumn(field="salary",
title="Income",
formatter=NumberFormatter(format="$0,0.00")),
TableColumn(field="years_experience", title="Experience (years)")
]
data_table = DataTable(source=source, columns=columns, width=800)
controls = widgetbox(slider, button)
table = widgetbox(data_table)
curdoc().add_root(row(controls, table))
curdoc().title = "Export CSV"
update()
def init_controls(self):
btnStop = Button(label="Stop", type="danger")
btnStart = Button(label="Start", type="success")
btnStop.on_click(self.handle_btnStop_press)
btnStart.on_click(self.handle_btnStart_press)
curdoc().add_root(btnStop)
curdoc().add_root(btnStart)
sliderHPThreshold = Slider(start=0,
end=500,
value=100,
step=1,
title="High pass threshold")
sliderHPThreshold.on_change('value', self.onChangeHPThreshold)
curdoc().add_root(vplot(sliderHPThreshold))
def main():
state_xs, state_ys = get_us_state_outline()
left, right = minmax(state_xs)
bottom, top = minmax(state_ys)
plot = Figure(title=TITLE, plot_width=1000,
plot_height=700,
tools="pan, wheel_zoom, box_zoom, reset",
x_range=Range1d(left, right),
y_range=Range1d(bottom, top),
x_axis_label='Longitude',
y_axis_label='Latitude')
plot_state_outline(plot, state_xs, state_ys)
density_overlay = DensityOverlay(plot, left, right, bottom, top)
density_overlay.draw()
grid_slider = Slider(title="Details", value=density_overlay.gridcount,
start=10, end=100, step=10)
grid_slider.on_change("value", density_overlay.grid_change_listener)
radiance_slider = Slider(title="Min. Radiance",
value=density_overlay.radiance,
start=np.min(density_overlay.rad),
end=np.max(density_overlay.rad), step=10)
radiance_slider.on_change("value", density_overlay.radiance_change_listener)
listener = ViewListener(plot, density_overlay, name="viewport")
plot.x_range.on_change("start", listener)
plot.x_range.on_change("end", listener)
plot.y_range.on_change("start", listener)
plot.y_range.on_change("end", listener)
backends = ["CPU", "HSA"]
default_value = backends[kde.USE_HSA]
backend_select = Select(name="backend", value=default_value,
options=backends)
backend_select.on_change('value', density_overlay.backend_change_listener)
doc = curdoc()
doc.add(VBox(children=[plot, grid_slider, radiance_slider, backend_select]))
doc.add_periodic_callback(density_overlay.periodic_callback, 0.5)
def setupControls(self):
repeatResolutionSlider = Slider(
start=1, end=10, value=1, step=1, title="Repeat resolution"
) #,width = self.figureWidth,height = self.buttonHeight)
repeatResolutionSlider.on_change("value",
self.repeatResolutionCallback)
chunkModeButtons = RadioButtonGroup(
labels=["Time", "Sample"], active=0, button_type="warning"
) #,width=self.buttonWidth,height = self.buttonHeight)
chunkModeButtons.on_change("active", self.chunkModeCallback)
yAxisModeButtons = RadioButtonGroup(labels=["Linear", "Log"],
active=0,
button_type="warning")
yAxisModeButtons.on_change("active", self.yAxisModeCallback)
self.controls = row(repeatResolutionSlider, chunkModeButtons,
yAxisModeButtons)
def init_slider_widget(cls,
update_value_callback,
on_change_callback,
title="Default",
start=1,
end=10,
step=1,
value=None):
if not value:
value = cls.get_value_or_none(update_value_callback)
slider = Slider(start=start,
end=end,
value=value,
step=step,
title=title)
slider.on_change('value', on_change_callback)
return SliderWidget(slider, update_value_callback)
def createFadeOutControls(self):
self.fadeSpeed = 500
fadeSpeedSlider = Slider(title="Speed",
show_value=False,
value=self.fadeSpeed,
start=30,
end=1000,
step=5)
fadeSpeedSlider.on_change("value", self.fadeSpeedCallback)
self.fadeStride = .1
fadeStrideSlider = Slider(title="Stride",
show_value=False,
value=self.fadeStride,
start=.01,
end=.2,
step=.01)
fadeStrideSlider.on_change("value", self.fadeStrideCallback)
return [fadeSpeedSlider, fadeStrideSlider]
class slider():
def __init__(self, widget_lst, label, start, end, step, callback_throttle,
default):
self.widget_lst = widget_lst
self.slider = None
self.initialize(label, start, end, step, callback_throttle, default)
def initialize(self, label, start, end, step, callback_throttle, default):
self.slider = Slider(start=start,
end=end,
value=default,
step=step,
title=label,
callback_throttle=callback_throttle)
self.widget_lst.append(self.slider)
def add_callback(self, callback):
self.slider.on_change('value', callback)
def set_value(self, value):
self.slider.value = value
def update(attr, old, new):
doc.clear()
network = make_dataset(0)
if new > 0:
new_network = make_dataset(new)
network.update(new_network)
timeselect_slider = Slider(start=0,
end=1000,
value=new,
value_throttled=new,
step=1,
title="Time",
callback_policy='mouseup')
timeselect_slider.on_change('value_throttled', update)
p = make_plot(network)
controls = WidgetBox(timeselect_slider)
layout = row(controls, p)
doc.add_root(layout)
class RotationViewer(object):
def __init__(self):
xs = np.linspace(-np.pi, np.pi, 11)
ys = xs
Xs, Ys = np.meshgrid(xs, ys)
self.Xs, self.Ys = Xs.flatten(), Ys.flatten()
initdegree = 0
mat = rot_mat(initdegree)
transXs, transYs = mat @ np.array([self.Xs, self.Ys])
TOOLS = "pan,lasso_select,save,reset"
self.source = ColumnDataSource(data=dict(Xs=self.Xs, Ys=self.Ys,
transXs=transXs,
transYs=transYs))
self.fig = figure(tools=TOOLS, title="target",
x_range=(-np.pi*np.sqrt(2)-1, np.pi*np.sqrt(2)+1),
y_range=(-np.pi*np.sqrt(2)-1, np.pi*np.sqrt(2)+1))
self.fig.circle('Xs', 'Ys', source=self.source)
self.transfig = figure(tools=TOOLS, title="transformed",
x_range=self.fig.x_range, y_range=self.fig.y_range)
self.transfig.circle('transXs', 'transYs', source=self.source, size=6)
self.rot_param = Slider(title="degree", value=0,
start=0, end=360, step=1)
self.rot_param.on_change('value', self.update_data)
self.plot = column(self.rot_param, gridplot([[self.fig, self.transfig]]))
def update_data(self, attr, old, new):
mat = rot_mat(self.rot_param.value)
transXs, transYs = mat @ np.array([self.Xs, self.Ys])
self.source.data = dict(Xs=self.Xs, Ys=self.Ys,
transXs=transXs, transYs=transYs)
self.transfig.title.text = "degree {}".format(self.rot_param.value)
def make_layout():
"""Inclui o gráficos e os controles no curdoc do Bokeh Server."""
plot = Plot(DISTS)
numbins_slider = Slider(title="Number of bins",
value=10,
start=5,
end=15,
step=1)
div = Div(text="<b>Goodness of fit tests (p-values)</b>")
table = fit_table([dist.name for dist in DISTS])
def numbins_slider_callback(attr, old, new): # pylint: disable=unused-argument
"""Função que atualiza o histograma e a CDF dos observações."""
hist, edges = np.histogram(plot.values, density=True, bins=new)
plot.update_histogram(hist, edges)
data = plot.cumulative_source.data
chi = [chi_squared(plot.values, dist.cdf, new) for dist in DISTS]
ks = [kolmogorov_smirnov(plot.values, dist.cdf) for dist in DISTS]
wms = [weverton(dist.cdf, data["x"], data["y"]) for dist in DISTS]
table.source.data.update(ks=ks, chi=chi, wms=wms) # pylint: disable=no-member
def upload_callback(attr, old, new):
"""Função que atualiza os dados do plot com os dados do arquivo enviado."""
file_contents = base64.b64decode(new)
file_contents_bytes = io.BytesIO(file_contents)
observed = np.loadtxt(file_contents_bytes)
plot.update_data(observed)
numbins_slider.value = plot.num_bins
numbins_slider.end = len(observed) // 3
numbins_slider_callback(attr, old, numbins_slider.value)
button = FileInput()
button.on_change("value", upload_callback)
numbins_slider.on_change("value", numbins_slider_callback)
controls = column(button, numbins_slider, div, table, width=300)
return row(controls, plot.layout, sizing_mode="scale_height")
def root():
# Konstante für maximale X-Ausdehnung
N = 100
X_MAX = 4 * np.pi
k = 1
# Definiere Initiale Daten
x = np.linspace(0, X_MAX, N)
y = np.sin(k * x)
# Definiere eine Datenquelle
source = ColumnDataSource(data=dict(x=x, y=y))
# Ein Plot-Objekt wird definiert
plot = figure()
# welches einen Linien-Plot beinhaltet
plot.line('x', 'y', source=source)
# Ein Schieberegler wird definiert
freq = Slider(title="freq", value=1.0, start=1, end=105, step=0.1)
# Diese Funktion soll gerufen werden, wenn der Schieberegler sich ändert ..
def update_data(attrname, old, new):
k = freq.value
x = np.linspace(0, X_MAX, N)
y = np.sin(k * x)
source.data = dict(x=x, y=y)
# .. was hier verdrahtet wird
freq.on_change('value', update_data)
# Hier wird eine Box im Browser erzeut, welche den Schieberegler enthält
inputs = widgetbox(freq)
# Diese Box wird zurück übergeben
return row(inputs, plot, width=800)
def init_slider_wx(self):
t_eff_slider = Slider(start=1000, end=40000, step=100, value=6000,
title='Star Effective Temperature (K)')
luminosity_slider = Slider(start=-5, end=5, step=0.1, value=0,
title='Relative Luminosity (10^x, solar units)')
planet_radius_slider = Slider(start=0.1, end=4, step=0.1, value=1,
title='Relative Planet Radius (earth radii)')
planet_distance_slider = Slider(start=-1, end=3, step=0.1, value=0,
title='Relative Planet Distance (10^x, AU)')
t_eff_slider.on_change('value', self._t_eff_handler)
luminosity_slider.on_change('value', self._luminosity_handler)
planet_radius_slider.on_change('value', self._planet_radius_handler)
planet_distance_slider.on_change('value', self._planet_dist_handler)
star_wx = WidgetBox(t_eff_slider, luminosity_slider)
planet_wx = WidgetBox(planet_radius_slider, planet_distance_slider)
return [star_wx, planet_wx]
# text input for input of the parametrized curve [cx(t),cy(t)]
cx_input = TextInput(value=curveintegral_settings.sample_curves[curveintegral_settings.init_curve_key][0],
title="cx(t):")
cy_input = TextInput(value=curveintegral_settings.sample_curves[curveintegral_settings.init_curve_key][1],
title="cy(t):")
# slider controlling the parameter t
parameter_input = Slider(title="t",
value=curveintegral_settings.parameter_input_init,
start=curveintegral_settings.parameter_min,
end=curveintegral_settings.parameter_max,
step=curveintegral_settings.parameter_step)
cx_input.on_change('value', curve_change)
cy_input.on_change('value', curve_change)
parameter_input.on_change('value', parameter_change)
# initialize plot
toolset = "crosshair,pan,reset,resize,save,wheel_zoom"
# Generate a figure container for the field
plot_field = Figure(plot_height=400,
plot_width=400,
tools=toolset,
title="Vector valued function",
x_range=[curveintegral_settings.x_min, curveintegral_settings.x_max],
y_range=[curveintegral_settings.y_min, curveintegral_settings.y_max]
)
# remove grid from plot
plot_field.grid[0].grid_line_alpha = 0.0
plot_field.grid[1].grid_line_alpha = 0.0
x_last = 0
t_last = 0
l_forward.data_source.data["y"] = vpulse(x - u*current_time)
l_reverse.data_source.data["y"] = vpulse(x + u*current_time)
t2.data_source.data["text"] = ['t = {:.3f} s'.format(current_time)]
button_reset = Button(label="Reset", type="success")
button_reset.on_click(reset_handler)
# Set up slider & callback function
def update_velocity(attrname, old, new):
global u, current_time, x_last, t_last
x_last += u * (current_time - t_last)
t_last = current_time
u = velocity.value
t1.data_source.data["text"] = ['u = {} m/s'.format(u)]
velocity = Slider(title="Velocity (m/s)", value=5.0, start=0.1, end=10.0, step=0.1)
velocity.on_change('value', update_velocity)
# Set up layout
layout = hplot(p, VBox(toggle, button_reset, velocity, height=400), width=900)
# Create callback function for periodic callback
def update():
global ii, current_time
if toggle.active:
ii += 1
current_time = ii * 1.e-3 * periodic_callback_time_ms
l_forward.data_source.data["y"] = vpulse( x - x_last - u*(current_time-t_last) )
l_reverse.data_source.data["y"] = vpulse( x + x_last + u*(current_time-t_last) )
t2.data_source.data["text"] = ['t = {:.3f} s'.format(current_time)]
text_reg_season.value = str(selected_presets[i]['reg_season'])
slider_freq_days.value = selected_presets[i]['freq_days']
text_periods.value = str(selected_presets[i]['periods'])
select_preset.on_change('value', select_preset_callback)
# Slider: Last month in time window
number_of_months = df_piv.shape[1]
slider_et = Slider(
start=2,
end=number_of_months,
value=number_of_months,
step=1, # current month
title="Last month in time window")
slider_et.on_change('value', slider_et_callback)
# Slider: Previous months to accumulate
slider_ws = Slider(
start=1,
end=slider_et.value,
value=36,
step=1, # acc months
title="Previous months to accumulate")
slider_ws.on_change('value', slider_ws_callback)
# Text: Start month / End month
text_period = Div(text=get_period_text())
# Prophet parameter controls
text_prophet_parameters = Div(text='<h3>Prophet parameters</h3>')
class widgetDIMS(object):
column_names_rocks = ['kclay', 'muclay', 'rhoclay',
'knonclay', 'munonclay', 'rhononclay',
'vclay', 'phi', 'dryEk', 'dryPk', 'dryEg', 'dryPg']
column_names_fluids = ['Name', 'ko', 'rhoo', 'kw', 'rhow', 'kg', 'rhog', 'so', 'sw', 'sg' ]
column_names_pres = ['Name', 'OB_Grad', 'init_Pres', 'curr_Pres']
column_names_output = ['rock', 'fluid', 'Vp', 'Vs', 'rho', 'other']
def __init__(self,init_depth,file_rocks,file_fluids,file_prespfs,fdi=None):
'''
:param init_depth: Initial depth to model (TVDSS).
:param file_rocks: File with input mineral parameters.
:param file_fluids: File with input fluid parameters.
:param file_prespfs: File with input pressure profiles.
:keyword dependents: A list of geoPy widgets which need to be updated when widgetDIMS is changed.
'''
# Initial Data
self.df_rocks = pd.read_csv(file_rocks, skipinitialspace=True)
self.df_fluids = pd.read_csv(file_fluids, skipinitialspace=True)
self.df_pres = pd.read_csv(file_prespfs, skipinitialspace=True)
self.init_depth = init_depth # mTVDSS
self.pagewidth = 1000 # pixels
self.fdi = fdi
# Setup Sources
self.CDS_rocks = ColumnDataSource(self.df_rocks)
self.CDS_fluids = ColumnDataSource(self.df_fluids)
self.CDS_pres = ColumnDataSource(self.df_pres)
self.CDS_out = ColumnDataSource(data=dict())
# Extract Names
self.odict_rocks = self.__odictIndex(self.df_rocks.Name.tolist())
self.odict_fluids = self.__odictIndex(self.df_fluids.Name.tolist())
self.odict_pres = self.__odictIndex(self.df_pres.Name.tolist())
# Setup widgets
self.createTableWidgets()
self.createControls()
self.createLayout()
self.on_selection_change('value',1,1)
def __odictIndex(self,keys):
out = ExtOrderedDict()
for ind,key in enumerate(keys):
out[key] = ind
return out
def createTableWidgets(self):
self.col_rocks = [TableColumn(field=Ci, title=Ci) for Ci in self.column_names_rocks]
self.col_fluids = [TableColumn(field=Ci, title=Ci) for Ci in self.column_names_fluids]
self.col_pres = [TableColumn(field=Ci, title=Ci) for Ci in self.column_names_pres]
self.col_out = [TableColumn(field=Ci, title=Ci) for Ci in self.column_names_output]
#Setup table widgets
tablekwargs = {'width': self.pagewidth, 'editable': True}
self.TW_rocks = DataTable(source=self.CDS_rocks, columns=self.col_rocks, **tablekwargs)
self.TW_fluids = DataTable(source=self.CDS_fluids, columns=self.col_fluids, **tablekwargs)
self.TW_pres = DataTable(source=self.CDS_pres, columns=self.col_pres, **tablekwargs)
self.TW_out = DataTable(source=self.CDS_out, columns=self.col_out, **tablekwargs)
def createControls(self):
# Setup Select Panes and Input Widgets
#Obr - Overburden rock #ResR - Reservoir rock
#Obf - Oberburden fluid #Resf - Reservoir fluid
self.selectObr = Select(value=self.odict_rocks.keyslist()[0], options=self.odict_rocks.keyslist(),
title="Rock Model")
self.selectResR = Select(value=self.odict_rocks.keyslist()[0], options=self.odict_rocks.keyslist(),
title="Rock Model")
self.selectObf = Select(value=self.odict_fluids.keyslist()[0], options=self.odict_fluids.keyslist(),
title="Fluid Model")
self.selectResf = Select(value=self.odict_fluids.keyslist()[0], options=self.odict_fluids.keyslist(),
title="Fluid Model")
self.selectPres = Select(value=self.odict_pres.keyslist()[0], options=self.odict_pres.keyslist(),
title="Pressure Scenario")
self.slideDepth = Slider(start=0, end=10000, value=self.init_depth, step=10, title='Depth (TVDSS)',
callback_policy='mouseup')
self.selectObr.on_change('value', self.on_selection_change)
self.selectResR.on_change('value', self.on_selection_change)
self.selectObf.on_change('value', self.on_selection_change)
self.selectResf.on_change('value', self.on_selection_change)
self.selectPres.on_change('value', self.on_selection_change)
self.slideDepth.on_change('value', self.on_selection_change)
def createLayout(self):
# Layout of Page
self.inputTab1 = Panel(child=self.TW_rocks, title='Rock Models')
self.inputTab2 = Panel(child=self.TW_fluids, title='Fluid Mixes')
self.inputTab3 = Panel(child=self.TW_pres, title='Pressure Scenarios')
self.inputTab4 = Panel(child=self.TW_out, title='Model Calculations')
self.inputTabs = Tabs(tabs=[self.inputTab1, self.inputTab2,
self.inputTab3, self.inputTab4],
width=self.pagewidth, height=200)
textrowob = Div(text="<h1> Overburden: </h1>")
selectrowob = row(self.selectObr, self.selectObf, width=500, height=50, sizing_mode="scale_both")
textrowres = Div(text="<h1> Reservoir: </h1>")
selectrowres = row(self.selectResR, self.selectResf, width=500, height=50, sizing_mode="scale_both")
selectrowpres = row(self.selectPres, self.slideDepth, width=500, height=50, sizing_mode="scale_both")
self.layout = column(self.inputTabs,
textrowob,
selectrowob,
textrowres,
selectrowres,
selectrowpres, width=self.pagewidth)
def on_selection_change(self,attribute,old,new):
# update active selections
self.activeObr = self.df_rocks.loc[self.odict_rocks[self.selectObr.value]] #Overburden Rock and Fluid
self.activeObf = self.df_fluids.loc[self.odict_fluids[self.selectObf.value]]
self.activeResR = self.df_rocks.loc[self.odict_rocks[self.selectResR.value]] #Reservoir Rock and Fluid
self.activeResF = self.df_fluids.loc[self.odict_fluids[self.selectResf.value]]
self.activePresPf = self.df_pres.loc[self.odict_pres[self.selectPres.value]] #Pressure Profile
self.cur_depth = self.slideDepth.value
self.updateRocks()
self.updateFluids()
self.updateRockModel()
if self.fdi != None:
self.fdi.updateModel(self.activeResR_dry, self.activeResF_mix, self.fdi.min_pres, self.fdi.max_pres,
init_imp=self.activeResRM.pimp)
def updateRocks(self):
#update rock models based upon selections
parnonclay = ['knonclay', 'munonclay', 'rhononclay'];
parclay = ['kclay', 'muclay', 'rhoclay']
obnonshale = structMineral('nonshale', *[self.activeObr[par] for par in parnonclay])
obshale = structMineral('shale', *[self.activeObr[par] for par in parclay])
nonshale = structMineral('nonshale', *[self.activeResR[par] for par in parnonclay])
shale = structMineral('shale', *[self.activeResR[par] for par in parclay])
# output rock names to table
self.CDS_out.data['rock'] = [self.activeObr['Name'], self.activeResR['Name']]
#update dryrock properties
self.activeObr_dry = structDryFrame(self.activeObr['Name'], obnonshale, obshale, self.activeObr['vclay'],
self.activeObr['phi'])
self.activeResR_dry = structDryFrame(self.activeResR['Name'], nonshale, shale, self.activeResR['vclay'],
self.activeResR['phi'])
self.activeObr_dry.calcRockMatrix(); self.activeResR_dry.calcRockMatrix()
parp = ['init_Pres', 'curr_Pres']; pardry = ['dryEk', 'dryPk', 'dryEg', 'dryEk']
self.activeObr_dry.calcDryFrame(self.activePresPf['OB_Grad'], self.cur_depth, *[self.activePresPf[par] for par in parp],
*[self.activeObr[par] for par in pardry])
self.activeResR_dry.calcDryFrame(self.activePresPf['OB_Grad'], self.cur_depth, *[self.activePresPf[par] for par in parp],
*[self.activeResR[par] for par in pardry])
def updateFluids(self):
# oil, water, gas, setup and mixing
parw = ['kw', 'rhow', 'sw']; paro = ['ko', 'rhoo', 'so']; parg = ['kg', 'rhog', 'sg']
self.activeObf_mix = structFluid(self.activeObf['Name'], water=[self.activeObf[ind] for ind in parw],
oil=[self.activeObf[ind] for ind in paro],
gas=[self.activeObf[ind] for ind in parg])
self.activeResF_mix = structFluid(self.activeResF['Name'], water=[self.activeResF[ind] for ind in parw],
oil=[self.activeResF[ind] for ind in paro],
gas=[self.activeResF[ind] for ind in parg])
# output fluid names to table
self.CDS_out.data['fluid'] = [self.activeObf['Name'], self.activeResF['Name']]
def updateRockModel(self):
# calculate rock models and properties
self.activeObrM = structRock(self.activeObr_dry, self.activeObf_mix)
self.activeObrM.calcGassmann(); self.activeObrM.calcDensity(); self.activeObrM.calcElastic()
self.activeResRM = structRock(self.activeResR_dry, self.activeResF_mix)
self.activeResRM.calcGassmann(); self.activeResRM.calcDensity(); self.activeResRM.calcElastic()
# output rockproperties to table
self.CDS_out.data['Vp'] = [self.activeObrM.velp, self.activeResRM.velp]
self.CDS_out.data['Vs'] = [self.activeObrM.vels, self.activeResRM.vels]
self.CDS_out.data['rho'] = [self.activeObrM.den, self.activeResRM.den]
self.CDS_out.data['other'] = [self.activeObrM.pimp, self.activeResRM.pimp]
order = int(new)
update_data()
def on_text_value_change(attr, old, new):
try:
global expr
expr = sy.sympify(new, dict(x=xs))
except (sy.SympifyError, TypeError, ValueError) as exception:
dialog.content = str(exception)
dialog.visible = True
else:
update_data()
dialog = Dialog(title="Invalid expression")
slider = Slider(start=1, end=20, value=order, step=1, title="Order:")
slider.on_change('value', on_slider_value_change)
text = TextInput(value=str(expr), title="Expression:")
text.on_change('value', on_text_value_change)
inputs = HBox(children=[slider, text])
layout = VBox(children=[inputs, plot, dialog])
update_data()
document.add_root(layout)
session.show(layout)
if __name__ == "__main__":
print("\npress ctrl-C to exit")
session.loop_until_closed()
# initialize controls
# buttons for choosing a sample function
sample_function_type = RadioButtonGroup(labels=fs.function_names, active=fs.function_init)
# here one can choose arbitrary input function
default_function_input = TextInput(value=fs.function_input_init)
default_function_period_start = TextInput(title='period start', value=fs.timeinterval_start_init)
default_function_period_end = TextInput(title='period end', value=fs.timeinterval_end_init)
# slider controlling degree of the fourier series
degree = Slider(title="degree", name='degree', value=fs.degree_init, start=fs.degree_min,
end=fs.degree_max, step=fs.degree_step)
# initialize callback behaviour
degree.on_change('value', degree_change)
default_function_input.on_change('value',
type_input_change) # todo write default functions for any callback, like above
default_function_period_start.on_change('value', type_input_change)
default_function_period_end.on_change('value', type_input_change)
sample_function_type.on_change('active', type_input_change)
# initialize plot
toolset = "crosshair,pan,reset,resize,save,wheel_zoom"
# Generate a figure container
plot = Figure(plot_height=fs.resolution,
plot_width=fs.resolution,
tools=toolset,
title="Fourier Series Approximation",
x_range=[fs.x_min, fs.x_max],
y_range=[fs.y_min, fs.y_max]
class FPDApp(HBox):
extra_generated_classes = [["FPDApp", "FPDApp", "HBox"]]
main_frame = Instance(VBox)
top_frame = Instance(HBox)
table_frame = Instance(HBox)
input_frame = Instance(VBoxForm)
plot_frame = Instance(HBox)
# widget instances
min_excitation = Instance(Slider)
max_excitation = Instance(Slider)
min_emission = Instance(Slider)
max_emission = Instance(Slider)
chrom_class_select = Instance(Select)
# chrom_class = String(default='All')
data_table = Instance(DataTable)
plot = Instance(Plot)
source = Instance(ColumnDataSource)
# pretext = Instance(PreText)
@classmethod
def create(cls):
obj = cls()
obj.init_input()
obj.init_source()
obj.init_plot()
obj.set_children()
return obj
def __init__(self, *args, **kwargs):
super(FPDApp, self).__init__(*args, **kwargs)
def init_source(self):
self.source = ColumnDataSource(data=data)
self.data_table = DataTable(source=self.source, columns=[
TableColumn(field='fpid', title='FPID'),
TableColumn(field='chromophore_name', title='chromophore_name'),
TableColumn(field='chromophore_class', title='chromophore_class'),
TableColumn(field='protein_name', title='Protein name'),
TableColumn(field='excitation_new', title='Excitation'),
TableColumn(field='emission_new', title='Emission'),
TableColumn(field='pdb_id', title='PDB ID'),
TableColumn(field='genbank', title='Genbank ID'),
TableColumn(field='mutation', title='Mutation'),
TableColumn(field='quantum_yield', title='Quantum Yield'),
TableColumn(field='pka', title='pka'),
TableColumn(field='amino_acid_sequence', title='Sequence'),
])
self.data_table.width = 1200
# obj.pretext = PreText(text='No selected items', width=400)
def init_plot(self):
self.plot = self.scatter_plot()
def init_input(self):
# create input widgets only once
self.min_excitation = Slider(
title="Min Excitation", name="min_excitation",
value=min_excitation,
start=min_excitation,
end=max_excitation,
)
self.max_excitation = Slider(
title="Max Excitation", name="max_excitation",
value=max_excitation,
start=min_excitation,
end=max_excitation,
)
self.min_emission = Slider(
title="Min Emission", name="min_emission",
value=min_emission,
start=min_emission,
end=max_emission,
)
self.max_emission = Slider(
title="Max Emission", name="max_emission",
value=max_emission,
start=min_emission,
end=max_emission,
)
self.chrom_class_select = Select(
title="Chromophore",
value='All',
options=['All'] + CHROMOPHORES,
)
def set_sliders(self):
self.min_excitation = Slider(
title="Min Excitation", name="min_excitation",
value=self.min_excitation.value,
start=min_excitation,
end=max_excitation,
)
self.max_excitation = Slider(
title="Max Excitation", name="max_excitation",
value=self.max_excitation.value,
start=min_excitation,
end=max_excitation,
)
self.min_emission = Slider(
title="Min Emission", name="min_emission",
value=self.min_emission.value,
start=min_emission,
end=max_emission,
)
self.max_emission = Slider(
title="Max Emission", name="max_emission",
value=self.max_emission.value,
start=min_emission,
end=max_emission,
)
def get_data(self):
df = data
df = df[df['excitation_new']>=self.min_excitation.value]
df = df[df['excitation_new']<=self.max_excitation.value]
df = df[df['emission_new']>=self.min_emission.value]
df = df[df['emission_new']<=self.max_emission.value]
if self.chrom_class_select.value == 'All': # all chromophore classes
return df
else:
df = df[df['chromophore_class']==self.chrom_class_select.value]
return df
def make_source(self):
self.source.data = self.get_data().to_dict('list')
def make_plots(self):
# # print('CALL: make_plots')
self.plot = self.scatter_plot()
@property
def selected_df(self):
df = data
selected = self.source.selected
if selected:
df = df.iloc[selected, :]
return df
def scatter_plot(self):
toolset = "pan,reset,resize,save,wheel_zoom,hover,box_select"
plot = figure(tools=toolset)
plot.scatter('excitation_new', 'emission_new',
source=self.source,
plot_width=100, plot_height=200,
radius=4, fill_alpha=0.4,
fill_color='excitation_color_new',
line_color='#000000',
)
plot.xaxis.axis_label = 'Emission'
plot.yaxis.axis_label = 'Excitation'
plot.x_range = Range1d(start=min_excitation, end=max_excitation)
plot.y_range = Range1d(start=min_emission, end=max_excitation)
hover = plot.select(dict(type=HoverTool))
hover.tooltips = [
("FPID ", "@fpid"),
("Chromophore name ", "@chromophore_name"),
("Excitation color class ", "@excitation_color_class"),
("Emission color class ", "@emission_color_class"),
("Primary excitation ", "@excitation_new"),
("Secondary excitation ", "@excitation_alt"),
("Primary emission ", "@emission_new"),
("Secondary emission ", "@emission_alt"),
]
return plot
def set_children(self):
self.input_frame = VBoxForm(children=[
self.min_excitation,
self.max_excitation,
self.min_emission,
self.max_emission,
self.chrom_class_select,
])
self.plot_frame = HBox(children=[self.plot])
self.top_frame = HBox(children=[self.plot_frame, self.input_frame])
self.table_frame = HBox(children=[self.data_table])
self.main_frame = VBox(children=[self.top_frame, self.table_frame])
self.children = [self.main_frame]
def setup_events(self):
super(FPDApp, self).setup_events()
if self.source:
self.source.on_change('selected', self, 'on_slider_change')
if self.min_excitation:
self.min_excitation.on_change('value', self, 'on_slider_change')
if self.max_excitation:
self.max_excitation.on_change('value', self, 'on_slider_change')
if self.min_emission:
self.min_emission.on_change('value', self, 'on_slider_change')
if self.max_emission:
self.max_emission.on_change('value', self, 'on_slider_change')
if self.chrom_class_select:
self.chrom_class_select.on_change(
'value', self, 'on_class_change')
def on_class_change(self, obj, attrname, old, new):
self.chrom_class_select.value = new
self.make_source()
self.make_plots()
curdoc().add(self)
def on_slider_change(self, obj, attrname, old, new):
if obj == self.min_excitation:
self.min_excitation.value = new
if self.min_excitation.value > self.max_excitation.value:
self.min_excitation.value = old
if obj == self.max_excitation:
self.max_excitation.value = new
if self.max_excitation.value < self.min_excitation.value:
self.max_excitation.value = old
if obj == self.min_emission:
self.min_emission.value = new
if self.min_emission.value > self.max_emission.value:
self.min_emission.value = old
if obj == self.max_emission:
self.max_emission.value = new
if self.max_emission.value < self.min_emission.value:
self.max_emission.value = old
self.set_sliders()
self.make_source()
self.set_children()
curdoc().add(self)
end=[math.radians(alpha), math.radians(
alpha + beta), math.radians(alpha + beta)],
color=["red", "blue", "purple"])
def update_beta(attr, old, new):
global beta
beta = beta_slider.value
xs, ys = set_patches(alpha, beta)
patch_source.data = dict(xs=xs, ys=ys, color=color)
xs, ys = set_lines(alpha, beta)
dotted_line_source.data = dict(
xs=xs, ys=ys, color=["black", "black"])
arc_source.data = dict(x=[0, 0, 0], y=[0, 0, 0, ],
radius=[0.2, 0.25, 0.3],
start=[0, math.radians(alpha), 0],
end=[math.radians(alpha), math.radians(
alpha + beta), math.radians(alpha + beta)],
color=["red", "blue", "purple"])
alpha_slider.on_change('value', update_alpha)
beta_slider.on_change('value', update_beta)
sliders = column(alpha_slider,
beta_slider)
plot = column(sliders, fig)
document = curdoc()
document.add_root(plot)
# plotting for arc length parametrization
source_point_arc = ColumnDataSource(data=dict(x=[], y=[]))
# initialize controls
# choose between original and arc length parametrization
parametrization_input = CheckboxGroup(labels=['show original parametrization',
'show arc length parametrization'],
active=[0, 1])
parametrization_input.on_click(parametrization_change)
# slider controlling the current parameter t
t_value_input = Slider(title="parameter t", name='parameter t', value=arc_settings.t_value_init,
start=arc_settings.t_value_min, end=arc_settings.t_value_max,
step=arc_settings.t_value_step)
t_value_input.on_change('value', t_value_change)
# text input for the x component of the curve
x_component_input = TextInput(value=arc_settings.x_component_input_msg, title="curve x")
x_component_input.on_change('value', curve_change)
# text input for the y component of the curve
y_component_input = TextInput(value=arc_settings.y_component_input_msg, title="curve y")
y_component_input.on_change('value', curve_change)
# dropdown menu for selecting one of the sample curves
sample_curve_input = Dropdown(label="choose a sample function pair or enter one below",
menu=arc_settings.sample_curve_names)
sample_curve_input.on_click(sample_curve_change)
# initialize plot
toolset = "crosshair,pan,reset,resize,save,wheel_zoom"
# Generate a figure container
def on_text_value_change(attr, old, new):
try:
global expr
expr = sy.sympify(new, dict(x=xs))
except (sy.SympifyError, TypeError, ValueError) as exception:
dialog.content = str(exception)
dialog.visible = True
else:
update_data()
dialog = Dialog(title="Invalid expression")
slider = Slider(start=1, end=20, value=order, step=1, title="Order", callback_policy="mouseup")
slider.on_change("value", on_slider_value_change)
text = TextInput(value=str(expr), title="Expression:")
text.on_change("value", on_text_value_change)
inputs = WidgetBox(children=[slider, text], width=400)
layout = Column(children=[inputs, plot, dialog])
update_data()
document.add_root(layout)
session.show(layout)
if __name__ == "__main__":
print("\npress ctrl-C to exit")
session.loop_until_closed()
df = pd.DataFrame()
boundaryDF = pd.DataFrame()
colorDF = pd.DataFrame()
outDF = pd.DataFrame()
Console = PreText(
text="Console:\nStart visualize by entering \nannotations, pickle file and gene.\nPress Enter to submit.\n",
width=250,
height=100,
)
p = createPlot(df, boundaryDF)
Gene.on_change("value", updateGene)
Full.on_change("value", updateFP)
Partial.on_change("value", updateFP)
Alpha.on_change("value", updateFP)
Cluster.on_change("value", updateGroup)
Save.on_change("value", saveFasta)
Width.on_change("value", updateWidth)
dataColumns = [TableColumn(field="Gene", title="Gene"), TableColumn(field="Cluster", title="Cluster")]
data_table = DataTable(source=geneSource, columns=dataColumns, width=200, height=1200)
paramSource = ColumnDataSource(
data=dict(
Parameter=[
"annotation",
"format",
"matches",
range_start = range_select.value[0],
range_end = range_select.value[1],
bin_width = binwidth_select.value)
src.data.update(new_src.data)
# CheckboxGroup to select carrier to display
carrier_selection = CheckboxGroup(labels=available_carriers, active = [0, 1])
carrier_selection.on_change('active', update)
# Slider to select width of bin
binwidth_select = Slider(start = 1, end = 30,
step = 1, value = 5,
title = 'Delay Width (min)')
binwidth_select.on_change('value', update)
# RangeSlider control to select start and end of plotted delays
range_select = RangeSlider(start = -60, end = 180, value = (-60, 120),
step = 5, title = 'Delay Range (min)')
range_select.on_change('value', update)
# Find the initially selected carrieres
initial_carriers = [carrier_selection.labels[i] for i in carrier_selection.active]
src = make_dataset(initial_carriers,
range_start = range_select.value[0],
range_end = range_select.value[1],
bin_width = binwidth_select.value)
"date": [conso_date, conso_date],
"conso": (0., conso_bounds[1])
}
title = "Consommation {}, {}".format(sector_id, conso_date)
print(title)
conso_plot.update_title(title)
conso_plot.set_active(mode)
def update(attrname, old, new):
print("update {} {} {}".format(attrname, old, new))
sector_id = int(sector_select.value)
conso_date = datetime(2016, 3, int(date_slider.value),
int(time_slider.value))
update_sources(sector_id, conso_date, type_button.active)
sector_select.on_change("value", update)
date_slider.on_change("value", update)
time_slider.on_change("value", update)
type_button.on_change("active", update)
def on_selection_change(attr, old, new):
print("on_selection_change")
indices = new["1d"]["indices"]
if indices:
sector_id = geo_sectors.loc[indices[0]]["sector_id"]
sector_select.value = str(sector_id) # Calls update in chain
#update_sources(sector_id=sector_id)
map_plot.get_data_source().on_change("selected", on_selection_change)
def close_session():
session.close()
button.on_click(close_session)
def slider_change(attr, old, new):
global interval
interval = (10 * max_interval + min_interval + new * (min_interval - max_interval)) / 9
if play:
curdoc().remove_periodic_callback(update)
curdoc().add_periodic_callback(update, interval)
def button_group_click(new):
global play
if new == 0: # play
play = True
curdoc().add_periodic_callback(update, interval)
else:
play = False
curdoc().remove_periodic_callback(update)
def button_click():
global X, step
step = 1
X = np.copy(X_init)
redraw()
slider.on_change("value", slider_change)
button_group.on_click(button_group_click)
button.on_click(button_click)
session.show(row(wb, p1, p2))
session.loop_until_closed()
and update the image data as well as the coloring of the image.
2. if any relevant parameters for the computation of the colormap have changed, apply the colormap to unchanged
raw mandelbrot set data and save the changed colors to the corresponding data source
"""
parameters_have_changed = check_parameters(slider_max_iterations.value)
frequency_has_changed = check_frequency(slider_frequency.value)
if parameters_have_changed:
update_mandelbrot_set()
update_colormap(None, None, slider_frequency.value)
return
elif frequency_has_changed:
update_colormap(None, None, slider_frequency.value)
return
else:
return
# initialize data
update_mandelbrot_set()
update_colormap(None, None, slider_frequency.value)
# setup callback for colormap frequency change
slider_frequency.on_change('value', update_colormap)
# update picture all 100 ms w.r.t current view
curdoc().add_periodic_callback(update_data, mandelbrot_settings.update_time)
# make layout
curdoc().add_root(column(plot, slider_max_iterations, slider_frequency))
import numpy as np
x = np.linspace(0, 10, 500)
y=np.sin(x)
df=pd.DataFrame({'x':x,'y':y})
source = ColumnDataSource(data=dict(x=df.x, y=df.y))
plot_figure = figure(title='Slider',plot_height=450, plot_width=600,
tools="save,reset", toolbar_location="below")
plot_figure.line('x', 'y', line_width=3, source=source)
slider = Slider(start=0.1, end=10, value=1, step=.1, title="Change Frequency")
def slider_change(attr,old,new):
slider_value=slider.value ##Getting radio button value
y_change=np.sin(x*slider_value)
source.data=dict(x=x, y=y_change)
slider.on_change('value',slider_change)
layout=row(slider, plot_figure)
curdoc().add_root(layout)
curdoc().title = "Slider Bokeh Server"
colors = [spectral[i] for i in y_pred]
source.data['x'] = X[:, 0]
source.data['y'] = X[:, 1]
source.data['colors'] = colors
def update_clusters(attrname, old, new):
algorithm = algorithm_select.value
n_clusters = int(clusters_slider.value)
n_samples = int(samples_slider.value)
global X
X, y_pred = clustering(X, algorithm, n_clusters)
colors = [spectral[i] for i in y_pred]
source.data['x'] = X[:, 0]
source.data['y'] = X[:, 1]
source.data['colors'] = colors
algorithm_select.on_change('value', update_algorithm)
dataset_select.on_change('value', update_dataset)
clusters_slider.on_change('value', update_clusters)
samples_slider.on_change('value', update_samples)
# SET UP LAYOUT
sliders = VBox(children=[samples_slider, clusters_slider])
selects = HBox(children=[dataset_select, algorithm_select])
inputs = VBox(children=[sliders, selects])
plots = HBox(children=[plot])
# add to document
curdoc().add_root(HBox(children=[inputs, plots]))
plot.renderers.append(p_line)
p_value_text = bokeh.models.Paragraph()
def get_p_text():
return 'p={}'.format(get_p())
p_value_text.text = get_p_text()
def callback(attr, old, new):
p_line.location = -math.log10(get_p())
left.location = left_limit.value
right.location = right_limit.value
p_value_text.text = get_p_text()
p_value.on_change('value', callback)
p_mult.on_change('value', callback)
left_limit.on_change('value', callback)
right_limit.on_change('value', callback)
###################################################
## Data table ##############################
###################################################
aux_source = bokeh.models.ColumnDataSource()
table = bokeh.models.DataTable(
source=aux_source,
columns=[
bokeh.models.TableColumn(field='text', title='text')
],
fit_columns=True,
checkbox_group = CheckboxGroup(
labels=["Forward Propagating Wave", "Reverse Propagating Wave", "Sum of Waves",
"Standing Wave (valid only for \u03B1=0)"], active=[0, 1])
checkbox_group.on_click(checkbox_group_handler)
# Set up slider & callback function
def update_alpha(attrname, old, new):
global alpha
alpha = alpha_slider.value
if not toggle.active:
l_forward.data_source.data["y"] = forward_wave()
l_reverse.data_source.data["y"] = reverse_wave()
l_sum.data_source.data["y"] = l_forward.data_source.data["y"] + \
l_reverse.data_source.data["y"]
alpha_slider = Slider(title="Attenuation Constant, \u03B1 (1/m)", value=0.0, start=0.0, end=0.25, step=0.005)
alpha_slider.on_change('value', update_alpha)
# Set up slider & callback function for reflection_coef
def update_gamma(attrname, old, new):
global reflection_coef
reflection_coef = gamma_slider.value
if not toggle.active:
l_forward.data_source.data["y"] = forward_wave()
l_reverse.data_source.data["y"] = reverse_wave()
l_sum.data_source.data["y"] = l_forward.data_source.data["y"] + \
l_reverse.data_source.data["y"]
l_standing.data_source.data["y"] = standing_wave()
gamma_slider = Slider(title="Reflection Coefficient, \u0393", value=reflection_coef, start=-1.0, end=1.0, step=0.01)
gamma_slider.on_change('value', update_gamma)
# Set up layout
alpha = alphaSlider.value
offset = offsetSlider.value
response.data['y'] = contrast**alpha + offset
response_plus_noise.data['y'] = contrast**alpha + offset + (np.random.random(contrast.shape)-0.5)/CNR
baseline.data['y'] = offset*np.ones(contrast.shape)
baseline_plus_noise.data['y'] = offset+(np.random.random(contrast.shape)-0.5)/CNR
p1.title = 'CNR = %2.1f' %CNR
# sim some data
data = np.zeros([nRep,3])
for iRep in range(nRep):
stim = offset + np.array([0.08,0.16,0.32])**alpha + (np.random.random((1,3))-0.5)/CNR
fonly = offset + (np.random.random()-0.5)/CNR
data[iRep,:] = stim - fonly
# and push to plots
for iC,c in enumerate([0.08,0.16,0.32]):
data_all[iC].data['y'] = data[:,iC]
data_all[iC].data['x'] = c*np.ones([nRep])
data_means.data['y'] = np.mean(data,axis=0)
for iC,c in enumerate([0.08,0.16,0.32]):
data_eb[iC].data['y'] = np.mean(data[:,iC]) + np.std(data[:,iC])/np.sqrt(nRep)*np.array([-1,1])
CNRslider.on_change('value',update)
nREPslider.on_change('value',update)
alphaSlider.on_change('value',update)
offsetSlider.on_change('value',update)
redrawButton.on_change('clicks',update)
from bokeh.io import curdoc
df = pd.read_csv(join(dirname(__file__), 'salary_data.csv'))
source = ColumnDataSource(data=dict())
def update():
current = df[df['salary'] <= slider.value].dropna()
source.data = {
'name' : current.name,
'salary' : current.salary,
'years_experience' : current.years_experience,
}
slider = Slider(title="Max Salary", start=10000, end=250000, value=150000, step=1000)
slider.on_change('value', lambda attr, old, new: update())
button = Button(label="Download", button_type="success")
button.callback = CustomJS(args=dict(source=source),
code=open(join(dirname(__file__), "download.js")).read())
columns = [
TableColumn(field="name", title="Employee Name"),
TableColumn(field="salary", title="Income", formatter=NumberFormatter(format="$0,0.00")),
TableColumn(field="years_experience", title="Experience (years)")
]
data_table = DataTable(source=source, columns=columns, width=800)
controls = widgetbox(slider, button)
table = widgetbox(data_table)
zip_data = build_zip_data(
where_inner = where_inner,
where_outer = where_outer
)
zip_source.data = dict(
x=zip_data["median_income"],
y=zip_data["complaint_count"]
)
table_source.data = build_data_table(where_inner)
state_widget.on_change('value', update)
product_widget.on_change('value', update)
issue_widget.on_change('value', update)
min_complaints_widget.on_change('value', update)
### Step 3: Build the charts
# Build state bar chart
state_bar_chart = Bar(build_state_data(), label="state",
values='complaint_count', toolbar_location=None,
title="Complaints by State", width=1300, height=200,
ylabel="", xlabel="", color="#2cb34a")
# Build zip code scatter plot
zip_data = build_zip_data()
zip_source.data = dict(x = zip_data["median_income"],
y = zip_data["complaint_count"])
zip_scatter_plot = Figure(plot_height=500, plot_width=1000,
title="Complaints by Median Income",
response_plus_noise = response + (np.random.random(contrast.shape)-0.5)/CNR
# sim some data
data = np.zeros([nRep,3])
for iRep in range(nRep):
stim = baseline + np.array([0.08,0.16,0.32])**alpha + (np.random.random((1,3))-0.5)/CNR
fonly = baseline + np.random.random()-0.5
data[iRep,:] = stim - fonly
#p1.line([0,1], [baseline,baseline], line_dash=[8,8], color = 'green')
#p1.line(contrast, (np.random.random(contrast.shape)-0.5)/CNR+baseline, alpha=0.6, color='green')
#p1.line(contrast,response, alpha=0.6, color='black')
#p1.line(contrast,response_plus_noise, alpha=0.6, color='black')
sourceLine.data['xs']=[[0,1],contrast,contrast,contrast]
sourceLine.data['ys']=[[baseline,baseline],[(np.random.random(contrast.shape)-0.5)/CNR+baseline],response, response_plus_noise]
p1.title = 'CNR = %2.1f' %CNR
p2.line([0,1], [0,0], line_dash=[8,8], color = 'green')
for iC,c in enumerate([0.08,0.16,0.32]):
p2.circle(c*np.ones([nRep]), data[:,iC], color='red', fill_alpha=0.3, line_alpha=0.3)
for iC,c in enumerate([0.08,0.16,0.32]):
p2.circle(c, np.mean(data[:,iC]), color='red')
p2.line([c,c], np.mean(data[:,iC]) + np.std(data[:,iC])/np.sqrt(nRep)*np.array([-1,1]), color='red')
CNRslider.on_change('value',update)
class plotter_bif:
def __init__(self, _aggr, _depl, _dRdt, _S_0,
_kvalues=np.ones(7), _kmax=0, _wire_url=0, _formula_url=0,
_N=200, _Rmax=2, _Rmin=0, _Smax=3, _Smin=0, _title='test', _R0=0, _imgheight=150):
self.aggregation = _aggr
self.depletion = _depl
self.dRdt = _dRdt
self.kvalues = _kvalues
self.N = _N #density of plot points
self.Rmax = _Rmax
self.Rmin = _Rmin
self.Smax = _Smax
self.Smin = _Smin
self.S = _S_0
S0 = [_S_0] #this is necessary since some struct need a list as input
self.wire_url = _wire_url
self.formula_url = _formula_url
self.title = _title
self.R = _R0
self.imgheight=_imgheight
if (np.size(_kmax)==1):
self.kmax=np.array(_kvalues)
self.kmax[:]['value'] = self.kmax[:]['value']*2
else:
self.kmax=_kmax
# Set up data
R_x = np.linspace(self.Rmin, self.Rmax, self.N)
self.dRmin = np.max(self.depletion(R_x, self.kvalues))
dR_dt_depl = self.depletion(R_x, self.kvalues)
dR_dt_aggr = self.aggregation(R_x, self.S, self.kvalues)
#R_ss = self.Rss(self.S, self.kvalues)
#dR_dt_ss = self.depletion(R_ss, self.kvalues)
self.dRmax = max(np.max(dR_dt_depl), np.max(dR_dt_aggr))
self.dRmin = min(np.min(dR_dt_depl), np.min(dR_dt_aggr))
self.data_dR_dt_R = ColumnDataSource(data=dict(R=R_x, dR_dt_depl=dR_dt_depl, dR_dt_aggr=dR_dt_aggr)) #graphs
#self.data_dR_dt_R_lines = ColumnDataSource(data=dict(R_ss_y=[R_ss, R_ss], dR_dt_ss_y=[0, depletion(R_ss, self.kvalues)]))#y parallel
#self.data_dR_dt_R_point_lab = ColumnDataSource(data=dict(R_ss=[R_ss], dR_dt_ss=[dR_dt_ss], lab=["R_ss = %.2f" % R_ss])) #label
#self.data_dR_dt_R_point = ColumnDataSource(data=dict(R_ss=R_ss, dR_dt_ss=dR_dt_ss)) #label
#we need to separate this, since bokeh has problem with drawing circles from data in the label structure
#2nd graph, this differs from original graph
R_y = np.linspace(self.Rmin, self.Rmax, self.N)
S_x = np.linspace(self.Smin, self.Smax, self.N)
R_, S_ = np.meshgrid(R_y, S_x)
RS = self.dRdt(R_, S_, self.kvalues)
R_split = self.split_R(RS, R_)
S_split = np.split(S_x, self.get_index_Scrit(RS))
#self.data_S_R = ColumnDataSource(data=dict(R_split=R_split, S_split=S_split))
#implement a list of columnnames and use that list with add to append datasource
R = np.array([])
R_dotted = np.array([])
S = np.array([])
S_dotted = np.array([])
self.data_R_S2 = ColumnDataSource()
self.data_R_S2_dotted = ColumnDataSource()
for i, r_ in enumerate(R_split):
for j, r in enumerate(r_):
s = S_split[i]
_r = r
_s = s
if j%2 == 1:
_r = np.flip(r, 0)
_s = np.flip(s, 0)
R_dotted = np.append(R_dotted, _r)
S_dotted = np.append(S_dotted, _s)
R = np.append(R, _r)
S = np.append(S, _s)
self.data_R_S2.add(R, "R")
self.data_R_S2.add(S, "S")
self.data_R_S2_dotted.add(R_dotted, "R")
self.data_R_S2_dotted.add(S_dotted, "S")
# Set up widgets
self.S_var = Slider(title="S", value=self.S, start=self.Smin, end=self.Smax, step=(self.Smax - self.Smin)/100)
self.k_var = list(np.empty(np.size(self.kvalues)))
for i, k in enumerate(self.kvalues):
self.k_var[i] = Slider(title=k['name'], value=k['value'], start=0.0, end=self.kmax[i]['value'], step=0.01)
def signchange2D(self, a):
asign = np.sign(a)
return ((np.roll(asign, 1, axis=1) - asign) != 0).astype(int)
def signchange(self, a):
asign = np.sign(a)
return ((np.roll(asign, 1) - asign) != 0).astype(int)
def corr_sign(self, a):
signed = self.signchange2D(a)
#print(signed[300])
#get rid of preceeeding 1 due to wrap around -> correct all 1s at [0] and then roll left
signed[:, 0] = 0
signed = np.roll(signed, -1, axis=1)
return signed
#get indices that have equal numbers of root / get subarrays
def get_index_Scrit(self, a):
roots = np.sum(self.corr_sign(a), axis=1)
#print(roots)
root_indeces = np.array([0])
#the first index is always the beginning of a subarray
#use np.roll to find 'signchanges' in mask
for n in np.unique(roots):
mask = np.isin(roots, n)
mask = mask.astype(int)
changes = self.signchange(mask)
#changes[:, 0] = 1
#mark first element, as the first element of each subarray is marked
indeces = np.argwhere(changes==1)
root_indeces = np.append(root_indeces, indeces)
return np.unique(root_indeces)[1:]
#return only unique indeces, since some indeces might appear more often
#also 0 index is not needed
def split_R(self, RS, R_):
#if np.size(self.get_index_Scrit(RS))==0:
#return R_
Rs = R_[self.corr_sign(RS)==1]
N = np.size(RS, 0)
result = []
old_n = 0
first_ind = 0
for n in np.append(self.get_index_Scrit(RS), N):
R = np.empty(n-old_n)
m = np.sum(self.corr_sign(RS), axis=1)[n-1]
#get #roots
#print(first_ind, old_n, m, n)
for i in range(m):
#print(i, m, n, first_ind, old_n , np.shape(R), np.shape(Rs), np.shape(Rs[first_ind+i:first_ind+(n-old_n)*m+i:m]))
#R = np.vstack((R, Rs[first_ind+i:first_ind+m*n+i:m]))
R = np.vstack((R, Rs[first_ind+i:first_ind+(n-old_n)*m+i:m]))
#start:stop:step, stop is not inclusive
result.append(R[1:])
#get rid of preceeding zeros
#first_ind = first_ind+m*n
first_ind = first_ind+(n-old_n)*m
old_n = n
return result
def create_figure(self):
# Set up plot
#plot_dR_dt = figure(plot_height=600, plot_width=600, title="Depletion/Aggregation Rate",
# #tools="crosshair,pan,reset,save,wheel_zoom",
# x_range=[self.Rmin, self.Rmax], y_range=[self.dRmin, self.dRmax], toolbar_location="above")
plot_dR_dt = figure(plot_height=800, plot_width=600, title="Depletion/Aggregation Rate",
x_range=[self.Rmin, self.Rmax], y_range=[self.dRmin, self.dRmax])
plot_dR_dt.line('R', 'dR_dt_aggr', source=self.data_dR_dt_R, line_width=3, line_alpha=0.6, color='steelblue')
plot_dR_dt.line('R', 'dR_dt_depl', source=self.data_dR_dt_R, line_width=3, line_alpha=0.6, color='crimson')
#plot_dR_dt.line('R_ss_y', 'dR_dt_ss_y', source=self.data_dR_dt_R_lines, line_width=3, line_alpha=0.6, color='red', line_dash='4 4')
#labels = LabelSet(x='R_ss', y='dR_dt_ss', text='lab', level='glyph',
# x_offset=7, y_offset=-25, source=self.data_dR_dt_R_point_lab, render_mode='canvas')
#plot_dR_dt.add_layout(labels)
#plot_dR_dt.circle('R_ss', 'dR_dt_ss', source=self.data_dR_dt_R_point, fill_color="white", size=10)
plot_dR_dt.yaxis.axis_label = "dR/dt"
plot_dR_dt.xaxis.axis_label = "R"
plot_dR_dt.toolbar.logo = None
plot_dR_dt.toolbar_location = None
#this part differs to original class
plot_R_S= figure(plot_height=800, plot_width=600, title="Steady State Solutions",
x_range=[self.Smin, self.Smax], y_range=[self.Rmin, self.Rmax], toolbar_location="above")
plot_R_S.line(x='S', y='R', source=self.data_R_S2, line_width=3, line_alpha=0.6, color='black')
plot_R_S.line(x='S', y='R', source=self.data_R_S2_dotted, line_width=3, line_alpha=1.0, color='white', line_dash='4 4')
plot_R_S.yaxis.axis_label = "R_ss"
plot_R_S.xaxis.axis_label = "S"
plot_R_S.toolbar.logo = None
plot_R_S.toolbar_location = None
plot_wire = figure(plot_height=300, plot_width=300, x_range=(0,1), y_range=(0,1), title='Wire Diagramm')
plot_wire.image_url(url=[self.wire_url], x=0, y=1, w=1, h=1)
plot_wire.toolbar.logo = None
plot_wire.toolbar_location = None
plot_wire.axis.visible = False
plot_formula = figure(plot_width=300, plot_height=self.imgheight, x_range=(0,1), y_range=(0,1), title='Formulas')
plot_formula.image_url(url=[self.formula_url], x=.01, y=.99, w=.99, h=.99)
plot_formula.toolbar.logo = None
plot_formula.toolbar_location = None
plot_formula.axis.visible = False
return plot_dR_dt, plot_R_S, plot_wire, plot_formula
def update_data(self, attrname, old, new):
# Get the current slider values
self.S = self.S_var.value
S0 = [self.S]
for i,k in enumerate(self.k_var):
self.kvalues['value'][i] = k.value
## update curve
R_x = np.linspace(self.Rmin, self.Rmax, self.N)
dR_dt_depl = self.depletion(R_x, self.kvalues)
dR_dt_aggr = self.aggregation(R_x, self.S, self.kvalues)
#R_ss = Rss(self.S, self.kvalues)
self.data_dR_dt_R.data = dict(R=R_x, dR_dt_depl=dR_dt_depl, dR_dt_aggr=dR_dt_aggr) #graphs
#self.data_dR_dt_R_lines.data = dict(R_ss_y=[R_ss, R_ss], dR_dt_ss_y=[0, depletion(R_ss, self.kvalues)])#y parallel
#self.data_dR_dt_R_point_lab.data = dict(R_ss=[R_ss], dR_dt_ss=[depletion(R_ss, self.kvalues)], lab=["R_ss = %.2f" % R_ss]) #label
#self.data_dR_dt_R_point.data = dict(R_ss=R_ss, dR_dt_ss=depletion(R_ss, self.kvalues))
#S = np.linspace(self.Smin, self.Smax, self.N)
#R_y = Rss(S, self.kvalues)
R_y = np.linspace(self.Rmin, self.Rmax, self.N)
S_x = np.linspace(self.Smin, self.Smax, self.N)
R_, S_ = np.meshgrid(R_y, S_x)
RS = self.dRdt(R_, S_, self.kvalues)
R_split = self.split_R(RS, R_)
S_split = np.split(S_x, self.get_index_Scrit(RS))
#implement a list of column_names and use that list with add to append datasource
R = np.array([])
R_dotted = np.array([])
S = np.array([])
S_dotted = np.array([])
for i, r_ in enumerate(R_split):
for j, r in enumerate(r_):
s = S_split[i]
_r = r
_s = s
if j%2 == 1:
_r = np.flip(r, 0)
_s = np.flip(s, 0)
R_dotted = np.append(R_dotted, _r)
S_dotted = np.append(S_dotted, _s)
R = np.append(R, _r)
S = np.append(S, _s)
self.data_R_S2.data["R"] = R
self.data_R_S2.data["S"] = S
self.data_R_S2_dotted.data["R"] = R_dotted
self.data_R_S2_dotted.data["S"] = S_dotted
#self.data_S_R_lines.data=dict(R_ss_y=[0, R_ss], S_ss_y=[self.S, self.S], #y parallel
# R_ss_x=[R_ss, R_ss], S_ss_x=[0, self.S]) #x parallel
#self.data_S_R_point.data = dict(S_ss=S0, R_ss=R_ss)#dot
def plot(self, doc):
for w in self.k_var:
w.on_change('value', self.update_data)
self.S_var.on_change('value', self.update_data)
# Set up layouts and add to document
plot_dR_dt, plot_R_S, plot_wire, plot_formula = self.create_figure()
l = row([column([plot_wire, plot_formula, widgetbox(self.S_var), row([widgetbox(self.k_var[0::2], width=150), widgetbox(self.k_var[1::2], width=150)])]),
plot_dR_dt, plot_R_S], sizing_mode='fixed', width=1500, height=800)
doc.add_root(l)
def show_notebook(self):
handler = FunctionHandler(self.plot)
app = Application(handler)
show(app, notebook_url="localhost:8888")
def show_server(self):
self.plot(curdoc())
curdoc().title = self.title
source = ColumnDataSource(data=dict())
columns = [TableColumn(field="name", title="Employee Name"),
TableColumn(field="salary", title="Income"),
TableColumn(field="years_experience", title="Experience (years)")]
data_table = DataTable(source=source, columns=columns)
def update(attr, old, new):
curr_df = df[df['salary'] <= salary_range.value].dropna()
source.data = dict(name=curr_df['name'].tolist(),
salary=curr_df['salary'].tolist(),
years_experience=curr_df['years_experience'].tolist())
salary_range.on_change('value', update)
js_callback = """
var data = source.get('data');
var filetext = 'name,income,years_experience\\n';
for (i=0; i < data['name'].length; i++) {
var currRow = [data['name'][i].toString(),
data['salary'][i].toString(),
data['years_experience'][i].toString().concat('\\n')];
var joined = currRow.join();
filetext = filetext.concat(joined);
}
var filename = 'data_result.csv';
var blob = new Blob([filetext], { type: 'text/csv;charset=utf-8;' });
