def modify_doc(doc):
plot = Plot(plot_height=400, plot_width=400, x_range=Range1d(0, 1), y_range=Range1d(0, 1), min_border=0)
slider = Slider(start=0, end=10, value=1, title="bar", css_classes=["foo"], width=300)
def cb(attr, old, new):
slider.title = "baz"
slider.on_change('value', cb)
doc.add_root(column(slider, plot))
def modify_doc(doc):
plot = Plot(plot_height=400, plot_width=400, x_range=Range1d(0, 1), y_range=Range1d(0, 1), min_border=0)
slider = Slider(start=0, end=10, value=1, title="bar", css_classes=["foo"], width=300, callback_policy="mouseup")
def cbv(attr, old, new): junk['v'] += 1
def cbvt(attr, old, new): junk['vt'] += 1
slider.on_change('value', cbv)
slider.on_change('value_throttled', cbvt)
doc.add_root(column(slider, plot))
def main(options, args):
#logger = log.get_logger("ginga", options=options)
logger = log.get_logger("ginga", level=20, log_file="/tmp/ginga.log")
#TOOLS = "pan,wheel_zoom,box_select,tap"
TOOLS = "box_select"
# create a new plot with default tools, using figure
fig = figure(x_range=[0, 600], y_range=[0, 600],
plot_width=600, plot_height=600, tools=TOOLS)
viewer = ib.CanvasView(logger)
viewer.set_figure(fig)
bd = viewer.get_bindings()
bd.enable_all(True)
## box_select_tool = fig.select(dict(type=BoxSelectTool))
## box_select_tool.select_every_mousemove = True
#tap_tool = fig.select_one(TapTool).renderers = [cr]
# open a session to keep our local document in sync with server
#session = push_session(curdoc())
#curdoc().add_periodic_callback(update, 50)
def load_file(path):
image = load_data(path, logger=logger)
viewer.set_image(image)
def load_file_cb(attr_name, old_val, new_val):
#print(attr_name, old_val, new_val)
load_file(new_val)
def zoom_ctl_cb(attr_name, old_val, new_val):
if new_val >= 0:
new_val += 2
viewer.zoom_to(int(new_val))
scale = viewer.get_scale()
logger.info("%f" % scale)
viewer.onscreen_message("%f" % (scale), delay=0.3)
# add a entry widget and configure with the call back
#dstdir = options.indir
dstdir = ""
path_w = TextInput(value=dstdir, title="File:")
path_w.on_change('value', load_file_cb)
slide = Slider(start=-20, end=20, step=1, value=1)
slide.on_change('value', zoom_ctl_cb)
layout = column(fig, path_w, slide)
curdoc().add_root(layout)
if len(args) > 0:
load_file(args[0])
def modify_doc(doc):
source = ColumnDataSource(dict(x=[1, 2], y=[1, 1], val=["a", "b"]))
plot = Plot(plot_height=400, plot_width=400, x_range=Range1d(0, 1), y_range=Range1d(0, 1), min_border=0)
plot.add_glyph(source, Circle(x='x', y='y', size=20))
plot.add_tools(CustomAction(callback=CustomJS(args=dict(s=source), code=RECORD("data", "s.data"))))
slider = Slider(start=0, end=10, value=1, title="bar", css_classes=["foo"], width=300)
def cb(attr, old, new):
source.data['val'] = [old, new]
slider.on_change('value', cb)
doc.add_root(column(slider, plot))
def modify_doc(doc):
x = np.linspace(0, 10, 1000)
y = np.log(x) * np.sin(x)
source = ColumnDataSource(data=dict(x=x, y=y))
plot = figure(title="Simple plot with slider")
plot.line('x', 'y', source=source)
slider = Slider(start=1, end=10, value=1, step=0.1)
def callback(attr, old, new):
y = np.log(x) * np.sin(x*new)
source.data = dict(x=x, y=y)
slider.on_change('value', callback)
doc.add_root(row(widgetbox(slider), plot))
def modify_doc(doc):
df = sea_surface_temperature.copy()
source = ColumnDataSource(data=df)
plot = figure(x_axis_type='datetime', y_range=(0, 25), y_axis_label='Temperature (Celsius)',
title="Sea Surface Temperature at 43.18, -70.43")
plot.line('time', 'temperature', source=source)
def callback(attr, old, new):
if new == 0:
data = df
else:
data = df.rolling('{0}D'.format(new)).mean()
source.data = ColumnDataSource(data=data).data
slider = Slider(start=0, end=30, value=0, step=1, title="Smoothing by N Days")
slider.on_change('value', callback)
doc.add_root(column(slider, plot))
doc.theme = Theme(filename="theme.yaml")
def modify_doc(doc):
data_url = "http://www.neracoos.org/erddap/tabledap/B01_sbe37_all.csvp?time,temperature&depth=1&temperature_qc=0&time>=2016-02-15&time<=2017-03-22"
df = pd.read_csv(data_url, parse_dates=True, index_col=0)
df = df.rename(columns={'temperature (celsius)': 'temperature'})
df.index.name = 'time'
source = ColumnDataSource(data=df)
plot = figure(x_axis_type='datetime', y_range=(0, 25), y_axis_label='Temperature (Celsius)',
title="Sea Surface Temperature at 43.18, -70.43")
plot.line('time', 'temperature', source=source)
def callback(attr, old, new):
if new == 0:
data = df
else:
data = df.rolling('{0}D'.format(new)).mean()
source.data = ColumnDataSource(data=data).data
slider = Slider(start=0, end=30, value=0, step=1, title="Smoothing by N Days")
slider.on_change('value', callback)
doc.add_root(column(slider, plot))
doc.theme = Theme(json=yaml.load("""
attrs:
Figure:
background_fill_color: "#DDDDDD"
outline_line_color: white
toolbar_location: above
height: 500
width: 800
Grid:
grid_line_dash: [6, 4]
grid_line_color: white
"""))
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 = 560
self.fig.plot_width = 800
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 label layer
self.label_source = WMTSTileSource(url=self.model.labels_url)
self.label_renderer = TileRenderer(tile_source=self.label_source)
self.fig.renderers.append(self.label_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)
image_opacity_slider = Slider(title="Opacity", value=100, start=0,
end=100, step=1)
image_opacity_slider.on_change('value', self.on_image_opacity_slider_change)
basemap_opacity_slider = Slider(title="Basemap Opacity", value=100, start=0,
end=100, step=1)
basemap_opacity_slider.on_change('value', self.on_basemap_opacity_slider_change)
show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0])
show_labels_chk.on_click(self.on_labels_change)
controls = [axes_select, field_select, aggregate_select,
transfer_select]
map_controls = [basemap_select, basemap_opacity_slider,
image_opacity_slider, show_labels_chk]
self.controls = VBox(width=200, height=600, children=controls)
self.map_controls = HBox(width=self.fig.plot_width, children=map_controls)
self.map_area = VBox(width=self.fig.plot_width, children=[self.map_controls, self.fig])
self.layout = HBox(width=1024, children=[self.controls, self.map_area])
w, h = image.shape
source = ColumnDataSource(data=dict(image=[image]))
p = figure(x_range=(0, w), y_range=(0, h))
p.image('image', x=0, y=0, dw=w, dh=h, palette=gray(256), source=source)
@njit
def blur(outimage, image, amt):
for i in range(amt, w - amt):
for j in range(amt, h - amt):
px = 0.
for iw in range(-amt // 2, amt // 2):
for jh in range(-amt // 2, amt // 2):
px += image[i + iw, j + jh]
outimage[i, j] = px / (amt * amt)
def update(attr, old, new):
out = image.copy()
blur(out, image, 2 * new + 1)
source.data.update(image=[out])
slider = Slider(title="Blur Factor", start=0, end=10, value=0)
slider.on_change('value', update)
curdoc().add_root(column(p, slider))
curdoc().title = "Image Blur"
predictors=cluster_fields,
cluster_column=cfc)
df_rfm, clf, clf_tree, c_acc = res_set
# now update only cluster column
cds.data[cfc] = np.array(df_rfm[cfc])
update_texts(text1, text2, c_acc, nr_sample, c_clust, clf.inertia_)
update_png('tree.png')
print("Done from cluster:{} to cluster:{}".format(old, new))
# Attach the callback to the 'value' property of slider
slider.on_change('value', update_plot)
slider_tree = Slider(start=2,
end=4,
step=1,
value=nr_tree_lvl,
title='Numarul de nivele arbore:',
width=200)
def update_tree_lvl(attr, old, new):
nr_tree_lvl = new
train_tree(df_rfm,
predictors=origin_fields,
label_column=cfc,
nr_lvl=nr_tree_lvl)
class Collimator(object):
""" Manage the Orientation of a Nano
"""
#__slots__ = [''] # add legal instance variables
# (setq properties `("" ""))
brre = re.compile(r'\n') # used to convert newline to <br/>
def __init__(self,
flexname: str = "Default",
name: str = "Collimator",
display=fakedisplay,
position: str = "0.0",
maxrange: float = 1.5,
width: int = 200): # Collimator::__init__()
"""Initialize this class."""
#super().__init__()
# (wg-python-property-variables)
self.flexname = flexname
self.name = name
self.display = display
self.wwidth = width
self.position = float(position)
self.speed = 0.10
self.maxrange = float(maxrange)
self.direction = 1
self.homestate = 0
self.spacer = Spacer(width=self.wwidth, height=5,
background='black') #None #
self.collimator = Slider(title=f"Collimator Position",
bar_color='firebrick',
value=self.position,
start=0,
end=self.maxrange,
step=0.01,
format="0.000f",
width=self.wwidth)
self.collimatorspeed = Slider(title=f"Collimator Speed",
bar_color='firebrick',
value=self.speed,
start=0,
end=1,
step=.01,
width=self.wwidth)
self.stepin = Button(label="Step In",
disabled=False,
button_type="warning",
width=self.wwidth // 2)
self.stepout = Button(label="Step Out",
disabled=False,
button_type="warning",
width=self.wwidth // 2)
self.homebutton = Button(label="Home",
disabled=False,
button_type="danger",
width=self.wwidth)
self.collimator.on_change(
'value',
lambda attr, old, new: self.update_collimator(attr, old, new))
self.collimatorspeed.on_change(
'value', lambda attr, old, new: self.update_speed(attr, old, new))
self.stepin.on_click(lambda: self.update_stepin())
self.stepout.on_click(lambda: self.update_stepout())
self.homebutton.on_click(lambda: self.update_homebutton())
### Collimator.__init__()
def debug(self, msg="", skip=[], os=sys.stderr): # Collimator::debug()
"""Help with momentary debugging, file to fit.
msg -- special tag for this call
skip -- the member variables to ignore
os -- output stream: may be IOStream etc.
"""
import pprint
print("Collimator - %s " % msg, file=os)
for key, value in self.__dict__.items():
if (key in skip):
continue
print(f'{key:20s} =', file=os, end='')
pprint.pprint(value, stream=os, indent=4)
return self
### Collimator.debug()
def update_collimator(self, attr, old,
new): # Collimator::update_collimator()
"""Update the parallactic angle. Disabled in interface"""
self.position = float(new)
### Collimator.update_collimator()
def update_speed(self, attr, old, new): # Collimator::update_speed()
"""Update the parallactic angle. Disabled in interface"""
self.speed = float(new)
### Collimator.update_speed()
def update_stepin(self): # Collimator::update_stepin()
"""Update the parallactic angle. Disabled in interface"""
self.direction = 0
newposition = self.position - (self.speed * self.collimator.step)
if (newposition >= 0):
self.position = newposition
self.collimator.value = newposition
self.send_state()
### Collimator.update_stepin()
def update_stepout(self): # Collimator::update_stepout()
"""Update the parallactic angle. Disabled in interface"""
self.direction = 1
newposition = self.position + (self.speed * self.collimator.step)
if (newposition < self.maxrange):
self.position = newposition
self.collimator.value = newposition
self.send_state()
### Collimator.update_stepout()
def update_homebutton(self): # Collimator::update_homebutton()
"""Send a home command"""
self.send_home()
### Collimator.update_homebutton()
def send_home(self): # Collimator::send_home()
"""Send a Home Command"""
self.home = 1
self.send_state()
self.homestate = 0
### Collimator.send_home()
def send_state(self): # Collimator::send_state()
"""Several ways to send things"""
devstate = dict([("position", f"{self.position:7.4f}"),
("direction", int(self.direction)),
("speed", self.speed), ("home", self.homestate)])
slitcmd = dict([("Process", devstate), ("Receipt", 0)])
slitcmd['Receipt'] = 1 # set the receipt as desired
d2 = dict([(f"{self.name}", slitcmd)])
d3 = dict([(f"{self.flexname}", d2)])
jdict = json.dumps(d3)
self.display.display(f'{jdict}')
### Collimator.send_state()
def layout(self): # Collimator::layout()
"""Create the layout"""
return (row(
column(self.collimator, self.collimatorspeed,
row(self.stepin, self.stepout), self.homebutton)))
source_overlay = ColumnDataSource(data=dict(x=[], y=[], y_neg=[], y_pos=[]))
# initialize properties
update_is_enabled = True
# initialize controls
# dropdown menu for sample functions
function_type = Dropdown(label="choose a sample function pair or enter one below",
menu=convolution_settings.sample_function_names)
function_type.on_click(function_pair_input_change)
# slider controlling the evaluated x value of the convolved function
x_value_input = Slider(title="x value", name='x value', value=convolution_settings.x_value_init,
start=convolution_settings.x_value_min, end=convolution_settings.x_value_max,
step=convolution_settings.x_value_step)
x_value_input.on_change('value', input_change)
# text input for the first function to be convolved
function1_input = TextInput(value=convolution_settings.function1_input_init, title="my first function:")
function1_input.on_change('value', input_change)
# text input for the second function to be convolved
function2_input = TextInput(value=convolution_settings.function1_input_init, title="my second function:")
function2_input.on_change('value', input_change)
# initialize plot
toolset = "crosshair,pan,reset,resize,save,wheel_zoom"
# Generate a figure container
plot = Figure(plot_height=400, plot_width=400, tools=toolset,
title="Convolution of two functions",
x_range=[convolution_settings.x_min_view, convolution_settings.x_max_view],
y_range=[convolution_settings.y_min_view, convolution_settings.y_max_view])
# 1. europa / świat
opcje = ["Europa", "poza Europa"]
checkbox_button_group = CheckboxButtonGroup(labels=opcje, active=[])
checkbox_button_group.on_change('active', update_x)
# 2. button - najwięcej zgonów
button = Button(label='The highest number of deaths')
button.on_click(deaths)
# 3. slider po liczebności
slider = Slider(start=0,
end=10,
step=1,
value=0,
title='Change the range of the x axis')
slider.on_change('value', x_range)
# 4.select okres
select = Select(title='Choose a period:',
value='latest',
options=[
'latest', '2020-10-01', '2020-09-01', '2020-08-01',
'2020-07-01', '2020-06-01', '2020-05-01', '2020-04-01',
'2020-03-01', '2020-02-01'
])
select.on_change('value', period)
html_1 = """ <h3> Covid incidence in individual countries </h><b><i></>"""
sup_title_1 = Div(text=html_1, width=800)
layout_1 = gridplot([[select], [slider], [plt], [checkbox_button_group],
#
#def on_dist_change(obj, attr, old, new):
# print "Max Node Dist (km)", new
# global max_node_dist_km
# max_node_dist_km = int(new)
#
#select_dist.on_change('value', on_dist_change)
select_dist = Slider(title="Max GDELT Distance to Road (km)",
start=1, end=10, value=5, step=1)
def on_dist_change(obj, attr, old, new):
print "Max Node Dist (km)", new
global max_node_dist_km
max_node_dist_km = int(new)
select_dist.on_change('value', on_dist_change)
##############
##############
# set max aug distance
#select_dist.on_change('value', on_dist_change)
slider_rkm = Slider(title="Control Inference Distance (km)",
start=0, end=10, value=r_km, step=0.5)
def on_rkm_change(obj, attr, old, new):
print "Max Aug Dist (km)", new
global r_km
r_km = new
slider_rkm.on_change('value', on_rkm_change)
bin_width=bin_width,
lat=lat,
lon=lon)
# python callbacks
map_fig.x_range.on_change('start', update_histogram)
map_fig.x_range.on_change('end', update_histogram)
map_fig.y_range.on_change('start', update_histogram)
map_fig.y_range.on_change('end', update_histogram)
map_fig.on_event(events.Tap, move_click_marker)
map_fig.on_event(events.Press, move_click_marker)
select_day.on_change('value', update_models)
select_model.on_change('value', update_file)
select_fxtime.on_change('value', update_data)
# layout the document
lay = column(
row([select_day, select_model, select_fxtime]),
gridplot(
[map_fig],
[tseries_fig, hist_fig],
toolbar_location='left',
), info_div)
doc = curdoc()
doc.add_root(lay)
doc.add_next_tick_callback(partial(_update_models, True))
doc.add_timeout_callback(_update_data, 1000)
doc.title = config.TITLE
doc.template_variables.update({
plot.y_range.end = max(source_cut.data['importance'])
def update_slider(attrname, old, new):
n_samples = int(samples_slider.value)
newdata = get_ends(n_samples)
source_cut.data = dict(newdata.to_dict('list'))
plot.x_range.factors = newdata['aspects'].tolist() # this was missing
plot.y_range.start = min(source_cut.data['importance'])
plot.y_range.end = max(source_cut.data['importance'])
data_table = DataTable(source=source_cut, columns=columns, width=700, height=500)
dataset_select.on_change('value', update_dataset)
exponent_slider.on_change('value', update_dataset)
ratings_box.on_change('value', update_dataset)
samples_slider.on_change('value', update_slider)
# Set up layout
selects = row(dataset_select)
inputs = column(selects, widgetbox(exponent_slider, ratings_box, samples_slider))
table = widgetbox(data_table)
tab1 = Panel(child=table, title="Data")
tab2 = Panel(child=plot, title="Bar Plot")
tabs = Tabs(tabs=[tab1, tab2])
lay = layout([[inputs,tabs],])
# Add to document
curdoc().add_root(lay)
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,
lod_threshold=None,
plot_width=self.model.plot_width,
plot_height=self.model.plot_height,
background_fill_color='black',
y_range=self.y_range)
self.fig.min_border_top = 0
self.fig.min_border_bottom = 10
self.fig.min_border_left = 0
self.fig.min_border_right = 0
self.fig.axis.visible = False
self.fig.xgrid.grid_line_color = None
self.fig.ygrid.grid_line_color = None
# 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 label layer
self.label_source = WMTSTileSource(url=self.model.labels_url)
self.label_renderer = TileRenderer(tile_source=self.label_source)
self.fig.renderers.append(self.label_renderer)
# Add placeholder for legends (temporarily disabled)
# self.model.legend_side_vbox = VBox()
# self.model.legend_bottom_vbox = VBox()
# add ui components
controls = []
axes_select = Select(name='Axes', options=list(self.model.axes.keys()))
axes_select.on_change('value', self.on_axes_change)
controls.append(axes_select)
self.field_select = Select(name='Field',
options=list(self.model.fields.keys()))
self.field_select.on_change('value', self.on_field_change)
controls.append(self.field_select)
self.aggregate_select = Select(
name='Aggregate',
options=list(self.model.aggregate_functions.keys()))
self.aggregate_select.on_change('value', self.on_aggregate_change)
controls.append(self.aggregate_select)
transfer_select = Select(name='Transfer Function',
options=list(
self.model.transfer_functions.keys()))
transfer_select.on_change('value', self.on_transfer_function_change)
controls.append(transfer_select)
color_ramp_select = Select(name='Color Ramp',
options=list(self.model.color_ramps.keys()))
color_ramp_select.on_change('value', self.on_color_ramp_change)
controls.append(color_ramp_select)
spread_size_slider = Slider(title="Spread Size (px)",
value=0,
start=0,
end=10,
step=1)
spread_size_slider.on_change('value', self.on_spread_size_change)
controls.append(spread_size_slider)
hover_size_slider = Slider(title="Hover Size (px)",
value=8,
start=4,
end=30,
step=1)
hover_size_slider.on_change('value', self.on_hover_size_change)
controls.append(hover_size_slider)
# legends (temporarily disabled)
# controls.append(self.model.legend_side_vbox)
# add map components
basemap_select = Select(name='Basemap',
value='Imagery',
options=list(self.model.basemaps.keys()))
basemap_select.on_change('value', self.on_basemap_change)
image_opacity_slider = Slider(title="Opacity",
value=100,
start=0,
end=100,
step=1)
image_opacity_slider.on_change('value',
self.on_image_opacity_slider_change)
basemap_opacity_slider = Slider(title="Basemap Opacity",
value=100,
start=0,
end=100,
step=1)
basemap_opacity_slider.on_change('value',
self.on_basemap_opacity_slider_change)
show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0])
show_labels_chk.on_click(self.on_labels_change)
map_controls = [
basemap_select, basemap_opacity_slider, image_opacity_slider,
show_labels_chk
]
self.controls = VBox(height=600, children=controls)
self.map_controls = HBox(width=self.fig.plot_width,
children=map_controls)
# legends (temporarily disabled)
self.map_area = VBox(width=900,
height=600,
children=[self.map_controls, self.fig])
self.layout = HBox(width=1300,
height=600,
children=[self.controls, self.map_area])
self.model.fig = self.fig
self.model.update_hover()
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 = 560
self.fig.plot_width = 800
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 label layer
self.label_source = WMTSTileSource(url=self.model.labels_url)
self.label_renderer = TileRenderer(tile_source=self.label_source)
self.fig.renderers.append(self.label_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)
image_opacity_slider = Slider(title="Opacity",
value=100,
start=0,
end=100,
step=1)
image_opacity_slider.on_change('value',
self.on_image_opacity_slider_change)
basemap_opacity_slider = Slider(title="Basemap Opacity",
value=100,
start=0,
end=100,
step=1)
basemap_opacity_slider.on_change('value',
self.on_basemap_opacity_slider_change)
show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0])
show_labels_chk.on_click(self.on_labels_change)
controls = [
axes_select, field_select, aggregate_select, transfer_select
]
map_controls = [
basemap_select, basemap_opacity_slider, image_opacity_slider,
show_labels_chk
]
self.controls = VBox(width=200, height=600, children=controls)
self.map_controls = HBox(width=self.fig.plot_width,
children=map_controls)
self.map_area = VBox(width=self.fig.plot_width,
children=[self.map_controls, self.fig])
self.layout = HBox(width=1024, children=[self.controls, self.map_area])
class Distribution(object):
def __init__(
self,
name,
xmin,
xmax,
mu,
sigma,
pdf,
gp_callback,
throttle,
):
# Store
self.pdf = pdf
self.gp_callback = gp_callback
# Arrays
x = np.linspace(xmin, xmax, 300)
y = self.pdf(x, mu["value"], sigma["value"])
self.source = ColumnDataSource(data=dict(x=x, y=y))
# Plot them
dx = (xmax - xmin) * 0.01
self.plot = figure(
plot_width=400,
plot_height=400,
sizing_mode="stretch_height",
toolbar_location=None,
x_range=(xmin - dx, xmax + dx),
title="{} distribution".format(name),
)
self.plot.title.align = "center"
self.plot.title.text_font_size = "14pt"
self.plot.line("x",
"y",
source=self.source,
line_width=3,
line_alpha=0.6)
self.plot.xaxis.axis_label = name
self.plot.xaxis.axis_label_text_font_style = "normal"
self.plot.xaxis.axis_label_text_font_size = "12pt"
self.plot.yaxis[0].formatter = FuncTickFormatter(code="return ' ';")
self.plot.yaxis.axis_label = "probability"
self.plot.yaxis.axis_label_text_font_style = "normal"
self.plot.yaxis.axis_label_text_font_size = "12pt"
self.plot.outline_line_width = 1
self.plot.outline_line_alpha = 1
self.plot.outline_line_color = "black"
# Sliders
self.slider_mu = Slider(
start=mu["start"],
end=mu["stop"],
step=mu["step"],
value=mu["value"],
orientation="vertical",
format="0.3f",
css_classes=["custom-slider"],
callback_policy="throttle",
callback_throttle=throttle,
)
self.slider_mu.on_change("value_throttled", self.callback)
self.slider_sigma = Slider(
start=sigma["start"],
end=sigma["stop"],
step=sigma["step"],
value=sigma["value"],
orientation="vertical",
format="0.3f",
css_classes=["custom-slider"],
name="sigma",
callback_policy="throttle",
callback_throttle=throttle,
)
self.slider_sigma.on_change("value_throttled", self.callback)
# Show mean and std. dev.
self.mean_vline = Span(
location=self.slider_mu.value,
dimension="height",
line_color="black",
line_width=1,
line_dash="dashed",
)
self.std_vline1 = Span(
location=self.slider_mu.value - self.slider_sigma.value,
dimension="height",
line_color="black",
line_width=1,
line_dash="dotted",
)
self.std_vline2 = Span(
location=self.slider_mu.value + self.slider_sigma.value,
dimension="height",
line_color="black",
line_width=1,
line_dash="dotted",
)
self.plot.renderers.extend(
[self.mean_vline, self.std_vline1, self.std_vline2])
# Full layout
self.layout = row(
self.plot,
column(svg_mu(), self.slider_mu, margin=(10, 10, 10, 10)),
column(svg_sigma(), self.slider_sigma, margin=(10, 10, 10, 10)),
)
def callback(self, attr, old, new):
try:
# Update the distribution
self.source.data["y"] = self.pdf(
self.source.data["x"],
self.slider_mu.value,
self.slider_sigma.value,
)
self.slider_mu.bar_color = "white"
self.slider_sigma.bar_color = "white"
self.plot.background_fill_color = "white"
self.plot.background_fill_alpha = 1
# Update the mean and std. dev. lines
self.mean_vline.location = self.slider_mu.value
self.std_vline1.location = (self.slider_mu.value -
self.slider_sigma.value)
self.std_vline2.location = (self.slider_mu.value +
self.slider_sigma.value)
except AssertionError as e:
# A param is out of bounds!
if "std" in str(e):
self.slider_sigma.bar_color = "firebrick"
elif "mean" in str(e):
self.slider_mu.bar_color = "firebrick"
else:
self.slider_sigma.bar_color = "firebrick"
self.slider_mu.bar_color = "firebrick"
self.plot.background_fill_color = "firebrick"
self.plot.background_fill_alpha = 0.2
finally:
try:
# Update the GP samples
self.gp_callback(attr, old, new)
except AssertionError as e:
pass
def fun_change(attrname, old, new):
f_str = f_input.value
f_fun, f_sym = string_to_function_parser(f_str, ['x'])
print der.value
df_sym = diff(f_sym, 'x', int(der.value))
df_fun = sym_to_function_parser(df_sym,['x'])
x = np.linspace(-5, 5, 100)
y = f_fun(x)
dy = df_fun(x)
line_source.data = dict(x=x, y=y, dy=dy)
def init_data():
fun_change(None,None,None)
# Plotting
plot = Figure(title="function plotter",
x_range=[-5,5],
y_range=[-5,5])
plot.line(x='x', y='y', source=line_source, color='red', legend='f(x)')
plot.line(x='x', y='dy', source=line_source, color='blue', legend='df^n(x)')
#Callback
f_input.on_change('value', fun_change)
derivative_input.on_change('value', fun_change)
init_data()
#Layout
curdoc().add_root(row(plot,column(f_input,derivative_input)))
# initialize data source
plot_data_num = ColumnDataSource(data=dict(x=[], u=[]))
plot_data_ana = ColumnDataSource(data=dict(x=[], u=[]))
mesh_data = ColumnDataSource(data=dict())
pde_specs = ColumnDataSource(data=dict(h=[], k=[]))
ana_sol = ColumnDataSource(data=dict())
# initialize controls
# slider for going though time
time_slider = Slider(title="time",
name='time',
value=pde_settings.t_init,
start=pde_settings.t_min,
end=pde_settings.t_max,
step=pde_settings.t_step)
time_slider.on_change('value', time_change)
# slider controlling spatial stepsize of the solver
h_slider = Slider(title="spatial meshwidth",
name='spatial meshwidth',
value=pde_settings.h_init,
start=pde_settings.h_min,
end=pde_settings.h_max,
step=pde_settings.h_step)
h_slider.on_change('value', mesh_change)
# slider controlling spatial stepsize of the solver
k_slider = Slider(title="temporal meshwidth",
name='temporal meshwidth',
value=pde_settings.k_init,
start=pde_settings.k_min,
end=pde_settings.k_max,
step=pde_settings.k_step)
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,
lod_threshold=None,
plot_width=self.model.plot_width,
plot_height=self.model.plot_height,
background_fill_color="black",
y_range=self.y_range,
)
self.fig.min_border_top = 0
self.fig.min_border_bottom = 10
self.fig.min_border_left = 0
self.fig.min_border_right = 0
self.fig.axis.visible = False
self.fig.xgrid.grid_line_color = None
self.fig.ygrid.grid_line_color = None
# 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 label layer
self.label_source = WMTSTileSource(url=self.model.labels_url)
self.label_renderer = TileRenderer(tile_source=self.label_source)
self.fig.renderers.append(self.label_renderer)
# Add placeholder for legends (temporarily disabled)
# self.model.legend_side_vbox = VBox()
# self.model.legend_bottom_vbox = VBox()
# add ui components
controls = []
axes_select = Select.create(name="Axes", options=self.model.axes)
axes_select.on_change("value", self.on_axes_change)
controls.append(axes_select)
self.field_select = Select.create(name="Field", options=self.model.fields)
self.field_select.on_change("value", self.on_field_change)
controls.append(self.field_select)
self.aggregate_select = Select.create(name="Aggregate", options=self.model.aggregate_functions)
self.aggregate_select.on_change("value", self.on_aggregate_change)
controls.append(self.aggregate_select)
transfer_select = Select.create(name="Transfer Function", options=self.model.transfer_functions)
transfer_select.on_change("value", self.on_transfer_function_change)
controls.append(transfer_select)
color_ramp_select = Select.create(name="Color Ramp", options=self.model.color_ramps)
color_ramp_select.on_change("value", self.on_color_ramp_change)
controls.append(color_ramp_select)
spread_size_slider = Slider(title="Spread Size (px)", value=0, start=0, end=10, step=1)
spread_size_slider.on_change("value", self.on_spread_size_change)
controls.append(spread_size_slider)
hover_size_slider = Slider(title="Hover Size (px)", value=8, start=4, end=30, step=1)
hover_size_slider.on_change("value", self.on_hover_size_change)
controls.append(hover_size_slider)
# legends (temporarily disabled)
# controls.append(self.model.legend_side_vbox)
# add map components
basemap_select = Select.create(name="Basemap", value="Imagery", options=self.model.basemaps)
basemap_select.on_change("value", self.on_basemap_change)
image_opacity_slider = Slider(title="Opacity", value=100, start=0, end=100, step=1)
image_opacity_slider.on_change("value", self.on_image_opacity_slider_change)
basemap_opacity_slider = Slider(title="Basemap Opacity", value=100, start=0, end=100, step=1)
basemap_opacity_slider.on_change("value", self.on_basemap_opacity_slider_change)
show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0])
show_labels_chk.on_click(self.on_labels_change)
map_controls = [basemap_select, basemap_opacity_slider, image_opacity_slider, show_labels_chk]
self.controls = VBox(height=600, children=controls)
self.map_controls = HBox(width=self.fig.plot_width, children=map_controls)
# legends (temporarily disabled)
self.map_area = VBox(width=900, height=600, children=[self.map_controls, self.fig])
self.layout = HBox(width=1300, height=600, children=[self.controls, self.map_area])
self.model.fig = self.fig
self.model.update_hover()
]
p.add_layout(legend)
def update():
try:
expr = sy.sympify(text.value, dict(x=xs))
except Exception as exception:
errbox.text = str(exception)
else:
errbox.text = ""
x, fy, ty = taylor(expr, xs, slider.value, (-2*sy.pi, 2*sy.pi), 200)
p.title.text = "Taylor (n=%d) expansion comparison for: %s" % (slider.value, expr)
legend.items[0].label = value("%s" % expr)
legend.items[1].label = value("taylor(%s)" % expr)
source.data = dict(x=x, fy=fy, ty=ty)
slider = Slider(start=1, end=20, value=1, step=1, title="Order")
slider.on_change('value', lambda attr, old, new: update())
text = TextInput(value=str(expr), title="Expression:")
text.on_change('value', lambda attr, old, new: update())
errbox = PreText()
update()
inputs = column(text, slider, errbox, width=400)
curdoc().add_root(column(inputs, p))
height="height",
fill_color="LightSeaGreen"))
centroids = kmeans_viz.add_glyph(
source, Circle(x="longitude", y="latitude", size=10, fill_alpha=1))
hover = kmeans_viz.select_one(HoverTool)
hover.point_policy = "follow_mouse"
hover.tooltips = [
("Count", "@count"),
("(Long, Lat)", "($x.2, $y.2)"),
("Width", "@width"),
("Height", "@height"),
]
iter_slider = Slider(start=0,
end=len(cluster_hist) - 5,
value=0,
step=1,
title="Iteration")
def update(attr, old, new):
clusters.data_source.data = cluster_hist[str(iter_slider.value)]
centroids.data_source.data = cluster_hist[str(iter_slider.value)]
iter_slider.on_change("value", update)
# output_file("sample_clusters_visualization.html", title='K-Means Visualization', mode='inline')
show(layout([[kmeans_viz, iter_slider]]))
curdoc().add_root(layout([[kmeans_viz, iter_slider]]))
other_source.data = gen_dict(other)
else:
other_source.data = empty_dict
if 1 in button_group.active:
speed_source.data = gen_dict(speed)
else:
speed_source.data = empty_dict
if 2 in button_group.active:
drunk_source.data = gen_dict(drunk)
else:
drunk_source.data = empty_dict
slider.on_change('value', update_hour)
toggle.on_change('active', update_hour)
button_group.on_change('active', update_hour)
callback = CustomJS(args=dict(other=other_circles, speed=speed_circles, drunk=drunk_circles), code="""
other.glyph.radius = { value: cb_obj.get('value')*125 }
other.data_source.trigger('change')
speed.glyph.radius = { value: cb_obj.get('value')*125 }
speed.data_source.trigger('change')
drunk.glyph.radius = { value: cb_obj.get('value')*125 }
drunk.data_source.trigger('change')
""")
size_slider = Slider(title="Dot Size", start=1, end=100, orientation="horizontal",
def gapminder_plot_bokeh(datos_e,
datos_pca,
year_i,
X_data_df,
grad_per,
etiquetas_glo,
periodos_incluir,
k,
imp_periods_var,
centroids_ite,
scaler_es,
title='Titulo',
xlabel='Eje x',
ylabel='Eje y'):
### Lista years
years_plot = []
for o in periodos_incluir:
years_plot.append(o)
### Dataframes necesarias
pca1 = pd.DataFrame(columns=years_plot)
pca2 = pd.DataFrame(columns=years_plot)
### PCA de cada year
for year in years_plot:
filtro = datos_e['periodo'] == year
### Los que usare para el PCA seran
X_data_pca_y = np.array(datos_pca[filtro])
pca1[year] = X_data_pca_y[:, 0]
pca2[year] = X_data_pca_y[:, 1]
### Nombres de los individuos
pca1.index = X_data_df.cliente
pca2.index = X_data_df.cliente
### Grados de pertenencia
grados_pert = pd.DataFrame(columns=years_plot)
##### Grados de pertenencia de cada year
coun = 0
for year in years_plot:
grados_pert[year] = np.max(
grad_per[coun],
axis=1) * 40 ### Aumento escala para que se vean bien
coun = coun + 1
grados_pert.index = X_data_df.cliente
##### Cluster al que pertenece cada dato en cada periodo de tiempo
etiqs_plot = []
couu = 0
for year in years_plot:
eti = pd.DataFrame()
eti['region'] = [str(i)[0] for i in list(etiquetas_glo[couu])
] ### Solo 1 caracter
eti.index = X_data_df.cliente
etiqs_plot.append(eti)
couu = couu + 1
##### Regions_list son los id de los cluster
regions_list = []
for cu in range(k):
regions_list.append(str(cu))
### fertility df seria componente principal 1
### life expectancy df seria componente principal 2
### population_df_size es el maximo grado de pertenencia
### regions_df es el cluster id al que se asigno cada uno
### years es la lista de years a modelar
### regions list seria el "nombre " de cada cluster (top variables mas importantes)
### Consolidar data
df = pd.concat(
{
'Componente_1': pca1,
'Componente_2': pca2,
'Grado_Pertenencia': grados_pert
},
axis=1)
### Construir data
data = {}
counta = 0
for year in years_plot:
df_year = df.iloc[:, df.columns.get_level_values(1) == year]
df_year.columns = df_year.columns.droplevel(1)
data[year] = df_year.join(
etiqs_plot[counta].region).reset_index().to_dict('series')
counta = counta + 1
source = ColumnDataSource(data=data[years_plot[0]])
############### Para las labels ########################
#### Numero de variables a plotear
num_v_plot = 4
#### Nombres variables
nomb_v = datos_e.columns[2:]
#### Desestandarizar centroides
centroids_ito = scaler_es.inverse_transform(centroids_ite)
#### Consolidar strings de las legends de cada iteracion
strings_legends = []
c = 0
for y in years_plot:
esta_iter = []
estas_imp = imp_periods_var[c]
cc = 0
for clu in estas_imp:
### Variables mas importantes
orden_v = np.argsort(clu)[::-1][:num_v_plot]
### Construir string
stri = ''
### Numero observaciones cluster
stri = stri + 'Num_obs: ' + str(
len(np.where(etiquetas_glo[c] == cc)[0])) + ', '
### Variables importantes
for i in orden_v:
stri = stri + nomb_v[i][:12] + ': ' + str(
np.around(centroids_ito[c][cc][i], 2)) + ', '
stri = stri[:-2]
esta_iter.append(stri)
cc = cc + 1
strings_legends.append(esta_iter)
c = c + 1
#### PLoteos
global plot
plot = figure(title=title,
y_range=(-5, 7),
plot_height=520,
plot_width=900)
plot.xaxis.ticker = SingleIntervalTicker(interval=1)
plot.xaxis.axis_label = xlabel
plot.yaxis.ticker = SingleIntervalTicker(interval=20)
plot.yaxis.axis_label = ylabel
label = Label(x=1.1,
y=18,
text=str(years_plot[0]),
text_font_size='70pt',
text_color='#eeeeee')
plot.add_layout(label)
color_mapper = CategoricalColorMapper(palette=Spectral6,
factors=regions_list)
global r
r = plot.circle(
x='Componente_1',
y='Componente_2',
size='Grado_Pertenencia',
source=source,
fill_color={
'field': 'region',
'transform': color_mapper
},
fill_alpha=0.8,
line_color='#7c7e71',
line_width=0.5,
line_alpha=0.5,
# legend_group='region',
)
from bokeh.models import Legend, LegendItem
global legend
items_son = []
co = 0
for a in strings_legends[0]:
color_ = list(etiquetas_glo[0]).index(co)
items_son.append(LegendItem(label=a, renderers=[r], index=color_))
co = co + 1
legend = Legend(items=items_son)
plot.add_layout(legend)
plot.add_tools(
HoverTool(tooltips="@cliente",
show_arrow=False,
point_policy='follow_mouse'))
def animate_update():
global plot
posi = (int(slider.value) + 1) % len(
years_plot) ### En este ejemplo, q no pase de 12
year = years_plot[posi]
plot.title.text = str(year)[:].replace('.', '-Q')
if year > years_plot[-1]:
year = years_plot[0]
slider.value = posi
def slider_update(attrname, old, new):
year = years_plot[int(slider.value)]
label.text = str(year)
source.data = data[year]
pos = years_plot.index(year)
global legend
global r
global plot
plot.title.text = str(year)[:].replace('.', '-Q')
items_son = []
bo = 0
for a in strings_legends[pos]:
color_ = list(etiquetas_glo[pos]).index(bo)
items_son.append(LegendItem(label=a, renderers=[r], index=color_))
bo = bo + 1
legend.items = items_son
plot.add_layout(legend)
slider = Slider(start=0, end=11, value=0, step=1, title="periodo")
slider.on_change('value', slider_update)
callback_id = None
def animate():
global callback_id
if button.label == '► Play':
button.label = '❚❚ Pause'
callback_id = curdoc().add_periodic_callback(animate_update, 1000)
else:
button.label = '► Play'
curdoc().remove_periodic_callback(callback_id)
button = Button(label='► Play', width=60)
button.on_click(animate)
layout_plot = layout([
[plot],
[slider, button],
])
curdoc().add_root(layout_plot)
curdoc().title = "Transactional"
return None
source=source,
line_width=3,
line_alpha=0.6)
ticker = SingleIntervalTicker(interval=1, num_minor_ticks=0)
xaxis = LinearAxis(ticker=ticker, axis_label='y index')
plot.add_layout(xaxis, 'below')
samples_slider = Slider(start=3,
end=20,
value=10,
step=1,
title="Number of points")
given_slider = Slider(start=0,
end=1,
value=.1,
step=.1,
title="% of given points")
theta1_slider = Slider(start=0.01, end=1, value=.12, step=.01, title="Theta_1")
resample_Button = Button(label="Resample unknowns")
samples_slider.on_change('value', lambda attr, old, new: new_givens())
given_slider.on_change('value', lambda attr, old, new: given_wrapper(old, new))
theta1_slider.on_change('value', lambda attr, old, new: resample_wrapper())
resample_Button.on_click(lambda: resample_wrapper())
controls = [samples_slider, given_slider, theta1_slider, resample_Button]
inputs = widgetbox(*controls, sizing_mode='fixed')
l = gridplot([[inputs], [plot]])
resample_wrapper()
curdoc().add_root(l)
def fun_change(attrname, old, new):
f_str = f_input.value
f_fun, f_sym = string_to_function_parser(f_str, ['x'])
print(derivative_input.value)
df_sym = diff(f_sym, 'x', int(derivative_input.value))
df_fun = sym_to_function_parser(df_sym, ['x'])
x = np.linspace(-5, 5, 100)
y = f_fun(x)
dy = df_fun(x)
line_source.data = dict(x=x, y=y, dy=dy)
def init_data():
fun_change(None, None, None)
# Plotting
plot = Figure(title="function plotter", x_range=[-5, 5], y_range=[-5, 5])
plot.line(x='x', y='y', source=line_source, color='red', legend='f(x)')
plot.line(x='x', y='dy', source=line_source, color='blue', legend='df^n(x)')
#Callback
f_input.on_change('value', fun_change)
derivative_input.on_change('value', fun_change)
init_data()
#Layout
curdoc().add_root(row(plot, column(f_input, derivative_input)))
def produce_scatter_on_background(self, context, doc):
# Interesting error, background doesn't seem to update after running multiple instances
# to the latest version and starts off with the data the first instance was given.
# Need to figure out why!
# Port to connect to master
port = 5000
#socket = context.socket(zmq.SUB)
socket = context.socket(zmq.REQ)
# MUST BE FROM SAME MACHINE, CHANGE IF NECESSARY!!!
socket.connect("tcp://localhost:%d" % port)
#socket.setsockopt(zmq.SUBSCRIBE, b"")
# Dynamic Map
dmapBackground = hv.DynamicMap(gen_background, streams=[self.streamContour])
dmapScatter = hv.DynamicMap(gen_scatter, streams=[self.streamScatter])
overlay = (dmapBackground*dmapScatter).options(show_legend=False).opts(norm=dict(axiswise=True))
# Render plot with bokeh
hvplot = renderer.get_plot(overlay, doc)
def scatter_tick():
"""
Push new scatter points into stream to plot.
"""
# Still has the freezing points error, though, it seems to come more frequently.
# This may be a bigger problem now
#if socket.poll(timeout=0):
socket.send_string("Hello")
print("Oof")
data_dict = socket.recv_pyobj()
peakDict = data_dict['peakDict']
peakTSDict = data_dict['peakTSDict']
self.ipm2_plot = list(peakDict['peak_8'])
self.ipm3_plot = list(peakDict['peak_9'])
self.ebeam_plot = list(peakDict['peak_10'])
self.ipm2TS_plot = list(peakTSDict['peak_8_TS'])
self.ipm3TS_plot = list(peakTSDict['peak_9_TS'])
self.ebeamTS_plot = list(peakTSDict['peak_10_TS'])
ipm2Data = pd.Series(self.ipm2_plot[-self.limit:], index=self.ipm2TS_plot[-self.limit:])
ipm3Data = pd.Series(self.ipm3_plot[-self.limit:], index=self.ipm3TS_plot[-self.limit:])
ebeamData = pd.Series(self.ebeam_plot[-self.limit:], index=self.ebeamTS_plot[-self.limit:])
zipped = basic_event_builder(ipm2=ipm2Data, ipm3=ipm3Data, ebeam=ebeamData)
scatterList = zipped
data = scatterList[['ebeam', self.switch_key]]
self.paused_list = scatterList
self.streamScatter.event(df=data)
def limit_update(attr, old, new):
"""
Update limit slider value
"""
self.limit = limitSlider.value
def switch(attr, old, new):
"""
Update drop down menu value
"""
self.switch_key = select.value
def switch_background(attr, old, new):
"""
Switch background when drop down menu value is updated
"""
data = self.curBackData[['ebeam', self.switch_key]]
self.streamContour.event(df=data)
def switch_on_pause(attr, old, new):
if startButton.label == '► Play':
self.streamScatter.event(df=self.paused_list[['ebeam', self.switch_key]])
# Scatter plot may freeze when update background occurs?
def update_background():
"""
Update background with most updated data when update button is pressed
"""
newData = pd.read_csv('data_class.csv', index_col='Unnamed: 0')
self.curBackData = newData
data = newData[['ebeam', self.switch_key]]
self.streamContour.event(df=data)
def play_graph():
"""
Provide play and pause functionality to the graph
"""
if startButton.label == '► Play':
startButton.label = '❚❚ Pause'
self.callback_id_scatter = doc.add_periodic_callback(scatter_tick, 1000)
else:
startButton.label = '► Play'
doc.remove_periodic_callback(self.callback_id_scatter)
# Continuously update scatter plot
self.callback_id_scatter = doc.add_periodic_callback(scatter_tick, 1000)
# Create widgets
limitSlider = Slider(start=10, end=1000, value=50, step=1, title="Number of Events")
limitSlider.on_change('value', limit_update)
startButton = Button(label='❚❚ Pause')
startButton.on_click(play_graph)
select = Select(title="ipm value:", value="ipm2", options=["ipm2", "ipm3"])
select.on_change('value', switch)
select.on_change('value', switch_background)
select.on_change('value', switch_on_pause)
updateButton = Button(label='Update', width=60)
updateButton.on_click(update_background)
plot = layout([[hvplot.state],
widgetbox([limitSlider, select, updateButton, startButton], sizing_mode='stretch_both')])
doc.title = "Reference Graph"
doc.add_root(plot)
def create_interact_ui(doc):
fig_tpf, stretch_slider = self._make_echelle_elements(
dnu,
maximum_frequency=maximum_frequency,
minimum_frequency=minimum_frequency,
**kwargs
)
maxdnu = self.periodogram.frequency.max().value / 5
# Interactive slider widgets
dnu_slider = Slider(
start=0.01,
end=maxdnu,
value=dnu.value,
step=0.01,
title="Delta Nu",
width=290,
)
r_button = Button(label=">", button_type="default", width=30)
l_button = Button(label="<", button_type="default", width=30)
rr_button = Button(label=">>", button_type="default", width=30)
ll_button = Button(label="<<", button_type="default", width=30)
def update(attr, old, new):
"""Callback to take action when dnu slider changes"""
dnu = SeismologyQuantity(
quantity=dnu_slider.value * u.microhertz,
name="deltanu",
method="echelle",
)
ep, _, _ = self._clean_echelle(
deltanu=dnu,
minimum_frequency=minimum_frequency,
maximum_frequency=maximum_frequency,
**kwargs
)
fig_tpf.select("img")[0].data_source.data["image"] = [ep.value]
fig_tpf.xaxis.axis_label = r"Frequency / {:.3f} Mod. 1".format(dnu)
def go_right_by_one_small():
"""Step forward in time by a single cadence"""
existing_value = dnu_slider.value
if existing_value < maxdnu:
dnu_slider.value = existing_value + 0.002
def go_left_by_one_small():
"""Step back in time by a single cadence"""
existing_value = dnu_slider.value
if existing_value > 0:
dnu_slider.value = existing_value - 0.002
def go_right_by_one():
"""Step forward in time by a single cadence"""
existing_value = dnu_slider.value
if existing_value < maxdnu:
dnu_slider.value = existing_value + 0.01
def go_left_by_one():
"""Step back in time by a single cadence"""
existing_value = dnu_slider.value
if existing_value > 0:
dnu_slider.value = existing_value - 0.01
dnu_slider.on_change("value", update)
r_button.on_click(go_right_by_one_small)
l_button.on_click(go_left_by_one_small)
rr_button.on_click(go_right_by_one)
ll_button.on_click(go_left_by_one)
widgets_and_figures = layout(
[fig_tpf, [Spacer(height=20), stretch_slider]],
[
ll_button,
Spacer(width=30),
l_button,
Spacer(width=25),
dnu_slider,
Spacer(width=30),
r_button,
Spacer(width=23),
rr_button,
],
)
doc.add_root(widgets_and_figures)
hour1 = Slider(title="hour", value=0, start=0, end=96, step=1)
# Set up callbacks
def update_title(attrname, old, new):
plot.title.text = text.value
text.on_change('value', update_title)
def update_data(attrname, old, new):
# Get the current slider values
# a = amplitude.value
h = hour1.value
# Generate the new plot
x = hourwise[h]['source']
y = hourwise[h]['number']
source.data = dict(x=x, y=y)
hour1.on_change('value', update_data)
# Set up layouts and add to document
inputs = column(hour1, text)
curdoc().add_root(row(inputs, plot, width=800))
curdoc().title = "Sliders"
source_views.data = new_data_views
# Make a slider object: slider
min_timestamp = min(df_tx['ttimestamp'].min(), df_views['ttimestamp'].min())
max_timestamp = max(df_tx['ttimestamp'].max(), df_views['ttimestamp'].max())
slider_time = Slider(start=0,
end=max_timestamp - min_timestamp,
step=3600,
value=0,
title='Timestamp',
format="{://360}")
# Attach the callback to the 'value' property of slider
slider_time.on_change('value', update_plot_time)
tab1 = Panel(child=p1, title="Map")
p2 = figure(plot_width=500, plot_height=500)
bin_number = (lambda x: 96 * (x - min_timestamp) //
(max_timestamp - min_timestamp))
df_tx['bin'] = df_tx['ttimestamp'].apply(bin_number)
df_tx_binned = df_tx.groupby('bin').count()
p2.line(df_tx_binned.index,
df_tx_binned['ttimestamp'],
legend="transactions",
color="blue")
df_views['bin'] = df_views['ttimestamp'].apply(bin_number)
def update_data(attrname, old, new):
k = gsmooth.value
print("Gaussian filter : ", k)
img = cv2.imread('../../Bokeh/server_folder/static/image1.jpeg')
gaussian = cv2.GaussianBlur(img, (k, k), 0)
os.chdir(directory)
cv2.imwrite('gaussian.jpeg', gaussian)
cv2.imwrite('image1.jpeg', gaussian)
os.chdir(directory1)
img_path = 'server_folder/static/gaussian.jpeg'
url = img_path
source.data = dict(url=[url])
gsmooth.on_change('value', update_data)
########################################################################################################
################################Median Filter###########################################################
def callback1(event):
image = cv2.imread('../../Bokeh/server_folder/static/image1.jpeg')
median = cv2.medianBlur(image, 5)
os.chdir(directory)
cv2.imwrite('median.jpeg', median)
cv2.imwrite('image1.jpeg', median)
os.chdir(directory1)
img_path = 'server_folder/static/median.jpeg'
url = img_path
def create_interact_ui(doc):
# The data source includes metadata for hover-over tooltips
lc_source = prepare_lightcurve_datasource(lc)
tpf_source = prepare_tpf_datasource(tpf, aperture_mask)
# Create the lightcurve figure and its vertical marker
fig_lc, vertical_line = make_lightcurve_figure_elements(lc, lc_source)
# Create the TPF figure and its stretch slider
pedestal = np.nanmin(tpf.flux)
fig_tpf, stretch_slider = make_tpf_figure_elements(tpf,
tpf_source,
pedestal=pedestal)
# Helper lookup table which maps cadence number onto flux array index.
tpf_index_lookup = {cad: idx for idx, cad in enumerate(tpf.cadenceno)}
# Interactive slider widgets and buttons to select the cadence number
cadence_slider = Slider(start=np.min(tpf.cadenceno),
end=np.max(tpf.cadenceno),
value=np.min(tpf.cadenceno),
step=1,
title="Cadence Number",
width=490)
r_button = Button(label=">", button_type="default", width=30)
l_button = Button(label="<", button_type="default", width=30)
export_button = Button(label="Save Lightcurve",
button_type="success",
width=120)
message_on_save = Div(text=' ', width=600, height=15)
# Callbacks
def update_upon_pixel_selection(attr, old, new):
"""Callback to take action when pixels are selected."""
# Check if a selection was "re-clicked", then de-select
if ((sorted(old) == sorted(new)) & (new != [])):
# Trigger recursion
tpf_source.selected.indices = new[1:]
if new != []:
selected_indices = np.array(new)
selected_mask = np.isin(pixel_index_array, selected_indices)
lc_new = tpf.to_lightcurve(aperture_mask=selected_mask)
lc_source.data['flux'] = lc_new.flux
ylims = get_lightcurve_y_limits(lc_source)
fig_lc.y_range.start = ylims[0]
fig_lc.y_range.end = ylims[1]
else:
lc_source.data['flux'] = lc.flux * 0.0
fig_lc.y_range.start = -1
fig_lc.y_range.end = 1
message_on_save.text = " "
export_button.button_type = "success"
def update_upon_cadence_change(attr, old, new):
"""Callback to take action when cadence slider changes"""
if new in tpf.cadenceno:
frameno = tpf_index_lookup[new]
fig_tpf.select('tpfimg')[0].data_source.data['image'] = \
[tpf.flux[frameno, :, :] - pedestal]
vertical_line.update(location=tpf.time[frameno])
else:
fig_tpf.select('tpfimg')[0].data_source.data['image'] = \
[tpf.flux[0, :, :] * np.NaN]
lc_source.selected.indices = []
def go_right_by_one():
"""Step forward in time by a single cadence"""
existing_value = cadence_slider.value
if existing_value < np.max(tpf.cadenceno):
cadence_slider.value = existing_value + 1
def go_left_by_one():
"""Step back in time by a single cadence"""
existing_value = cadence_slider.value
if existing_value > np.min(tpf.cadenceno):
cadence_slider.value = existing_value - 1
def save_lightcurve():
"""Save the lightcurve as a fits file with mask as HDU extension"""
if tpf_source.selected.indices != []:
selected_indices = np.array(tpf_source.selected.indices)
selected_mask = np.isin(pixel_index_array, selected_indices)
lc_new = tpf.to_lightcurve(aperture_mask=selected_mask)
lc_new.to_fits(exported_filename,
overwrite=True,
aperture_mask=selected_mask.astype(np.int),
SOURCE='lightkurve interact',
NOTE='custom mask',
MASKNPIX=np.nansum(selected_mask))
if message_on_save.text == " ":
text = '<font color="black"><i>Saved file {} </i></font>'
message_on_save.text = text.format(exported_filename)
export_button.button_type = "success"
else:
text = '<font color="gray"><i>Saved file {} </i></font>'
message_on_save.text = text.format(exported_filename)
else:
text = '<font color="gray"><i>No pixels selected, no mask saved</i></font>'
export_button.button_type = "warning"
message_on_save.text = text
def jump_to_lightcurve_position(attr, old, new):
if new != []:
cadence_slider.value = lc.cadenceno[new[0]]
# Map changes to callbacks
r_button.on_click(go_right_by_one)
l_button.on_click(go_left_by_one)
tpf_source.selected.on_change('indices', update_upon_pixel_selection)
lc_source.selected.on_change('indices', jump_to_lightcurve_position)
export_button.on_click(save_lightcurve)
cadence_slider.on_change('value', update_upon_cadence_change)
# Layout all of the plots
sp1, sp2, sp3, sp4 = (Spacer(width=15), Spacer(width=30),
Spacer(width=80), Spacer(width=60))
widgets_and_figures = layout([fig_lc, fig_tpf], [
l_button, sp1, r_button, sp2, cadence_slider, sp3, stretch_slider
], [export_button, sp4, message_on_save])
doc.add_root(widgets_and_figures)
# Création du set de donnée à afficher
displaySet = select_data(dataCities,ogCity,dist)
### Construction du front-end ###
# Ajout d'un slider pour choisir l'année
slider_yr = Slider(title = 'Année',
start = data_yr[0],
end = data_yr[-1],
step = 1,
value = data_yr[-1],
default_size = 250
)
slider_yr.on_change('value', update_yr)
# Ajout d'un slider pour choisir la distance d'affichage
slider_dst = Slider(title = 'Distance d\'affichage (km)',
start = 0,
end = 100,
step = 5,
value = dist,
default_size = 250
)
slider_dst.on_change('value', update_dst)
# Ajout d'un sélecteur pour choisir l'impot à afficher
select_imp = Select(title="Impôt:",
value="Taxe d'habitation",
options=["Taxe d'habitation", "Taxe foncière"]
return b
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def update(attr, old, new):
print(attr, "**", old, "**", new)
layout.children[0].children[0] = create_map()
layout.children[1].children[0] = create_chart()
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# WIDGETS
# Position Control
zoom = Slider(start=10, end=15, value=11, step=1, title="Zoom")
zoom.on_change('value', update)
lat = Slider(start=36,
end=36.24,
value=36.1200,
step=.02,
title="Lat Position")
lat.on_change('value', update)
lon = Slider(start=-115.30,
end=-115.06,
value=-115.18,
step=.02,
title="Lon Position")
lon.on_change('value', update)
# Time Control
days_options = RadioButtonGroup(
def init():
t = slider.value
m = .5
x = np.linspace(0,1)
y = m*x+t
plot_data.data = dict(x=x.tolist(),y=y.tolist())
# initialize data source
plot_data = ColumnDataSource(data=dict(x=[], y=[]))
# initialize controls
slider = Slider(title="a", name='a', value=.5, start=0, end=1,
step=.1)
slider.on_change('value', callback_function)
# initialize plot
toolset = "crosshair,pan,reset,resize,wheel_zoom,box_zoom"
# Generate a figure container
plot = Figure(plot_height=400,
plot_width=400,
tools=toolset,
title="Time dependent PDEs",
x_range=[0,1],
y_range=[0,1]
)
# Plot the numerical solution at time=t by the x,u values in the source property
plot.line('x', 'y', source=plot_data,
line_width=.5,
def gen_bokeh(
df,
il_center=(3879662.3653308493, 3694724.561061665),
marg_x=2.0e5,
marg_y=2.0e5,
init_date=datetime.datetime(year=2021, month=5, day=10),
MAX_W=1000,
MAX_H=800,
):
# main figure with world map
tile_provider = get_provider(CARTODBPOSITRON)
p = figure(x_range=(il_center[0] - marg_x, il_center[0] + marg_x),
y_range=(il_center[1] - marg_y, il_center[1] + marg_y),
x_axis_type="mercator",
y_axis_type="mercator")
p.plot_height = MAX_H // 2
p.plot_width = MAX_W
p.add_tile(tile_provider)
# process df for plotting
df['mydate'] = pd.to_datetime(df['date'])
df = df.loc[df['mydate'] > init_date]
merc = longlat2mercator.transform(df['lat'].values, df['long'].values)
df['x'] = merc[0]
df['y'] = merc[1]
df['name'] = df['location']
df[['x', 'y', 'mydate_f', 'name']] = df[['x', 'y', 'mydate',
'name']].fillna('')
df['fill_alpha'] = .5
df['line_alpha'] = .0
df['fill_color'] = df['eta'].apply(eta2color)
src_cols = [
'x', 'y', 'mydate_f', 'name', 'fill_alpha', 'line_alpha', 'fill_color'
]
source0 = df[src_cols].to_dict('list')
source = ColumnDataSource(data=source0)
# add alarms on map
p.circle(x="x",
y="y",
size=4,
fill_color="fill_color",
fill_alpha='fill_alpha',
line_alpha='line_alpha',
source=source)
p.add_tools(
HoverTool(
tooltips=[
('time', '@mydate_f{%H:%M}'),
('date', '@mydate_f{%d/%m/%Y}'),
('name', '@name'),
],
formatters={'@mydate_f': 'datetime'},
))
# build other elements
date_slider = DateSlider(start=df['mydate'].min(),
end=date.today(),
step=24,
value=date.today(),
title='Date',
width=int(MAX_W * .9))
dur_slider = Slider(start=0,
end=168,
step=1,
value=24,
title='Hour duration',
width=MAX_W // 2)
delay_slider = Slider(start=0,
end=1000,
step=10,
value=200,
title='Animation delay (ms)',
width=MAX_W // 2)
label_xy = longlat2mercator.transform(31., 34)
label_src = ColumnDataSource(data=dict(text=['Hello, use the sliders']))
label = LabelSet(text='text',
x=label_xy[0],
y=label_xy[1],
source=label_src)
p.add_layout(label)
button = Button(label="Play", button_type="success", width=MAX_W // 10)
# add plot for number of alarms per day
ff = figure(x_range=(df['mydate_f'].min(), df['mydate_f'].max()),
x_axis_type="datetime")
df['day'] = df['mydate_f'].dt.day
agg = df.groupby('day').agg('count')
agg['date'] = agg.index.to_series().apply(
lambda x: df.loc[df['mydate_f'].dt.day == x, 'mydate_f'].iloc[0])
ff.scatter(agg['date'], agg['Unnamed: 0'], size=10)
ff.plot_height = MAX_H // 3
ff.plot_width = MAX_W
ff.title = 'alarms per day'
# callback functions
callback_id = None
def update_map_callback(attr, old, new):
st, en = date_slider.value, date_slider.value + dur_slider.value * 60 * 60 * 1000
st = datetime.datetime.fromtimestamp(st / 1000.)
en = datetime.datetime.fromtimestamp(en / 1000.)
ddf = df.loc[(df['mydate_f'] >= st) & (df['mydate_f'] < en)]
source.data = ddf[src_cols].to_dict('list')
sts = st.strftime("%d/%m, %H:%M")
ens = en.strftime("%d/%m, %H:%M")
label_src.data = dict(
text=[f'Range: {sts} to {ens}, total: {len(ddf)}'])
def restart_animation(attr, old, new):
global callback_id
if button.label == 'Stop':
curdoc().remove_periodic_callback(callback_id)
callback_id = curdoc().add_periodic_callback(
adv_slider, delay_slider.value)
def adv_slider():
date_slider.value += 1 * 1000 * 60 * 60
if date_slider.value >= date_slider.end:
date_slider.value = date_slider.start
def button_callback():
global callback_id
if button.label == 'Play':
button.label = 'Stop'
callback_id = curdoc().add_periodic_callback(
adv_slider, delay_slider.value)
else:
button.label = 'Play'
curdoc().remove_periodic_callback(callback_id)
# callback assignment
delay_slider.on_change('value', restart_animation)
date_slider.on_change('value', update_map_callback)
dur_slider.on_change('value', update_map_callback)
button.on_click(button_callback)
lay = column(p, row(date_slider, button), row(dur_slider, delay_slider),
ff)
return lay
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,
lod_threshold=None,
plot_width=self.model.plot_width,
plot_height=self.model.plot_height,
y_range=self.y_range)
self.fig.min_border_top = 0
self.fig.min_border_bottom = 10
self.fig.min_border_left = 0
self.fig.min_border_right = 0
self.fig.axis.visible = False
self.fig.xgrid.grid_line_color = None
self.fig.ygrid.grid_line_color = None
# 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 label layer
self.label_source = WMTSTileSource(url=self.model.labels_url)
self.label_renderer = TileRenderer(tile_source=self.label_source)
self.fig.renderers.append(self.label_renderer)
# Add a hover tool
self.invisible_square = Square(x='x',
y='y',
fill_color=None,
line_color=None,
size=self.model.hover_size)
self.visible_square = Square(x='x',
y='y',
fill_color='#79DCDE',
fill_alpha=.5,
line_color='#79DCDE',
line_alpha=1,
size=self.model.hover_size)
cr = self.fig.add_glyph(self.model.hover_source,
self.invisible_square,
selection_glyph=self.visible_square,
nonselection_glyph=self.invisible_square)
code = "source.set('selected', cb_data['index']);"
callback = CustomJS(args={'source': self.model.hover_source}, code=code)
self.model.hover_tool = HoverTool(tooltips=[(self.model.fields.keys()[0], "@value")],
callback=callback,
renderers=[cr],
mode='mouse')
self.fig.add_tools(self.model.hover_tool)
self.model.legend_side_vbox = VBox()
self.model.legend_bottom_vbox = VBox()
# add ui components
controls = []
axes_select = Select.create(name='Axes',
options=self.model.axes)
axes_select.on_change('value', self.on_axes_change)
controls.append(axes_select)
self.field_select = Select.create(name='Field', options=self.model.fields)
self.field_select.on_change('value', self.on_field_change)
controls.append(self.field_select)
self.aggregate_select = Select.create(name='Aggregate',
options=self.model.aggregate_functions)
self.aggregate_select.on_change('value', self.on_aggregate_change)
controls.append(self.aggregate_select)
transfer_select = Select.create(name='Transfer Function',
options=self.model.transfer_functions)
transfer_select.on_change('value', self.on_transfer_function_change)
controls.append(transfer_select)
color_ramp_select = Select.create(name='Color Ramp', options=self.model.color_ramps)
color_ramp_select.on_change('value', self.on_color_ramp_change)
controls.append(color_ramp_select)
spread_size_slider = Slider(title="Spread Size (px)", value=0, start=0,
end=10, step=1)
spread_size_slider.on_change('value', self.on_spread_size_change)
controls.append(spread_size_slider)
hover_size_slider = Slider(title="Hover Size (px)", value=8, start=4,
end=30, step=1)
hover_size_slider.on_change('value', self.on_hover_size_change)
controls.append(hover_size_slider)
controls.append(self.model.legend_side_vbox)
# add map components
basemap_select = Select.create(name='Basemap', value='Imagery',
options=self.model.basemaps)
basemap_select.on_change('value', self.on_basemap_change)
image_opacity_slider = Slider(title="Opacity", value=100, start=0,
end=100, step=1)
image_opacity_slider.on_change('value', self.on_image_opacity_slider_change)
basemap_opacity_slider = Slider(title="Basemap Opacity", value=100, start=0,
end=100, step=1)
basemap_opacity_slider.on_change('value', self.on_basemap_opacity_slider_change)
show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0])
show_labels_chk.on_click(self.on_labels_change)
map_controls = [basemap_select, basemap_opacity_slider,
image_opacity_slider, show_labels_chk]
self.controls = VBox(width=200, height=600, children=controls)
self.map_controls = HBox(width=self.fig.plot_width, children=map_controls)
self.map_area = VBox(width=self.fig.plot_width, children=[self.map_controls,
self.fig,
self.model.legend_bottom_vbox])
self.layout = HBox(width=1366, children=[self.controls, self.map_area])
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,
lod_threshold=None,
plot_width=self.model.plot_width,
plot_height=self.model.plot_height,
y_range=self.y_range)
self.fig.min_border_top = 0
self.fig.min_border_bottom = 10
self.fig.min_border_left = 0
self.fig.min_border_right = 0
self.fig.axis.visible = False
self.fig.xgrid.grid_line_color = None
self.fig.ygrid.grid_line_color = None
# 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 label layer
self.label_source = WMTSTileSource(url=self.model.labels_url)
self.label_renderer = TileRenderer(tile_source=self.label_source)
self.fig.renderers.append(self.label_renderer)
# Add a hover tool
hover_layer = HoverLayer()
hover_layer.field_name = self.model.field_title
hover_layer.is_categorical = self.model.field in self.model.categorical_fields
self.fig.renderers.append(hover_layer.renderer)
self.fig.add_tools(hover_layer.tool)
self.model.hover_layer = hover_layer
self.model.legend_side_vbox = VBox()
self.model.legend_bottom_vbox = VBox()
# add ui components
controls = []
axes_select = Select.create(name='Axes',
options=self.model.axes)
axes_select.on_change('value', self.on_axes_change)
controls.append(axes_select)
self.field_select = Select.create(name='Field', options=self.model.fields)
self.field_select.on_change('value', self.on_field_change)
controls.append(self.field_select)
self.aggregate_select = Select.create(name='Aggregate',
options=self.model.aggregate_functions)
self.aggregate_select.on_change('value', self.on_aggregate_change)
controls.append(self.aggregate_select)
transfer_select = Select.create(name='Transfer Function',
options=self.model.transfer_functions)
transfer_select.on_change('value', self.on_transfer_function_change)
controls.append(transfer_select)
color_ramp_select = Select.create(name='Color Ramp', options=self.model.color_ramps)
color_ramp_select.on_change('value', self.on_color_ramp_change)
controls.append(color_ramp_select)
spread_size_slider = Slider(title="Spread Size (px)", value=0, start=0,
end=10, step=1)
spread_size_slider.on_change('value', self.on_spread_size_change)
controls.append(spread_size_slider)
hover_size_slider = Slider(title="Hover Size (px)", value=8, start=4,
end=30, step=1)
hover_size_slider.on_change('value', self.on_hover_size_change)
controls.append(hover_size_slider)
controls.append(self.model.legend_side_vbox)
# add map components
basemap_select = Select.create(name='Basemap', value='Imagery',
options=self.model.basemaps)
basemap_select.on_change('value', self.on_basemap_change)
image_opacity_slider = Slider(title="Opacity", value=100, start=0,
end=100, step=1)
image_opacity_slider.on_change('value', self.on_image_opacity_slider_change)
basemap_opacity_slider = Slider(title="Basemap Opacity", value=100, start=0,
end=100, step=1)
basemap_opacity_slider.on_change('value', self.on_basemap_opacity_slider_change)
show_labels_chk = CheckboxGroup(labels=["Show Labels"], active=[0])
show_labels_chk.on_click(self.on_labels_change)
map_controls = [basemap_select, basemap_opacity_slider,
image_opacity_slider, show_labels_chk]
self.controls = VBox(width=200, height=600, children=controls)
self.map_controls = HBox(width=self.fig.plot_width, children=map_controls)
self.map_area = VBox(width=self.fig.plot_width, children=[self.map_controls,
self.fig,
self.model.legend_bottom_vbox])
self.layout = HBox(width=1366, children=[self.controls, self.map_area])
import pandas as pd
import numpy as np
from bokeh.io import curdoc
from bokeh.plotting import Figure, output_file, show
from bokeh.models import ColumnDataSource, Slider
from bokeh.layouts import column
COUNT = 10
df = pd.DataFrame({"x": np.random.rand(COUNT), "y": np.random.rand(COUNT), "radius": 0.05})
source = ColumnDataSource(df)
fig = Figure()
fig.circle(source=source, x="x", y="y", fill_color="red", line_color="black", radius="radius")
slider = Slider(start=1, end=10, step=0.1, value=5)
def update_size(attrname, old, new):
source.data["radius"] = [slider.value / 100.0] * COUNT
slider.on_change("value", update_size)
curdoc().add_root(column(fig, slider))
updata_analytical_solution()
update_mesh(h, k)
# initialize data source
plot_data_num = ColumnDataSource(data=dict(x=[], u=[]))
plot_data_ana = ColumnDataSource(data=dict(x=[],u=[]))
mesh_data = ColumnDataSource(data=dict())
pde_specs = ColumnDataSource(data=dict(h=[], k=[]))
ana_sol = ColumnDataSource(data=dict())
# initialize controls
# slider for going though time
time_slider = Slider(title="time", name='time', value=pde_settings.t_init, start=pde_settings.t_min, end=pde_settings.t_max,
step=pde_settings.t_step)
time_slider.on_change('value', time_change)
# slider controlling spatial stepsize of the solver
h_slider = Slider(title="spatial meshwidth", name='spatial meshwidth', value=pde_settings.h_init, start=pde_settings.h_min,
end=pde_settings.h_max, step=pde_settings.h_step)
h_slider.on_change('value', mesh_change)
# slider controlling spatial stepsize of the solver
k_slider = Slider(title="temporal meshwidth", name='temporal meshwidth', value=pde_settings.k_init, start=pde_settings.k_min,
end=pde_settings.k_max, step=pde_settings.k_step)
k_slider.on_change('value', mesh_change)
# radiobuttons controlling pde type
pde_type = RadioButtonGroup(labels=['Heat', 'Wave'], active=0)
pde_type.on_change('active', pde_type_change)
# radiobuttons controlling solver type
solver_type = RadioButtonGroup(labels=['Explicit', 'Implicit'], active=0)
solver_type.on_change('active', mesh_change)
# text input for IC
p.line('t', 'i', source=source)
p.xaxis.axis_label='Time [s]'
p.yaxis.axis_label='Current [A]'
m=figure(plot_width=600, plot_height=400, title='Voltages')
m.line('t', 'usupp', source=source, legend='Line voltage', color='orange')
m.line('t', 'uc', source=source, legend='Capacitor voltage', color='green')
m.xaxis.axis_label='Time [s]'
m.yaxis.axis_label='Voltage[V]'
m.legend.location = "bottom_left"
# widgets
Slider_C = Slider(start=0.0001, end=0.01, value=0.01, step=.00001, title="Capacitance [F]")
Slider_R = Slider(start=1, end=50, value=5, step=1, title="Resistance [Ohm]")
Slider_L = Slider(start=0.001, end=1, value=0.1, step=0.001, title="Inductance [H]")
#Slider_Uo = Slider(start=10e3, end=100e3, value=20e3, step=10e3, title="Charging voltage [V]")
layout = row(widgetbox(Slider_C, Slider_R, Slider_L), column(p,m))
def callback(attr, old, new):
new_C = Slider_C.value
new_R = Slider_R.value
new_L = Slider_L.value
ib, uc2, ub = calRLCcir(R=new_R, L=new_L, C=new_C, alpha=0)
source.data = {'t': t, 'i': ib, 'uc': uc2, 'usupp': ub}
Slider_C.on_change('value', callback)
Slider_R.on_change('value', callback)
Slider_L.on_change('value', callback)
curdoc().add_root(layout)
plot.xaxis.axis_label_text_font_size = '10pt'
plot.yaxis.axis_label="Current [A]"
plot.yaxis.axis_label_text_font_size = '10pt'
plot.line('t', 'ia', source=source, line_width=3, line_alpha=0.6, legend="Circuit current")
plot.line('t', 'iadc', source=source, line_width=2, line_alpha=0.6, color="orange", legend="DC component")
plot.line('t', 'iau', source=source, line_width=2, line_alpha=0.6, color="green", legend="AC component")
# slider
slider = Slider(start=0, end=phi, value=0, step=.1, title="Voltage closing angle [rad]", name="slider")
#callback part
def callback(attr, old, new):
new_alpha = slider.value
#Current response
ia = [(sqrt(2)*u/(sqrt(R**2+XL**2))*(sin(omega*k+new_alpha-phi)-sin(new_alpha-phi)*exp(-R/L*k))) for k in t]
#DC component of the current
iadc = [(sqrt(2)*u/(sqrt(R**2+XL**2))*-sin(new_alpha-phi)*(exp(-R/L*k))) for k in t]
#AC steady state current
iau = [(sqrt(2)*u/(sqrt(R**2+XL**2))*sin(omega*k+new_alpha-phi)) for k in t]
# source data update
source.data = {'t': t, 'ia': ia, 'iadc': iadc, 'iau': iau}
slider.on_change('value', callback)
layout = row(slider, plot)
curdoc().add_root(layout)
# Add the layout to the current document
curdoc().add_root(layout)
# Define a callback function: callback
def callback(attr, old, new):
# Read the current value of the slider: scale
scale = slider.value
# Compute the updated y using np.sin(scale/x): new_y
new_y = np.sin(scale / x)
# Update source with the new data values
source.data = {'x': x, 'y': new_y}
# Attach the callback to the 'value' property of slider
slider.on_change('value', callback)
# Create layout and add to current document
layout = column(widgetbox(slider), plot)
curdoc().add_root(layout)
# Perform necessary imports
from bokeh.models import ColumnDataSource, Select
# Create ColumnDataSource: source
source = ColumnDataSource(data={'x': fertility, 'y': female_literacy})
# Create a new plot: plot
plot = figure()
# Add circles to the plot
width=250)
def update_k_clusters(attrname, old, new):
k_cluster = int(k_slider.value)
brc = Birch(branching_factor=50,
n_clusters=k_cluster,
threshold=0.5,
compute_labels=True)
brc.fit(tweet_vecs)
predictions = brc.predict(tweet_vecs)
colors = get_colors(predictions)
brc_data.data = dict(colors=colors, x=tsne_vecs[:, 0], y=tsne_vecs[:, 1])
k_slider.on_change('value', update_k_clusters)
def update_s_clusters(attrname, old, new):
k_cluster = int(k_slider.value)
km = KMeans(n_clusters=k_cluster, random_state=0)
km.fit(tweet_vecs)
predictions = km.predict(tweet_vecs)
colors = get_colors(predictions)
km_data.data = dict(colors=colors, x=tsne_vecs[:, 0], y=tsne_vecs[:, 1])
s_slider.on_change('value', update_s_clusters)
inputs = widgetbox(k_slider)
l = layout([row(column(brc_plot, k_slider), column(km_plot, s_slider))])
doc = curdoc()
x = np.linspace(0, 2, 1000)
y = 1 - (x-1)**2
source = ColumnDataSource(data=dict(x=x, y=y))
p = figure(title="initial title")
p.circle(x=1, y=list(range(0, 11)))
p.line('x', 'y', color="orange", source=source)
slider = Slider(start=0, end=10, step=0.1, value=1)
def scb(attr, old, new):
source.data['y'] = new * y
slider.on_change('value', scb)
combine = Button(label="hold combine")
combine.on_event(ButtonClick, lambda event: doc.hold("combine"))
collect = Button(label="hold collect")
collect.on_event(ButtonClick, lambda event: doc.hold("collect"))
unhold = Button(label="unhold")
unhold.on_event(ButtonClick, lambda event: doc.unhold())
doc.add_root(column(p, slider, combine, collect, unhold))
@repeat(np.linspace(0, 10, 100))
def update(v):
slider.value = v
text='Your score for {} dataset {} is: {} pts!'.format(diff,datasetNum,score)
)
difficultySelect.on_change('value',on_dataSelect)
easySelect.on_change('value',on_dataSelect)
mediumSelect.on_change('value',on_dataSelect)
hardSelect.on_change('value',on_dataSelect)
modelTypeSelect.on_change('value',on_modelChange)
noiseSelect.on_change('value',on_modelChange)
monoSelect.on_change('value',on_modelChange)
coalSelect.on_change('value',on_modelChange)
burstSelect.on_change('value',on_modelChange)
xSlider.on_change('value',on_modelChange)
goButton.on_click(on_goButton)
#Layout of webpage------------------------------------------------------------
layoutList = [
[description],
[fig],
[[difficultySelect,easySelect],[modelTypeSelect,noiseSelect],[xSlider,goButton, results]],
[endBits]
]
plot.title = algorithm
def update_samples_or_dataset(attrname, old, new):
global X, y
dataset = dataset_select.value
algorithm = algorithm_select.value
n_clusters = int(clusters_slider.value)
n_samples = int(samples_slider.value)
X, y = get_dataset(dataset, n_samples)
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_or_clusters)
clusters_slider.on_change('value', update_algorithm_or_clusters)
dataset_select.on_change('value', update_samples_or_dataset)
samples_slider.on_change('value', update_samples_or_dataset)
# set up layout
selects = HBox(dataset_select, algorithm_select)
inputs = VBox(samples_slider, clusters_slider, selects)
# add to document
curdoc().add_root(HBox(inputs, plot))
value=0,
step=10,
title="Land Cost Adjustment")
sorghum_c2_slider = Slider(start=-50,
end=40,
value=0,
step=10,
title="Nitrogen Fertilizer Cost Adjustment")
sorghum_p_slider = Slider(start=-50,
end=40,
value=0,
step=10,
title="Crop Price Adjustment")
# Get the values from the sliders
cassava_c1_slider.on_change('value', update_data)
cassava_c2_slider.on_change('value', update_data)
cassava_p_slider.on_change('value', update_data)
groundnuts_c1_slider.on_change('value', update_data)
groundnuts_c2_slider.on_change('value', update_data)
groundnuts_p_slider.on_change('value', update_data)
maize_c1_slider.on_change('value', update_data)
maize_c2_slider.on_change('value', update_data)
maize_p_slider.on_change('value', update_data)
sesame_c1_slider.on_change('value', update_data)
sesame_c2_slider.on_change('value', update_data)
sesame_p_slider.on_change('value', update_data)
Attach the callback to the 'value' property of slider. This can be done using on_change() and passing in 'value' and update_plot.
Make a row layout of widgetbox(slider) and plot and add it to the current document.
'''
# Import the necessary modules
from bokeh.layouts import widgetbox, row
from bokeh.models import Slider
# Define the callback function: update_plot
def update_plot(attr, old, new):
# set the `yr` name to `slider.value` and `source.data = new_data`
yr = slider.value
new_data = {
'x' : data.loc[yr].fertility,
'y' : data.loc[yr].life,
'country' : data.loc[yr].Country,
'pop' : (data.loc[yr].population / 20000000) + 2,
'region' : data.loc[yr].region,
}
source.data = new_data
# Make a slider object: slider
slider = Slider(start=1970, end=2010, step=1, value=1970, title='Year')
# Attach the callback to the 'value' property of slider
slider.on_change('value',update_plot)
# Make a row layout of widgetbox(slider) and plot and add it to the current document
layout = row(widgetbox(slider), plot)
curdoc().add_root(layout)
class Document:
def __init__(self, time1, granularity, dark_mode):
self.time1 = time1 # datetime.datetime(2020, 4, 1)
self.time2 = datetime.datetime.now() # utcnow()
self.granularity = granularity # '5m'
self.dark_mode = dark_mode
if self.dark_mode:
self.color_green = '#75bb36'
self.color_red = '#dd4a4a'
self.color_blue = 'light blue'
self.color_black = 'white'
self.color_gray = 'gray'
else:
self.color_green = 'green'
self.color_red = 'red'
self.color_blue = 'blue'
self.color_black = 'black'
self.color_gray = 'gray'
self.days = self.time2 - self.time1
print('days', self.days.days)
self.day_slider = Slider(start=0,
end=self.days.days,
value=self.days.days,
step=1,
title='Day Selector')
self.day_slider.on_change('value', self.select_data)
self.raw_data = get_data_bitfinex(self.time1, self.time2,
self.granularity)
self.time_step = (self.raw_data[1][0] - self.raw_data[0][0]) / 1000
self.day_length = 86400 / self.time_step
print('delta (s): ', self.time_step)
print('day length: ', self.day_length)
print('raw data length: ', len(self.raw_data))
print('actual data start: ', self.day_slider.value * self.day_length)
self.green_candles = ColumnDataSource(data={
'timestamps': [],
'candles_bottom': [],
'candles_top': []
})
self.red_candles = ColumnDataSource(data={
'timestamps': [],
'candles_bottom': [],
'candles_top': []
})
self.blue_volumes = ColumnDataSource(data={'bins': [], 'volumes': []})
self.actual_line = ColumnDataSource(data={
'timestamps': [],
'values': [],
'name': []
})
self.gray_volumes = ColumnDataSource(data={
'timestamps': [],
'volumes': []
})
self.create_candles()
self.select_data('value', self.day_slider.value, self.day_slider.value)
self.create_candles_plot()
self.create_volumes_plot()
def create_candles(self):
self.segment_y0_green = []
self.segment_y1_green = []
self.segment_y0_red = []
self.segment_y1_red = []
self.vbar_green_x = []
self.vbar_green_top = []
self.vbar_green_bottom = []
self.vbar_red_x = []
self.vbar_red_top = []
self.vbar_red_bottom = []
self.vbar_gray_x = []
self.vbar_gray = []
for each in self.raw_data:
self.vbar_gray_x.append(each[0])
self.vbar_gray.append(each[5])
if each[1] < each[2]:
self.vbar_green_x.append(each[0])
self.vbar_green_top.append(each[2])
self.vbar_green_bottom.append(each[1])
self.segment_y0_green.append(each[4])
self.segment_y1_green.append(each[3])
else:
self.vbar_red_x.append(each[0])
self.vbar_red_top.append(each[2])
self.vbar_red_bottom.append(each[1])
self.segment_y0_red.append(each[4])
self.segment_y1_red.append(each[3])
def select_data_(self):
"""
initial data select function
currently not used
:return:
"""
start_timestamp = self.raw_data[int(self.day_slider.value *
self.day_length)][0]
print('searchin for timestamp ', start_timestamp)
for i in range(len(self.vbar_green_x)):
if self.vbar_green_x[i] >= start_timestamp:
break
print('timestamp found ', self.vbar_green_x[i])
self.green_candles.data = {
'timestamps': self.vbar_green_x[i:-1],
'candles_bottom': self.vbar_green_bottom[i:-1],
'candles_top': self.vbar_green_top[i:-1]
}
def create_candles_plot(self):
self.candles = figure(x_axis_type='datetime')
print('volumes: ', max(self.gray_volumes.data['volumes']))
y_start = min(min(self.green_candles.data['segment_min']),
min(self.red_candles.data['segment_min']))
y_end = max(max(self.green_candles.data['segment_max']),
max(self.red_candles.data['segment_max']))
self.candles.y_range.start = y_start - (y_end - y_start) * 0.15
self.candles.y_range.end = y_end + (y_end - y_start) * 0.05
self.candles.extra_y_ranges = {
'volume_y':
Range1d(
start=0,
end=max(self.gray_volumes.data['volumes']) * 5,
),
'candles_y':
Range1d(
start=y_start - (y_end - y_start) * 0.15,
end=y_end + (y_end - y_start) * 0.05,
)
}
self.candles.yaxis.visible = False
self.candles.add_layout(LinearAxis(y_range_name='candles_y'), 'left')
self.candles.vbar(
x='timestamps',
width=self.time_step * 1000 * 0.7, # 900000,
top='volumes',
bottom=0,
source=self.gray_volumes,
fill_color=self.color_gray,
line_color=self.color_gray,
fill_alpha=0.4,
y_range_name='volume_y',
)
self.candles.segment(
x0='timestamps',
y0='segment_min',
x1='timestamps',
y1='segment_max',
source=self.green_candles,
color=self.color_green,
y_range_name='candles_y',
)
self.candles.segment(
x0='timestamps',
y0='segment_min',
x1='timestamps',
y1='segment_max',
source=self.red_candles,
color=self.color_red,
y_range_name='candles_y',
)
self.candles.vbar(
x='timestamps',
width=self.time_step * 1000 * 0.7, # 900000,
top='candles_top',
bottom='candles_bottom',
source=self.green_candles,
fill_color=self.color_green,
line_color=self.color_green,
fill_alpha=0.4,
y_range_name='candles_y',
)
self.candles.vbar(
x='timestamps',
width=self.time_step * 1000 * 0.7, # 900000,
top='candles_top',
bottom='candles_bottom',
source=self.red_candles,
fill_color=self.color_red,
line_color=self.color_red,
fill_alpha=0.4,
y_range_name='candles_y',
)
self.candles.line(
x='timestamps',
y='values',
source=self.actual_line,
line_color=self.color_black,
line_dash='dashed',
name='actual_value',
legend_field='values',
y_range_name='candles_y',
)
hover_tool = HoverTool(
tooltips=[('time', '@timestamps{%Y-%m-%d %H:%M}'),
('open', '@candles_bottom{(0.0)}'),
('close', '@candles_top{(0.0)}'),
('high', '@segment_max{(0.0)}'),
('low', '@segment_min{(0.0)}'),
('volume', '@volumes{(0.0)}')],
formatters={'@timestamps': 'datetime'},
# mode='vline'
)
self.candles.add_tools(hover_tool)
# self.candles.output_backend = "webgl"
print(self.candles.border_fill_color)
print(self.candles.background_fill_color)
print(self.candles.yaxis[0].major_label_text_color)
if self.dark_mode:
self.candles.border_fill_color = 'dimgray'
self.candles.background_fill_color = '#060606' # '#1f1f1f' # 'dimgray'
self.candles.grid.grid_line_color = '#4a4a4a' # 'black'
self.candles.yaxis[0].major_label_text_color = 'white'
self.candles.yaxis[1].major_label_text_color = 'white'
self.candles.xaxis[0].major_label_text_color = 'white'
else:
self.candles.border_fill_color = '#ffffff'
self.candles.background_fill_color = '#ffffff'
self.candles.grid.grid_line_color = '#e5e5e5'
self.candles.yaxis[0].major_label_text_color = '#444444'
self.candles.yaxis[1].major_label_text_color = '#444444'
self.candles.xaxis[0].major_label_text_color = '#444444'
def create_volumes_plot(self):
self.volume_plot = figure()
self.volume_plot.hbar(
y='bins',
height=self.bin_height * 0.7,
left=0,
right='volumes',
source=self.blue_volumes,
fill_alpha=0.4,
)
hover_tool = HoverTool(
tooltips=[('price: ', '@bins{(0)}'), ('volume: ',
'@volumes{(0)}')])
self.volume_plot.add_tools(hover_tool)
self.volume_plot.sizing_mode = 'stretch_height'
if self.dark_mode:
self.volume_plot.border_fill_color = 'dimgray'
self.volume_plot.background_fill_color = '#060606' # 'dimgray'
self.volume_plot.grid.grid_line_color = '#4a4a4a' # 'black'
self.volume_plot.yaxis[0].major_label_text_color = 'white'
self.volume_plot.xaxis[0].major_label_text_color = 'white'
else:
self.volume_plot.border_fill_color = '#ffffff'
self.volume_plot.background_fill_color = '#ffffff'
self.volume_plot.grid.grid_line_color = '#e5e5e5'
self.volume_plot.yaxis[0].major_label_text_color = '#444444'
self.volume_plot.xaxis[0].major_label_text_color = '#444444'
def select_data(self, attr, old, new):
"""
day_slider value change callback function
:param attr:
:param old:
:param new:
:return:
"""
print('slider value changed: ', new)
start_timestamp = self.raw_data[int(self.day_slider.value *
self.day_length)][0]
try:
stop_timestamp = self.raw_data[int(
(self.day_slider.value + 1) * self.day_length)][0]
except IndexError:
stop_timestamp = self.raw_data[-1][0]
for i in range(len(self.vbar_green_x)):
if self.vbar_green_x[i] >= start_timestamp:
break
# if self.day_slider.value < self.day_slider.end:
for j in range(len(self.vbar_green_x)):
if self.vbar_green_x[j] >= stop_timestamp:
break
self.green_candles.data = {
'timestamps': self.vbar_green_x[i:j + 1],
'candles_bottom': self.vbar_green_bottom[i:j + 1],
'candles_top': self.vbar_green_top[i:j + 1],
'segment_min': self.segment_y0_green[i:j + 1],
'segment_max': self.segment_y1_green[i:j + 1],
}
for k in range(len(self.vbar_red_x)):
if self.vbar_red_x[k] >= start_timestamp:
break
# if self.day_slider.value < self.day_slider.end:
for l in range(len(self.vbar_red_x)):
if self.vbar_red_x[l] >= stop_timestamp:
break
self.red_candles.data = {
'timestamps': self.vbar_red_x[k:l + 1],
'candles_bottom': self.vbar_red_bottom[k:l + 1],
'candles_top': self.vbar_red_top[k:l + 1],
'segment_min': self.segment_y0_red[k:l + 1],
'segment_max': self.segment_y1_red[k:l + 1],
}
raw_data_start = int(self.day_slider.value * self.day_length)
raw_data_stop = int(raw_data_start + self.day_length)
self.gray_volumes.data = {
'timestamps': self.vbar_gray_x[raw_data_start:raw_data_stop],
'volumes': self.vbar_gray[raw_data_start:raw_data_stop],
}
self.bin_height = 5
bins, volumes = generate_volumes(
self.raw_data[raw_data_start:raw_data_stop], self.bin_height)
self.bins = bins
self.volumes = volumes
self.blue_volumes.data = {
'bins': self.bins,
'volumes': self.volumes,
}
self.update_ranges()
def update_last_value(self):
url2 = f'https://api-pub.bitfinex.com/v2/candles/trade:{self.granularity}:tBTCUSD/last'
r2 = requests.get(url2)
print('last data: ',
datetime.datetime.fromtimestamp(r2.json()[0] / 1000), r2.json())
# x = [self.raw_data[0][0], self.raw_data[-1][0]]
x = [
min(self.green_candles.data['timestamps'][0],
self.red_candles.data['timestamps'][0]),
max(self.green_candles.data['timestamps'][-1],
self.red_candles.data['timestamps'][-1])
]
y = [round(r2.json()[2], 1), round(r2.json()[2], 1)]
# self.actual_line.data = {'timestamps': x, 'values': y, 'name': [str(y[0]), str(y[-1])]}
self.actual_line.data = {
'timestamps': x,
'values': y
} # , 'name': str(y[0])}
def update_everything(self):
self.raw_data = get_data_bitfinex(self.time1, datetime.datetime.now(),
self.granularity)
self.create_candles()
# self.select_data_()
self.select_data('value', self.day_slider.value, self.day_slider.value)
def update_ranges(self):
try:
print('updating ranges')
y_start = min(min(self.green_candles.data['segment_min']),
min(self.red_candles.data['segment_min']))
y_end = max(max(self.green_candles.data['segment_max']),
max(self.red_candles.data['segment_max']))
self.candles.y_range.start = y_start - (y_end - y_start) * 0.15
self.candles.y_range.end = y_end + (y_end - y_start) * 0.05
self.candles.extra_y_ranges['candles_y'].start = y_start - (
y_end - y_start) * 0.15
self.candles.extra_y_ranges['candles_y'].end = y_end + (
y_end - y_start) * 0.05
print('min: ', y_start, self.candles.y_range.start)
print('max: ', y_end, self.candles.y_range.end)
self.candles.extra_y_ranges['volume_y'].end = max(
self.gray_volumes.data['volumes']) * 5
except AttributeError:
print('ranges not updated')
partial_hist, _ = np.histogram(selected.data['dist'],
bins=edges)
histogram.data_source.data['right'] = partial_hist
# Recompute n, median and rms
n = len(selected.data['dist'])
median = np.median(selected.data['dist'])
rms = np.sqrt(np.mean(np.square(selected.data['dist'])))
# Update spans
span1.location = snr_cut
span2.location = rms
# Update labels
label1.text = 'SNR > {:3.2f}'.format(snr_cut)
label2.text = 'Median = {:3.2f} marcsec'.format(median)
label3.text = 'RMS = {:3.2f} marcsec'.format(rms)
label4.text = 'N = {}'.format(n)
snr_slider.on_change('value', update)
# Arrange plots and widgets layout
layout = row(column(widgetbox(title, width=900),
widgetbox(snr_slider, width=900),
row(plot, hist)))
curdoc().add_root(layout)
curdoc().title = "SQuaSH"
plot.title.text = algorithm
def update_samples_or_dataset(attrname, old, new):
global X, y
dataset = dataset_select.value
algorithm = algorithm_select.value
n_clusters = int(clusters_slider.value)
n_samples = int(samples_slider.value)
X, y = get_dataset(dataset, n_samples)
X, y_pred = clustering(X, algorithm, n_clusters)
colors = [spectral[i] for i in y_pred]
source.data = dict(colors=colors, x=X[:, 0], y=X[:, 1])
algorithm_select.on_change('value', update_algorithm_or_clusters)
clusters_slider.on_change('value_throttled', update_algorithm_or_clusters)
dataset_select.on_change('value', update_samples_or_dataset)
samples_slider.on_change('value_throttled', update_samples_or_dataset)
# set up layout
selects = row(dataset_select, algorithm_select, width=420)
inputs = column(selects, samples_slider, clusters_slider)
# add to document
curdoc().add_root(row(inputs, plot))
curdoc().title = "Clustering"
plot_width=950,
toolbar_location=None,
tools=[hover])
p.xgrid.grid_line_color = None
p.ygrid.grid_line_color = None
p.patches('xs',
'ys',
source=geosource,
fill_color={
'field': 'per_cent_obesity',
'transform': color_mapper
},
line_color='black',
line_width=0.25,
fill_alpha=1)
p.add_layout(color_bar, 'below')
def update_plot(attr, old, new):
yr = slider.value
new_data = json_data(yr)
geosource.geojson = new_data
p.title.text = 'Share of adults who are obese, %d' % yr
slider = Slider(title='Year', start=1975, end=2016, step=1, value=2016)
slider.on_change('value', update_plot)
layout = column(p, widgetbox(slider))
curdoc().add_root(layout)
show(layout)
# Read the current value of the slider: scale
scale = slider.value
# Compute the updated y using np.cos(scale/x): new_y
new_y = np.sin(scale / x)
# Update source with the new data values
source.data = {'x': x, 'y': new_y}
# Dataset
x = np.arange(0, 10, 0.1)
y = np.sin(x)
# Create ColumnDataSource: source
source = ColumnDataSource(data={'x': x, 'y': y})
# Create a figure
p = figure(x_axis_label='x values', y_axis_label='Sin(x)')
# Add a line to the plot
p.line('x', 'y', source=source)
# Create first slider: slider1
slider = Slider(title='slider1', start=0, end=10, step=0.1, value=2)
# Attach the callback to the 'value' property of slider
slider.on_change('value', callback)
# Create layout and add to current document
layout = column(widgetbox(slider), p)
curdoc().add_root(layout)
def animate_update():
year = slider.value + 1
if year > years[-1]:
year = years[0]
slider.value = year
def slider_update(attrname, old, new):
year = slider.value
label.text = str(year)
source.data = data[year]
slider = Slider(start=years[0], end=years[-1], value=years[0], step=1, title="Year")
slider.on_change('value', slider_update)
callback_id = None
def animate():
global callback_id
if button.label == '► Play':
button.label = '❚❚ Pause'
callback_id = curdoc().add_periodic_callback(animate_update, 200)
else:
button.label = '► Play'
curdoc().remove_periodic_callback(callback_id)
button = Button(label='► Play', width=60)
button.on_click(animate)
geo_source.geojson = states_view.to_json()
def save_to_shapefile():
states_view.to_file('fout.shp')
def on_slider_change(attr, old, new):
simplify_tolerance = new
simplify_features(simplify_tolerance)
# let's read some shapefile metadata
crs = states.crs
simplify_slider = Slider(title='Simplify Tolerance',
value=0, start=0, end=1, step=.01)
simplify_slider.on_change('value', on_slider_change)
save_button = Button(label='Save')
save_button.on_click(save_to_shapefile)
p = Figure(plot_height=600, plot_width=900,
x_range=(bounds[0], bounds[2]), y_range=(bounds[1], bounds[3]))
polys = p.patches(xs='xs', ys='ys', alpha=0.9, source=geo_source)
controls = HBox(width=p.plot_width, children=[simplify_slider, save_button])
layout = VBox(width=p.plot_width, children=[controls, p])
curdoc().add_root(layout)
