new): # callback function for selection of channels
chans = []
for l in new:
chans.append(l.encode('UTF8'))
df2 = updateDateRange()
df2 = df2[df2['Light'].isin(chans)]
updateData(df2)
p1.y_range.factors = list(reversed(chans))
def allLights(): # callback function for all lights button
area_select.value = list(an['Name'])
# configure actions for widgets
plotDates.on_click(dateChange)
selectAll.on_click(allLights)
area_select.on_change('value', areaChange)
channel_select.on_change('value', channelChange)
setTitle()
p = Paragraph(text="""""", width=200, height=10)
l = layout([[
p1,
column(widgetbox(p), selectAll, area_select, channel_select,
row(datePickStart, datePickEnd, height=240), plotDates)
]])
curdoc().add_root(l)
x=[3,4,6,12,10,1]
y=[7,1,3,4,1,6]
label=['Red', 'Orange', 'Red', 'Orange','Red', 'Orange']
df=pd.DataFrame({'x':x,'y':y,'label':label}) #create a dataframe for future use
source = ColumnDataSource(data=dict(x=x, y=y,label=label))
plot_figure = figure(title='Multi-Select',plot_height=450, plot_width=600,
tools="save,reset", toolbar_location="below")
plot_figure.scatter('x', 'y',color='label', source=source, size=10)
multi_select = MultiSelect(title="Filter Plot by color:", value=["Red", "Orange"],
options=[("Red", "Red"), ("Orange", "Orange")])
def multiselect_click(attr,old,new):
active_mselect=multi_select.value ##Getting multi-select value
selected_df=df[df['label'].isin(active_mselect)] #filter the dataframe with value in multi-select
source.data=dict(x=selected_df.x, y=selected_df.y,label=selected_df.label)
multi_select.on_change('value',multiselect_click)
layout=row(multi_select, plot_figure)
curdoc().add_root(layout)
curdoc().title = "Multi-Select Bokeh Server"
plot_figure = figure(title='Multi-Select',
plot_height=450,
plot_width=600,
tools="save,reset",
toolbar_location="below")
plot_figure.scatter('x', 'y', color='label', source=source, size=10)
multi_select = MultiSelect(title="Filter Plot by color:",
value=["Red", "Orange"],
options=[("Red", "Red"), ("Orange", "Orange")])
def multiselect_click(attr, old, new):
active_mselect = multi_select.value ##Getting multi-select value
selected_df = df[df['label'].isin(
active_mselect)] #filter the dataframe with value in multi-select
source.data = dict(x=selected_df.x,
y=selected_df.y,
label=selected_df.label)
multi_select.on_change('value', multiselect_click)
layout = row(multi_select, plot_figure)
curdoc().add_root(layout)
curdoc().title = "Multi-Select Bokeh Server"
def tab_testing():
data_list = glob.glob('./np/Regression/*.npy')
data_list = sorted(data_list)
select_data = Select(title="Data:", value="", options=data_list)
model_list = os.listdir('./model/Regression/')
model_list = sorted(model_list)
select_model = Select(title="Trained Model:", value="", options=model_list)
notifier = Paragraph(text=""" Notification """, width=200, height=100)
def refresh_handler():
data_list_new = glob.glob('./np/Regression/*.npy')
data_list_new = sorted(data_list_new)
select_data.options = data_list_new
model_list_new = os.listdir('./model/Regression/')
model_list_new = sorted(model_list_new)
select_model.options = model_list_new
button_refresh = Button(label="Refresh list")
button_refresh.on_click(refresh_handler)
button_test = Button(label="Test model")
select_result = MultiSelect(title="Key(result):")
src = ColumnDataSource()
df = pd.DataFrame(columns=['key', 'y', 'y_hat'])
table_src = ColumnDataSource(pd.DataFrame(columns=['Key', 'MSE', 'R^2']))
table_columns = [
TableColumn(field=col, title=col) for col in ['Key', 'MSE', 'R^2']
]
table_acc = DataTable(source=table_src,
columns=table_columns,
width=350,
height=400,
fit_columns=True,
name="Accuracy per Key")
def test_handler():
df.drop(df.index, inplace=True)
print("Start test")
tf.reset_default_graph()
K.clear_session()
notifier.text = """ Start testing """
if (select_data.value == ""):
data = np.load(select_data.options[0])
else:
data = np.load(select_data.value)
data = data.item()
notifier.text = """ Import data """
data_x = data.get('x')
if (data_x.shape[-1] == 1 and not 'cnn' in select_model.value):
data_x = np.squeeze(data_x, -1)
data_y = data.get('y')
data_key = data.get('key1')
print(data_x.shape)
print(data_y.shape)
df['key'] = data_key
df['y'] = data_y[:, 0]
op_list = []
for i in df['key'].unique():
op_list.append(str(i))
select_result.options = op_list
print(data_x.shape)
print(data_y.shape)
print(data.get('key1'))
if (select_model.value == ""):
model_name = select_model.options[0]
else:
model_name = select_model.value
model_save_dir = './model/Regression/' + model_name + '/'
model_dl = glob.glob(model_save_dir + '*.h5')
model_ml = glob.glob(model_save_dir + '*.sav')
print(model_save_dir + '*.h5')
print(model_dl)
print(model_ml)
if (len(model_dl) > len(model_ml)):
model = keras.models.load_model(model_save_dir + model_name +
'.h5')
target_hat = model.predict(data_x)
DL = True
elif (len(model_dl) < len(model_ml)):
model = pickle.load(
open(model_save_dir + model_name + '.sav', 'rb'))
data_x = data_x.reshape([data_x.shape[0], -1])
target_hat = model.predict(data_x)
target_hat = np.expand_dims(target_hat, -1)
DL = False
notifier.text = """ Model restored """
print("Model restored.")
xs = []
ys = []
keys = []
color = ['blue', 'red']
xs.append([i for i in range(data_y.shape[0])])
xs.append([i for i in range(data_y.shape[0])])
ys.append(data_y)
keys.append(data_key)
print(target_hat.shape)
K.clear_session()
ys.append(target_hat)
keys.append(data_key)
print(target_hat[:, 0])
df['y_hat'] = target_hat[:, 0]
src.data = ColumnDataSource(
data=dict(xs=xs, ys=ys, color=color, keys=keys)).data
figure_trend.multi_line('xs', 'ys', source=src, color='color')
line_mse = []
line_r_2 = []
for unit in df['key'].unique():
target = df[df['key'] == unit]
y = target['y'].values
y_hat = target['y_hat'].values
unit_mse = np.sum((y - y_hat)**2) / target.shape[0]
unit_r_2 = np.max([r2_score(y, y_hat), 0])
line_mse.append(unit_mse)
line_r_2.append(unit_r_2)
acc = pd.DataFrame(columns=['Key', 'MSE', 'R^2'])
acc['Key'] = df['key'].unique()
mse_mean = np.mean(line_mse)
r_2_mean = np.mean(line_r_2)
line_mse = list(map(lambda x: format(x, '.2f'), line_mse))
acc['MSE'] = line_mse
line_r_2 = list(map(lambda x: format(x, '.2f'), line_r_2))
acc['R^2'] = line_r_2
acc_append = pd.DataFrame(columns=acc.columns)
acc_append['Key'] = ['MSE average', 'R^2 average']
acc_append['MSE'] = [mse_mean, r_2_mean]
acc = pd.concat([acc, acc_append])
table_src.data = ColumnDataSource(acc).data
notifier.text = """ Drawing complete """
history.text = history.text + "\n\t" + model_name + "'s R^2 score: " + format(
np.mean(r_2_mean), '.2f')
def update(attr, old, new):
key_to_plot = select_result.value
xs = []
ys = []
keys = []
y = []
y_hat = []
key = []
key_type = type(df['key'].values[0])
for k in key_to_plot:
y += list(df[df['key'] == key_type(k)]['y'].values)
y_hat += list(df[df['key'] == key_type(k)]['y_hat'].values)
key += [k for _ in range(df[df['key'] == key_type(k)].shape[0])]
ys.append(y)
ys.append(y_hat)
xs.append([i for i in range(len(y))])
xs.append([i for i in range(len(y))])
keys.append(key)
keys.append(key)
color = ['blue', 'red']
src.data = ColumnDataSource(
data=dict(xs=xs, ys=ys, color=color, keys=keys)).data
select_result.on_change("value", update)
button_test.on_click(test_handler)
button_export = Button(label="Export result")
def handler_export():
df.to_csv('./Export/result.csv', index=False)
button_export.on_click(handler_export)
figure_trend = figure(title="Prediction result", width=800, height=460)
history = PreText(text="", width=300, height=460)
layout = Column(
Row(button_refresh),
Row(select_data, select_model, button_test, select_result, notifier),
Row(table_acc, figure_trend, history, button_export))
tab = Panel(child=layout, title='Regression Test')
return tab
def create_tab(data, name):
def make_dataset(metric_fun, metric_sentiment, month_start, month_end,
editorial, category, social_network, product):
"""Constrói os datasets para cada tipo de gráfico utilizado no dashboard
Parâmetros
----------
data : DataFrame
Pandas DataFrame expandido com dados do Sprinklr
metric_fun : FUN
Função para calcular métrica específica selecionada no widget
metric_sentiment : str
Sentimento relacionado à métrica escolhida (Positividade: positivo, Gradiente: negativo, Crise: negativo, Saúde do post: positivo)
[restante] : str
Valaores selecionados nas opções de filtros nos widgets
Retorna
-------
dict
Dicionário com três chaves, correspondentes aos três gráficos apresentados. Cada chave é relacionada ao nome o gráfico
e os valores são datasets no formato column data source
"""
month_start = pd.Timestamp(month_start)
month_end = pd.Timestamp(month_end)
# Filtragem dos dados com base nas seleções dos widgets
filters = {
'Editoria': editorial,
'Categoria': category,
'SocialNetwork': social_network,
'Produto': product
}
filtered_data = filter_data(data, filters)
# Gera datasets para cada gráfico
ts_data = metric_fun(filtered_data)
ts_data = ts_data[(ts_data.time >= month_start)
& (ts_data.time <= month_end)]
donut_data = filtered_data[(filtered_data.Month >= month_start)
& (filtered_data.Month <= month_end)]
donut_data = percent(donut_data)
donut_data['angle'] = donut_data['value'] / sum(
donut_data['value']) * 2 * pi
donut_data['color'] = Category20c[donut_data.shape[0]]
avg_donut_data = percent_avg(filtered_data)
avg_donut_data = avg_donut_data[avg_donut_data.Month == month_end][[
'Sentimento', 'MAVG'
]]
avg_donut_data.columns = ['label', 'value']
avg_donut_data['angle'] = avg_donut_data['value'] / sum(
avg_donut_data['value']) * 2 * pi
avg_donut_data['color'] = Category20c[avg_donut_data.shape[0]]
top_data = filter_sentiment(filtered_data, metric_sentiment)
top_data = top_data[(top_data.Month >= month_start)
& (top_data.Month <= month_end)]
top_data = brand_health_txengages(top_data)
avg_top_data = round(top_data.score.mean(), 2)
top_data = top_data.sort_values('score', ascending=False).iloc[:10]
top_data = top_data.sort_values('score')
top_data['recorte'] = [
'1', '2', '3', '4', '5', '6', '7', '8', '9', '10'
]
# Converte dataframes em column data source
datasets = {
'ts': ColumnDataSource(ts_data),
'donut': ColumnDataSource(donut_data),
'avg_donut': ColumnDataSource(avg_donut_data),
'top': ColumnDataSource(top_data),
'avg_top': avg_top_data
}
return datasets
def update(attr, old, new):
"""Constrói os datasets para cada tipo de gráfico utilizado no dashboard
Parâmetros
----------
old : ColumnDataSource
Dataframe antigo relacionado aos filtros antigos
new : ColumnDataSource
Dataframe novo, com linhas filtradas de acordo com seleções mais recentes
"""
month_start = month_select.value_as_date[0]
month_end = month_select.value_as_date[1]
editorial = editorial_select.value
category = category_select.value
product = product_select.value
social_network = [
social_network_select.labels[i]
for i in social_network_select.active
]
metric = metric_select.value
metric_attr = get_metric_attr(metric)
metric_fun = metric_attr['fun']
metric_sentiment = metric_attr['sentiment']
new_src = make_dataset(metric_fun=metric_fun,
metric_sentiment=metric_sentiment,
month_start=month_start,
month_end=month_end,
editorial=editorial,
category=category,
social_network=social_network,
product=product)
src['ts'].data.update(new_src['ts'].data)
src['top'].data.update(new_src['top'].data)
src['avg_top'] = new_src['avg_top']
src['donut'].data.update(new_src['donut'].data)
src['avg_donut'].data.update(new_src['avg_donut'].data)
networks = data.SocialNetwork.unique().tolist()
editorials = get_multselect_options(data, 'Editoria')
categories = get_multselect_options(data, 'Categoria')
products = get_multselect_options(data, 'Produto')
month_select = DateRangeSlider(start=date(2019, 1, 1),
end=date(2019, 8, 1),
value=(date(2019, 1, 1), date(2019, 8, 1)),
step=1,
format="%b %Y")
metric_select = Select(value="gradiente",
options=[("velocity", "Parâmetro de Crise"),
("positivity", "Grau de Positividade"),
("gradiente", "Grau de Negatividade"),
("brand_health", "Saúde da Marca"),
("post_health", "Saúde do Post")])
product_select = MultiSelect(value=['Todos'], options=products)
category_select = MultiSelect(value=['Todos'], options=categories)
editorial_select = MultiSelect(value=['Todos'], options=editorials)
social_network_select = CheckboxGroup(labels=networks,
active=list(range(len(networks))))
metric_select.on_change('value', update)
month_select.on_change('value', update)
editorial_select.on_change('value', update)
category_select.on_change('value', update)
product_select.on_change('value', update)
social_network_select.on_change('active', update)
initial_metric_attr = get_metric_attr(metric_select.value)
metric_sentiment = initial_metric_attr['sentiment']
initial_networks = [
social_network_select.labels[i] for i in social_network_select.active
]
src = make_dataset(metric_fun=initial_metric_attr['fun'],
metric_sentiment=metric_sentiment,
month_start=month_select.value_as_date[0],
month_end=month_select.value_as_date[1],
editorial=editorial_select.value,
category=category_select.value,
social_network=initial_networks,
product=product_select.value)
p_ts = make_plot_ts(src['ts'], 'Evolução', metric_sentiment)
p_top = make_dotplot(src['top'])
avg_top = src['avg_top']
avg_top = create_div_title(f'Escore Médio: {avg_top}')
p_donut = make_plot_donut(src['donut'], 'Percentual')
p_avg_donut = make_plot_donut(src['avg_donut'], 'Norma Percentual')
metric_title = create_div_title('MÉTRICA')
month_title = create_div_title('PERÍODO')
network_title = create_div_title('REDE SOCIAL')
category_title = create_div_title('CATEGORIA')
editorial_title = create_div_title('EDITORIA')
product_title = create_div_title('PRODUTO')
controls = WidgetBox(
column(metric_title,
metric_select,
Div(height=5),
month_title,
month_select,
Div(height=5),
editorial_title,
editorial_select,
Div(height=5),
category_title,
category_select,
Div(height=5),
product_title,
product_select,
Div(height=5),
network_title,
social_network_select,
width=250))
plots = column(p_ts, Div(height=20), row(p_donut, p_avg_donut))
layout = row(controls, Div(width=50), plots)
layout = column(Div(text="", height=5), layout, Div(width=20), avg_top,
p_top)
tab = Panel(child=layout, title=name)
return tab
options=b_names,
size=12)
show_all_or_selected = Select(title="Show all data or selected:",
value="All",
options=["All", "selected"])
Reset_button = Button(label='Reset', button_type='warning')
source = get_dataset(data_all, test_ind, select_data_box.value,
multi_select.value)
p = make_plot(source)
select_data_box.on_change('value', update_plot)
multi_select.on_change('value', update_plot_chemistry)
multi_select_A_cation.on_change('value', update_plot_a_or_b)
multi_select_B_cation.on_change('value', update_plot_a_or_b)
Reset_button.on_click(reset_plot)
#select_data_box.on_change('value', update_plot)
#inputs = widgetbox(*controls)
selections = column(row(select_data_box, show_all_or_selected), multi_select,
row(multi_select_A_cation, multi_select_B_cation),
Reset_button)
curdoc().add_root(row(selections, p))
curdoc().title = "Weather"
#show()
# next(color_list)
# myString += '\n' + i
# myText.text = myString
multi_locations = sorted(list(df18['location'].unique()),
key=str.upper,
reverse=True)
multi_select = MultiSelect(title="Country:",
value=["0"],
size=7,
options=multi_locations,
height=200)
# myText = Paragraph(text='Initial Text', width=1200)
multi_select.on_change('value', update)
multi_select_widgetbox = widgetbox(multi_select)
# plot 1: rank vs student staff ratio
f = figure()
f.xaxis.axis_label = "rank"
f.yaxis.axis_label = "student staff ratio"
f.x_range = DataRange1d(start=0, end=1103)
f.y_range = DataRange1d(start=0, end=90)
f.legend.location = 'bottom_right'
# plot 3: percentage international vs percentage man (omdat size handig met t bolletje zelf kan)
h = figure()
h.xaxis.axis_label = "percentage international"
h.yaxis.axis_label = "percentage man"
h.x_range = DataRange1d(start=0, end=50)
except Exception as e:
annotation_output.text = "An error occured"
logger.error("Error: %s", e)
def mark_phrase_tag(text):
return "<phrase>" + text + "</phrase>"
# set callbacks
expand_button.on_click(get_expand_results_callback)
expand_table_source.selected.on_change("indices", row_selected_callback)
expand_table_source.on_change("data", expand_data_changed_callback)
checkbox_group.on_click(checkbox_callback)
search_input_box.on_change("value", search_callback)
phrases_list.on_change("value", vocab_phrase_selected_callback)
clear_seed_button.on_click(clear_seed_callback)
with open(join(dirname(__file__), "download.js")) as f:
code = f.read()
export_button.callback = CustomJS(args=dict(source=expand_table_source), code=code)
annotate_button.on_click(annotate_callback)
# table_area.on_change('children', table_area_change_callback)
# arrange components in page
doc = curdoc()
main_title = "Set Expansion Demo"
doc.title = main_title
doc.add_root(grid)
class GPE:
def __init__(self,offline=False,test_n_plots=6,test_n_samples=1000,max_row_width=4):
"""
Initialize Graph Projection Explorer
"""
print("\n\n" + '#' * 75)
print("Bokeh Graph Projection Explorer V.0.0.1")
print('Class Format')
print('#' * 75 + '\n\n')
self.test_n_plots = test_n_plots
self.test_n_samples = test_n_samples
self.max_row_width = max_row_width
self.testmode = False
self.n_newplots = 0
if offline:
# Operate in non command line argument mode
self.testmode = True
self.verbose = True
else:
parser = argparse.ArgumentParser()
parser.add_argument("--dir", help="directory housing data")
parser.add_argument("--mode", help="Options: Test, Presentation, Default")
parser.add_argument("--downsample", help="If provided, randomly samples the data the provided number of times")
parser.add_argument("--verbose", help="If True, Prints messages to console where server is running")
self.args = parser.parse_args()
try:
self.args.downsample = int(self.args.downsample)
except:
TypeError()
if self.args.verbose:
self.verbose = True
print "Verbose Turned On"
if isinstance(self.args.mode, str):
if self.args.mode.lower() == 'test':
if self.verbose:
print('Test Mode Selected')
self.testmode = True
else:
raise ValueError("Mode argument: " + self.args.mode + "Not among valid modes")
else:
raise ValueError("Mode Argument must be of type str. Instead recieved: " + str(type(self.args.mode)))
# Build Test Data if it exists
if self.testmode:
self.data_dir = self.gen_test_data()
else:
self.data_dir = self.args.dir
# Initialize
self.init_data()
self.init_color()
self.init_controls()
if self.verbose:
print("Initialization Timings")
print("\tData Init: "+str(self.init_data_time))
print("\tColor Init: " + str(self.init_color_time))
print("\tControl Init: " + str(self.init_control_time))
def read_data(self):
"""
:return:
"""
if self.verbose: print('\nReading Data\n')
# Check Data
assert os.path.isdir(self.data_dir)
vecdir = os.path.join(self.data_dir,'vectors')
graphdir = os.path.join(self.data_dir,'graphs')
assert os.path.isdir(vecdir)
try:
assert os.path.isdir(graphdir)
except AssertionError:
pass
vec_files = [os.path.join(vecdir,file) for file in os.listdir(vecdir) if file.endswith(".csv")]
vec_files.sort()
assert len(vec_files) > 0
self.plot_df = OrderedDict()
self.data_df = OrderedDict()
self.maps_dict = OrderedDict()
self.true_cols = []
self.initial_plot_2_data_mapper = {}
n_plot = 1
self.n_plots = 0
for i,f in enumerate(vec_files):
if self.verbose: print("Reading File: %s"%f)
file_prefix = f.split('/')[-1].split('.')[0] + "_"
df = pd.read_csv(f)
# Sometimes Unnamed: 0 creeps in by mistake of the user
if "Unnamed: 0" in df.columns:
df.drop(["Unnamed: 0"],axis=1,inplace=True)
# Confirm Data Dim
if i == 0:
self.n,p = df.shape
else:
n,p = df.shape
#assert n == self.n
if isinstance(self.args.downsample, int):
if self.verbose: print("Downsampling: %d"%self.args.downsample)
df = df.sample(n=int(self.args.downsample),replace=False,random_state=1,axis=0)
print(df.shape)
self.n, p = df.shape
# Test if D1 and D2 columns are found
has_d1 = 0
has_d2 = 0
for col in df.columns:
if 'D1' in col:
has_d1 += 1
elif 'D2' in col:
has_d2 += 1
if has_d1 == 1 and has_d2 == 1:
has_both = True
else:
has_both = False
if has_d1 > 1:
warnings.warn("Too many column headers contain D1, cannot disambiguate")
if has_d2 > 1:
warnings.warn("Too many column headers contain D2, cannot disambiguate")
if has_d1 != has_d2:
warnings.warn("The number of D1 and D2 variable do not match")
# Now that data validation is done, actually add data to self.df
for col in df.columns:
if 'D1' in col and has_both:
self.data_df[file_prefix + col] = df[col].values.tolist()
self.plot_df['Plot_%d_x' % n_plot] = df[col].values.tolist()
self.plot_df[file_prefix + col] = df[col].values.tolist()
self.true_cols.append(file_prefix + col)
self.initial_plot_2_data_mapper['Plot_%d_x' % n_plot] = file_prefix + col
elif 'D2' in col and has_both:
self.data_df[file_prefix + col] = df[col].values.tolist()
self.plot_df['Plot_%d_y' % n_plot] = df[col].values.tolist()
self.plot_df[file_prefix + col] = df[col].values.tolist()
self.true_cols.append(file_prefix + col)
self.initial_plot_2_data_mapper['Plot_%d_y' % n_plot] = file_prefix + col
else:
self.data_df[file_prefix + col] = df[col].values.tolist()
self.plot_df[file_prefix + col] = df[col].values.tolist()
self.true_cols.append(file_prefix + col)
if has_both:
self.maps_dict["Plot_%d" % n_plot] = ('Plot_%d_x' % n_plot,'Plot_%d_y' % n_plot)
n_plot += 1
def init_data(self):
"""
Load and Validate Data
:return:
"""
t0 = time()
if self.verbose: print("Initializing Data Resources")
self.read_data()
self.n_plots = len(self.maps_dict.keys())
self.color = "__COLOR__"
self.plot_df["__COLOR__"] = ["#80bfff"] * self.n
self.plot_df["__selected__"] = np.ones_like(self.n, dtype=np.bool).tolist()
self.data_df = pd.DataFrame(self.data_df)
self.data_dict = self.data_df.to_dict(orient='list')
assert isinstance(self.data_dict, dict)
self.plot_df = pd.DataFrame(self.plot_df)
self.plot_dict = self.plot_df.to_dict(orient='list')
assert isinstance(self.data_dict, dict)
# Used for indexing Selected Data
self.inds_bool = np.ones_like(np.arange(self.n), dtype=np.bool)
self.source = ColumnDataSource(data=self.plot_dict)
self.table_source = ColumnDataSource(data=self.plot_df[self.true_cols].to_dict(orient='list'))
self.init_data_time = time() - t0
return self.init_data_time
def gen_test_data(self):
"""
Generate Test Data, Store in temp dir and return dir path
:return: dir path
"""
if self.verbose: print('Generating Test Data')
# Initialize Temp Testing Dir Structure
tmpdir = tempfile.mkdtemp()
tmpdir_p = os.path.join(tmpdir,'vectors')
tmpdir_g = os.path.join(tmpdir,'graphs')
os.mkdir(tmpdir_p)
os.mkdir(tmpdir_g)
assert isinstance(self.test_n_plots, int)
assert isinstance(self.test_n_samples, int)
# Make Blob data
X, y = make_blobs(n_samples=self.test_n_samples, n_features=self.test_n_plots * 2,
centers=6, cluster_std=0.75, random_state=1)
# Store blob data in test dir
for i in range(self.test_n_plots):
cols = X[:, (i * 2):((i * 2) + 2)]
#cols[np.random.choice(range(self.test_n_samples),1),:] = [np.null,np.null]
df = pd.DataFrame(data=cols, columns=('D1','D2'))
df.to_csv(os.path.join(tmpdir_p,'P%d.csv'%i))
meta_df = pd.DataFrame({'Meta':['Class: ' + str(label) for label in y]})
meta_df.to_csv(os.path.join(tmpdir_p, 'Meta.csv'))
# Generate Graph Data
# TODO
return tmpdir
def init_color(self):
"""
:return:
"""
t0 = time()
if self.verbose: print("Initializing Color Resources")
self.color_map_dict = {col: list(enumerate(get_color_map(self.data_dict[col]))) for col in self.data_dict.keys()}
self.init_color_time = time() - t0
return self.init_color_time
def init_controls(self):
"""
:return:
"""
t0 = time()
if self.verbose: print("Initializing Controls")
# Initialize Controls
self.color_selection = Select(title="Color By", options=self.data_dict.keys(), value=self.data_dict.keys()[0])
self.selection_label = TextInput(value="MyGroup#1", title="Selection Label:")
self.add_selection_label = Button(label="Add Selection Label")
self.write_mod_file = Button(label="Download", button_type="primary")
self.write_mod_file.callback = CustomJS(args=dict(source=self.source),
code=open(os.path.join(os.path.dirname(__file__),
"download.js")).read())
self.tooltip_select = MultiSelect(title='Tooltip',value = [self.data_dict.keys()[0]],
options=[(key,key.upper()) for key in self.data_dict.keys()])
# Declare Tooltip Contents
self.tooltip_list = [(col, "@" + col) for col in self.tooltip_select.value]
self.init_control_time = time() - t0
return self.init_control_time
def add_selection(self):
"""
Add new column to source containing copy of selection
:return:
"""
self.source.add(self.source.data['__selected__'],name=self.selection_label.value)
def make_plot(self,title, x, y):
"""
:param title:
:param x:
:param y:
:return:
"""
print(title,x,y)
t0 = time()
pt = PanTool()
lst = LassoSelectTool()
pst = PolySelectTool()
bst = BoxSelectTool()
wzt = WheelZoomTool()
tt = TapTool()
st = SaveTool()
ut = UndoTool()
rt = RedoTool()
p = figure(
tools=[pt,lst,pst,bst,wzt,tt,st,ut,rt],
plot_width=400,
plot_height=400,
title=self.initial_plot_2_data_mapper[x]+" vs. "+self.initial_plot_2_data_mapper[y],
webgl=accelerator)
# configure so that no drag tools are active
p.toolbar.active_drag = pt
# configure so that Bokeh chooses what (if any) scroll tool is active
p.toolbar.active_scroll = wzt
# configure so that a specific PolySelect tap tool is active
p.toolbar.active_tap = tt
p.xaxis.axis_label = self.initial_plot_2_data_mapper[x]
p.yaxis.axis_label = self.initial_plot_2_data_mapper[y]
c = p.circle(x=x, y=y, size=5, color="__COLOR__", alpha=.75, source=self.source,
hover_color='white', hover_alpha=1, hover_line_color='grey')
c.data_source.on_change('selected', self.update)
# Edge generator
'''
self.graph_set = [{i: [[1,0.15],[2,0.5],[3,0.99]] for i in range(self.n)}]
self.edge_colors = qual_2_color(['g'+str(i) for i,_ in enumerate(self.graph_set)])
self.edge_sources = [ColumnDataSource({'x0': [],
'y0': [],
'x1': [],
'y1': [],
'alpha': []})
for i in self.graph_set]
self.edge_segments = [p.segment(x0='x0',
y0='y0',
x1='x1',
y1='y1',
color=self.edge_colors[i],
alpha='alpha',
line_width=3,
#line_dash=[1,1],
source=self.edge_sources[i])
for i, _ in enumerate(self.graph_set)]
for i, _ in enumerate(self.graph_set):
code1 = """
var links = %s;
var data = {'x0': [], 'y0': [], 'x1': [], 'y1': [], 'alpha': []};
var cdata = circle.get('data');
var indices = cb_data.index['1d'].indices;
for (i=0; i < indices.length; i++) {
ind0 = indices[i]
for (j=0; j < links[ind0].length; j++) {
ind1 = links[ind0][j][0];
w = links[ind0][j][1];
""" % self.graph_set[i]
code2 = "data['x0'].push(cdata['" + x + "'][ind0]);\n" + \
"data['y0'].push(cdata['" + y + "'][ind0]);\n" + \
"data['x1'].push(cdata['" + x + "'][ind1]);\n" + \
"data['y1'].push(cdata['" + y + "'][ind1]);\n" + \
"data['alpha'].push([w]);\n"
code3 = "}}segment.set('data', data);"
code = code1 + code2 + code3
callback = CustomJS(args={'circle': c.data_source,
'segment': self.edge_segments[i].data_source},
code=code)
p.add_tools(HoverTool(tooltips=None, callback=callback, renderers=[c]))
'''
p.select(BoxSelectTool).select_every_mousemove = False
p.select(LassoSelectTool).select_every_mousemove = False
# Plot Controls
xdim_select = Select(title="X Dim", options=self.data_dict.keys(), value=self.initial_plot_2_data_mapper[x],width=400)
ydim_select = Select(title="Y Dim", options=self.data_dict.keys(), value=self.initial_plot_2_data_mapper[y],width=400)
xdim_select.on_change('value', self.plot_update)
ydim_select.on_change('value', self.plot_update)
remove = Button(label="Remove", button_type="danger",width=400)
remove.on_click(partial(self.remove_plot,title,x,y))
self.plot_control_dict[title] = {'x':xdim_select,
'y':ydim_select,
'xprev':xdim_select.value,
'yprev':ydim_select.value,
'figure':p,
'tooltip':HoverTool(tooltips=self.tooltip_list,point_policy='snap_to_data',show_arrow=False)}
# Give the hover tool a tool tip
self.plot_control_dict[title]['figure'].add_tools(self.plot_control_dict[title]['tooltip'])
# Form Tab
plot_options = WidgetBox(xdim_select,ydim_select,remove)
tab1 = Panel(child=self.plot_control_dict[title]['figure'], title=title,width=400,height=400)
tab2 = Panel(child=plot_options, title="options",width=400,height=400)
tabs = Tabs(tabs=[tab1, tab2],width=400,height=400)
self.tab_list.append(tabs)
self.circle_list.append(c)
print('Plot Time: ' + str(time() - t0))
return tabs, c
def change_color(self,attrname, old, new):
"""
Change Color
:return:
"""
if self.verbose: print("---self.change_color---")
self.source.patch({"__COLOR__": self.color_map_dict[self.color_selection.value]})
if self.verbose: print('New Color: '+self.color_selection.value)
def refresh_plots(self):
"""
Refresh plots
:return:
"""
if self.verbose: print('---self.refresh_plots---')
print(self.layout)
print(self.layout.children)
self.layout.children[0] = self.make_all_plots()
print(self.layout)
print(self.layout.children)
#controls = self.make_all_controls()
#dt = self.make_data_table()
#self.layout.children[1] = row(controls, dt)
def add_plot(self):
"""
Add new plot to the
:return:
"""
if self.verbose: print('---self.add_plot---')
self.n_newplots += 1
d1 = self.true_cols[np.random.randint(len(self.true_cols))]
d2 = self.true_cols[np.random.randint(len(self.true_cols))]
self.source.add(self.source.data[d1],name='NewPlot%d_x'%self.n_newplots)
self.source.add(self.source.data[d2], name='NewPlot%d_y'%self.n_newplots)
self.maps_dict['NewPlot%d'%self.n_newplots] = ('NewPlot%d_x'%self.n_newplots,
'NewPlot%d_y'%self.n_newplots)
self.initial_plot_2_data_mapper['NewPlot%d_x'%self.n_newplots] = d1
self.initial_plot_2_data_mapper['NewPlot%d_y'%self.n_newplots] = d2
if self.verbose: print('---self.add_plot---Done')
self.refresh_plots()
def remove_plot(self,plot_title,x,y):
"""
Removes a plot
:return:
"""
if self.verbose: print('\n---self.remove_plot---')
print('Getting Rid of')
print(self.maps_dict[plot_title])
self.maps_dict.pop(plot_title)
print(x,y)
#self.source.data.pop(x)
#self.source.data.pop(y)
print('After poping')
print(self.maps_dict)
print(self.source.data.keys())
pprint(self.source.data)
self.refresh_plots()
def dist_plot(self):
"""
:return:
"""
dist_plots = []
self.dist_dict = {}
for col in self.true_cols[0:8]:
x = self.data_dict[col]
# create the horizontal histogram
hhist, hedges = np.histogram(x, bins=20)
hzeros = np.zeros(len(hedges) - 1)
hmax = max(hhist) * 1.1
LINE_ARGS = dict(color="#3A5785", line_color=None)
ph = figure(toolbar_location=None, plot_width=200, plot_height=100,title=col,
y_range=(0, hmax), y_axis_location="left")
ph.xgrid.grid_line_color = None
ph.yaxis.major_label_orientation = np.pi / 4
ph.background_fill_color = "#fafafa"
ph.quad(bottom=0, left=hedges[:-1], right=hedges[1:], top=hhist, color="white", line_color="#3A5785")
hh1 = ph.quad(bottom=0, left=hedges[:-1], right=hedges[1:], top=hzeros, alpha=0.5, **LINE_ARGS)
# Add to dist dict
self.dist_dict[col] = {'plot':ph,
'hh1':hh1,
'hedges':hedges}
# Add to grid plot
dist_plots.append(ph)
gp = gridplot(dist_plots, plot_width=300, plot_height=200, ncols=4, height=400,toolbar_location=None,)
return gp
def make_all_plots(self):
"""
:return:
"""
self.tab_list = []
self.plot_list = []
self.circle_list = []
self.plot_control_dict = {}
self.n_plots = len(self.maps_dict.keys())
# Make Each Plot
for f in self.maps_dict.keys():
xs = self.maps_dict[f][0]
ys = self.maps_dict[f][1]
self.make_plot(f, xs, ys)
#if self.verbose: print("Grid of plots: "+str(self.tab_list))
return gridplot(self.tab_list,ncols=self.max_row_width,plot_width=250, plot_height=250)
def make_all_controls(self):
# Controls
self.addplot = Button(label="Add New Plot", button_type="success")
self.addplot.on_click(self.add_plot)
self.add_selection_label.on_click(self.add_selection)
self.tooltip_select.on_change('value',self.tooltip_update)
self.color_selection.on_change('value',self.change_color)
controls = [self.color_selection,
self.tooltip_select,
self.selection_label,
self.add_selection_label,
self.addplot,
self.write_mod_file]
return widgetbox(children=controls)
def pseudo_update(self,n_selected):
"""
:param n_selected:
:return:
"""
assert self.n >= n_selected
pseudo_selected = np.random.choice(np.arange(self.n),size=n_selected)
pseudo_new = {'1d':{'indices':pseudo_selected}}
self.update(1,1,pseudo_new)
def tooltip_update(self,attrname, old, new):
"""
Updates tooltip content for each plot
:param attrname:
:param old:
:param new:
:return:
"""
if self.verbose: print("\n------self.tooltip_update-----")
self.tooltip_list = [(col.encode("utf-8"), "@" + col.encode("utf-8")) for col in self.tooltip_select.value]
self.refresh_plots()
#if self.verbose: print(contents)
#for p in self.plot_control_dict:
# self.plot_control_dict[p]['tooltip'].tooltips = contents
# self.plot_control_dict[p]['tooltip'].plot = self.plot_control_dict[p]['figure']
# if self.verbose: print(self.plot_control_dict[p]['tooltip'].tooltips)
def plot_update(self,attrname, old, new):
"""
Updates plot contents, title and axis labels
:param attrname:
:param old:
:param new:
:return:
"""
# modify column value of data source
if self.verbose: print("\n------self.plot_update-----")
for p in self.plot_control_dict:
xy_mod = False
# X
if self.plot_control_dict[p]['x'].value != self.plot_control_dict[p]['xprev']:
if self.verbose: print('X change on %s'%p)
# patch
self.source.patch({p+"_x": list(enumerate(self.data_dict[self.plot_control_dict[p]['x'].value]))})
# update prev
self.plot_control_dict[p]['xprev'] = self.plot_control_dict[p]['x'].value
self.plot_control_dict[p]['figure'].xaxis.axis_label = self.plot_control_dict[p]['x'].value
xy_mod = True
# Y
if self.plot_control_dict[p]['y'].value != self.plot_control_dict[p]['yprev']:
if self.verbose: print('Y change on %s' % p)
# patch
self.source.patch({p+"_y": list(enumerate(self.data_dict[self.plot_control_dict[p]['y'].value]))})
# update prev
self.plot_control_dict[p]['yprev'] = self.plot_control_dict[p]['y'].value
self.plot_control_dict[p]['figure'].yaxis.axis_label = self.plot_control_dict[p]['y'].value
xy_mod = True
# update title text
if xy_mod:
self.plot_control_dict[p]['figure'].title.text = self.plot_control_dict[p]['x'].value + " vs. " + self.plot_control_dict[p]['y'].value
def update(self,attrname, old, new):
"""
:param attrname:
:param old:
:param new:
:return:
"""
if self.verbose: print("\n------self.update-----")
t0 = time()
# Update Selected
try:
inds = np.array(new['1d']['indices'])
if len(inds) == 0 or len(inds) == self.n:
print("NOTHING SELECTED")
pass
else:
print('Selected Set Size: ' + str(len(inds)))
# Modify Dist Plots
if self.verbose: print('\tUpdating DistPlots')
for dist in self.dist_dict:
x = np.array(self.data_dict[dist])
xbins = self.dist_dict[dist]['hedges']
hhist1, _ = np.histogram(x[inds], bins=xbins)
self.dist_dict[dist]['hh1'].data_source.data["top"] = hhist1
# Modify Data Table
indbool = self.inds_bool
indbool[inds] = False
self.source.patch({"__selected__":list(enumerate(indbool))})
full_table_dict = self.data_dict
self.table_source.data = {col: np.array(full_table_dict[col])[inds] for col in full_table_dict.keys()}
# Hack to stop string index type error that occurs when you change color
except FloatingPointError:
print("NOTHING SELECTED, error caught")
pass
self.update_time = time()-t0
print(self.update_time)
def make_data_table(self):
# Add Table
columns = [TableColumn(field=col, title=col) for col in self.data_df.keys()]
dt = DataTable(source=self.table_source,
columns=columns,
width=1800,
height=400,
scroll_to_selection=False)
return WidgetBox(dt)
def go(self):
"""
:return:
"""
print("\n\n" + '#' * 75)
print("Server Engaged")
print('#' * 75 + '\n\n')
plots = self.make_all_plots()
controls = self.make_all_controls()
dt = self.make_data_table()
dp = self.dist_plot()
dp = gridplot(dp, plot_width=300, plot_height=200, ncols=2, height=400)
dp = Panel(child=dp, title="Distribution Plot", width=400, height=400)
dt = Panel(child=dt, title="Data Table", width=400, height=400)
dtdp = Tabs(tabs=[dp,dt],width=400,height=400)
self.layout = column(children=[plots,row(controls,dtdp)])
curdoc().add_root(self.layout)
curdoc().title = 'Graph Projection Explorer'
class CityBikeAnalysis:
def __init__(self,
log_file,
city='Oslo',
coord_mapping_file='',
altitude_file=''):
self.city = city
self.station_info_file = 'station_info.csv'
self.df_s_info = pd.read_csv(self.station_info_file, index_col=0)
self.df_s_info.index = self.df_s_info.index.astype(str)
self.tz_offset = pd.Timedelta('0h')
self.log_file = log_file
self.df_log = pd.read_csv(log_file)
self.re_index()
self.stations = [
str(s_id) for s_id in np.sort(self.df_log['station_id'].unique())
]
self.df_bikes_avail = pd.DataFrame()
self.df_docs_avail = pd.DataFrame()
self.pivot_df()
self.df_bikes_source = pd.DataFrame()
self.df_docks_source = pd.DataFrame()
if os.path.isfile(altitude_file):
self.df_altitude = pd.read_csv(altitude_file, index_col=0)
self.id_coord_mapping_df = pd.DataFrame()
if os.path.isfile(coord_mapping_file):
s_mod = os.path.getmtime(coord_mapping_file)
s_now = datetime.datetime.now().timestamp()
if s_mod < (s_now - 3600):
self.id_coord_mapping_df = self.make_station_coord_transformed_df(
self.get_station_info())
with open(coord_mapping_file, 'wb') as handle:
pickle.dump(self.id_coord_mapping_df,
handle,
protocol=pickle.HIGHEST_PROTOCOL)
# TODO Do not overwrite?
else:
with open('mapping_df.pickle', 'rb') as handle:
self.id_coord_mapping_df = pickle.load(handle)
if city == 'Oslo':
self.mid_lat, self.mid_lon = pyproj.transform(
pyproj.Proj(init='epsg:4326'), pyproj.Proj(init='epsg:3857'),
10.735, 59.928) # Center of map location
self.coord_range_delta = 7500
elif city == 'NewYorkCity':
self.mid_lat, self.mid_lon = pyproj.transform(
pyproj.Proj(init='epsg:4326'), pyproj.Proj(init='epsg:3857'),
-73.973, 40.736)
self.coord_range_delta = 12500
# Colors
self.empty_color = "#7e7e7e"
self.avail_color = "#87e03e"
self.full_color = "#ff2332"
x_mul_sel_opt = [(s, s + ' | ' + name) for s, name in zip(
self.stations,
self.df_s_info.reindex(self.stations, fill_value='Unknown')
['name'])]
self.x_mul_select = MultiSelect(
title="Stations",
value=[self.stations[0], self.stations[1]],
options=x_mul_sel_opt,
size=8)
self.x_mul_select.on_change('value', self.x_mul_select_callback)
s_date = datetime.date.fromtimestamp(
self.df_bikes_avail.index[0].value / 10**9)
e_date = datetime.date.fromtimestamp(
self.df_bikes_avail.index[-1].value / 10**9)
e_date += datetime.timedelta(days=1)
self.dr_slider = DateRangeSlider(
title='Date Range',
start=s_date,
end=e_date,
step=24,
value=(e_date - datetime.timedelta(days=5), e_date),
callback_throttle=500)
self.dr_slider.on_change('value', self.date_rage_slider_callback)
self.range_slider = RangeSlider(title='Time of day',
start=5,
end=25,
step=1,
value=(5, 25))
self.range_slider.on_change('value', self.hour_rage_slider_callback)
self.histogram_policy = RadioButtonGroup(
labels=["Aggregate", "Flatten"], active=0)
self.histogram_policy.on_change('active',
self.histogram_policy_callback)
self.x_select = Select(title="X-axis",
value=self.stations[0],
options=self.stations)
self.x_select.on_change('value', self.x_select_callback)
self.y_select = Select(title="Y-axis",
value=self.stations[1],
options=self.stations)
self.y_select.on_change('value', self.y_select_callback)
self.create_sliced_df()
self.station_history_fig, self.station_history_fig_source = self.create_station_history_fig(
)
self.station_avail_histogram, self.station_avail_histogram_source = self.create_station_avail_histogram(
)
self.extremes_annulus, self.extremes_annulus_source = self.create_extremes_figure(
)
self.station_map_fig, self.station_map_fig_source = self.create_station_map(
)
self.station_map_fig_source.selected.indices = [
self.id_coord_mapping_df.index.get_loc(s)
for s in self.x_mul_select.value
]
self._layout = column(
row(
column(self.x_mul_select, self.dr_slider, self.range_slider,
self.histogram_policy, self.extremes_annulus),
self.station_avail_histogram, self.station_map_fig),
row(self.station_history_fig))
# row(column(self.x_select, self.y_select), self.two_station_heatmap()))
@property
def layout(self):
return self._layout
def re_index(self):
self.df_log.index = pd.to_datetime(10**9 *
self.df_log['last_reported'])
self.df_log.drop(['last_reported'], axis=1, inplace=True)
self.df_log.index.tz_localize('UTC').tz_convert('Europe/Oslo')
def pivot_df(self):
def get_column_mapper(df):
d = {}
for col in df.columns.values:
d[col] = str(col)
return d
self.df_bikes_avail = self.df_log.pivot_table(
index='last_reported',
columns='station_id',
values='num_bikes_available')
self.df_bikes_avail.rename(columns=get_column_mapper(
self.df_bikes_avail),
inplace=True)
self.df_docs_avail = self.df_log.pivot_table(
index='last_reported',
columns='station_id',
values='num_docks_available')
self.df_docs_avail.rename(columns=get_column_mapper(
self.df_docs_avail),
inplace=True)
def create_sliced_df(self):
s_hour = self.range_slider.value[0]
e_hour = self.range_slider.value[1]
if e_hour == 25:
hours_of_day = self.df_bikes_avail.index.hour.isin(
np.append([0], range(s_hour, e_hour - 1)))
else:
hours_of_day = self.df_bikes_avail.index.hour.isin(
range(s_hour, e_hour))
df_bikes_sliced = self.df_bikes_avail.loc[
hours_of_day][self.dr_slider.value_as_datetime[0]:self.dr_slider.
value_as_datetime[1]]
df_docks_sliced = self.df_docs_avail.loc[
hours_of_day][self.dr_slider.value_as_datetime[0]:self.dr_slider.
value_as_datetime[1]]
self.df_bikes_source = df_bikes_sliced.loc[:, [
val for val in self.x_mul_select.value
]].fillna(0) # TODO Filling nan with 0 might not be best solution
self.df_docks_source = df_docks_sliced.loc[:, [
val for val in self.x_mul_select.value
]].fillna(0) #
def create_station_history_fig(self):
source_dict = self.create_station_history_fig_source_dict()
source = ColumnDataSource(source_dict)
fig = figure(plot_width=800, plot_height=600, x_axis_type='datetime')
colors = Category20[20][::2]
for val, color in zip(self.x_mul_select.value, colors):
fig.step('last_reported',
val,
color=color,
legend=value(val),
source=source)
return fig, source
def create_station_history_fig_source_dict(self):
df_sliced = self.df_bikes_avail[self.dr_slider.value_as_datetime[0]:
self.dr_slider.value_as_datetime[1]]
df_source = df_sliced.loc[:, [val for val in self.x_mul_select.value]]
df_source.index = df_source.index + self.tz_offset
df_source = df_source.reset_index()
return df_source.to_dict(orient='list')
def create_station_avail_histogram(self):
d = self.create_station_avail_histogram_source_dict()
source = ColumnDataSource(d)
fig = figure(plot_width=800,
plot_height=600,
title='Histogram of availability',
background_fill_color="#fafafa")
fig.quad(top='top',
bottom=0,
left='left',
right='right',
color="colors",
line_color="white",
alpha=0.9,
source=source)
fig.y_range.start = 0
# fig.legend.location = "center_right"
# fig.legend.background_fill_color = "#fefefe"
x_labl = 'x, Available bikes in station' if len(
self.x_mul_select.value) == 1 else 'x, Available bikes in stations'
fig.xaxis.axis_label = x_labl
fig.yaxis.axis_label = 'P(x)'
fig.grid.grid_line_color = "white"
return fig, source
def create_station_avail_histogram_source_dict(self):
if self.histogram_policy.labels[
self.histogram_policy.active] == 'Flatten':
df_bikes_source = self.df_bikes_source
df_docks_source = self.df_docks_source
elif self.histogram_policy.labels[
self.histogram_policy.active] == 'Aggregate':
df_bikes_source = self.df_bikes_source.sum(axis=1)
df_docks_source = self.df_docks_source.sum(axis=1)
else:
df_bikes_source = self.df_bikes_source
df_docks_source = self.df_docks_source
b = np.array((range(-1, int(df_bikes_source.max().max()) + 1))) + 0.5
hist, edges = np.histogram(df_bikes_source, density=True, bins=b)
colors = np.array([self.avail_color] * (len(hist)))
if np.any(df_bikes_source.values == 0):
colors[0] = self.empty_color
if np.any(df_docks_source.values == 0):
colors[-1] = self.full_color # TODO Add for all
d = dict(top=hist, left=edges[:-1], right=edges[1:], colors=colors)
return d
def create_extremes_figure(self):
fig = figure(title='Availability summary',
width=300,
height=300,
x_range=(-100, 100),
y_range=(-100, 100),
tools='')
fig.axis.visible = False
fig.grid.visible = False
fig.outline_line_alpha = 0.0
source = ColumnDataSource(self.create_extremes_figure_source_dict())
fig.annular_wedge(x=0,
y=0,
inner_radius=50,
outer_radius=75,
start_angle=0,
end_angle='end_angle_empty',
color=self.empty_color,
source=source) # Totally empty
fig.annular_wedge(x=0,
y=0,
inner_radius=50,
outer_radius=75,
start_angle='end_angle_empty',
end_angle='end_angle_mid',
color=self.avail_color,
source=source) # Not empty, not full
fig.annular_wedge(x=0,
y=0,
inner_radius=50,
outer_radius=75,
start_angle='end_angle_mid',
end_angle=2 * np.pi,
color=self.full_color,
source=source) # Totally full
fig.circle(x=0, y=0, radius=50, color="#fafafa")
fig.text(x=0,
y=14,
text='empty_percent',
text_color=self.empty_color,
text_baseline='bottom',
text_align='center',
text_font_size='16pt',
text_font_style='bold',
source=source)
fig.text(x=0,
y=0,
text='avail_percent',
text_color=self.avail_color,
text_baseline='middle',
text_align='center',
text_font_size='21pt',
text_font_style='bold',
source=source)
fig.text(x=0,
y=-14,
text='full_percent',
text_color=self.full_color,
text_baseline='top',
text_align='center',
text_font_size='16pt',
text_font_style='bold',
source=source)
return fig, source
def create_extremes_figure_source_dict(self):
df_bikes_source = self.df_bikes_source.sum(axis=1)
df_docks_source = self.df_docks_source.sum(axis=1)
d = dict(end_angle_empty=[
2 * np.pi * np.count_nonzero(df_bikes_source.values == 0) /
len(df_bikes_source.values)
],
end_angle_mid=[
2 * np.pi *
(1 - (np.count_nonzero(df_docks_source.values == 0) /
len(df_docks_source.values)))
])
d['empty_percent'] = [
f"{100 * (np.abs(d['end_angle_empty'][0]) / (2 * np.pi)):2.1f}% "
] # TODO deal with nan
d['avail_percent'] = [
f"{100*(np.abs(d['end_angle_mid'][0] - d['end_angle_empty'][0])/(2 * np.pi)):.1f}%"
] # TODO deal with nan
d['full_percent'] = [
f"{100 * (np.abs(2 * np.pi - d['end_angle_mid'][0]) / (2 * np.pi)):.1f}%"
] # TODO deal with nan
return d
def create_station_map(self):
fig = figure(
plot_width=780,
plot_height=600,
title='Stations map and selector',
tools=['pan', 'box_zoom', 'wheel_zoom', 'lasso_select', 'reset'],
x_range=(self.mid_lat - self.coord_range_delta,
self.mid_lat + self.coord_range_delta),
y_range=(self.mid_lon - self.coord_range_delta,
self.mid_lon + self.coord_range_delta),
x_axis_type="mercator",
y_axis_type="mercator")
fig.add_tile(CARTODBPOSITRON)
lst = fig.select(dict(type=LassoSelectTool))[0]
lst.select_every_mousemove = False
# # Bikes available
# fig.annular_wedge(x=status_df['x_proj'], y=status_df['y_proj'], color=self.avail_color,
# inner_radius=np.zeros(len(status_df)), outer_radius=25 * np.sqrt(status_df['num_docs']),
# start_angle=(np.pi / 2 + np.zeros(len(status_df))),
# end_angle=(np.pi / 2 - status_df['docks_start_ang']), direction='clock')
# # Docks available
# fig.annular_wedge(x=status_df['x_proj'], y=status_df['y_proj'], color="#ea6d3f",
# inner_radius=np.zeros(len(status_df)), outer_radius=25 * np.sqrt(status_df['num_docs']),
# start_angle=(np.pi / 2 - status_df['docks_start_ang']),
# end_angle=(10 ** (-3) + np.pi / 2 * np.ones(len(status_df))), direction='clock')
#
# fig.text(x=status_df['x_proj'], y=status_df['y_proj'], text=status_df.index)
source = ColumnDataSource(self.id_coord_mapping_df)
c = fig.circle(x='x_proj',
y='y_proj',
size=10,
color="navy",
source=source)
fig.text(x='x_proj', y='y_proj', text='station_id', source=source)
c.data_source.selected.on_change('indices', self.lasso_select_callback)
return fig, source
def two_station_heatmap(self):
fig = figure(width=700, match_aspect=True, tools='')
fig.xgrid.grid_line_color = None
fig.ygrid.grid_line_color = None
s_id1, s_id2 = self.x_select.value, self.y_select.value
df_counts = self.df_bikes_avail.groupby(
[s_id1, s_id2]).size().reset_index(name='counts')
df_counts.rename(columns={s_id1: s_id1, s_id2: s_id2}, inplace=True)
source = ColumnDataSource(df_counts)
pallette = [
'#084594', '#2171b5', '#4292c6', '#6baed6', '#9ecae1', '#c6dbef',
'#deebf7', '#f7fbff'
][::-1]
mapper = LinearColorMapper(palette=pallette,
low=0,
high=df_counts.counts.max())
color_bar = ColorBar(color_mapper=mapper)
fig.rect(x=str(s_id1),
y=str(s_id2),
width=1.0,
height=1.0,
line_alpha=0.0,
fill_color=transform('counts', mapper),
source=source)
fig.add_layout(color_bar, 'right')
return fig
def lasso_select_callback(self, attr, old, new):
# print(self.id_coord_mapping_df.iloc[new].index.values)
if new:
self.x_mul_select.value = list(
self.id_coord_mapping_df.iloc[new].index.values)
def get_station_info(self):
if self.city == 'Oslo':
json_url = "https://gbfs.urbansharing.com/oslobysykkel.no/station_information.json"
elif self.city == 'NewYorkCity':
json_url = "https://gbfs.citibikenyc.com/gbfs/es/station_information.json"
with urllib.request.urlopen(json_url) as url:
station_info = json.loads(url.read().decode())
return station_info
# @staticmethod
def make_station_coord_transformed_df(self, station_info_in):
def apply_transfomation(lon_in, lat_in):
return pyproj.transform(pyproj.Proj(init='epsg:4326'),
pyproj.Proj(init='epsg:3857'), lon_in,
lat_in)
lon = [s['lon'] for s in station_info_in['data']['stations']]
lat = [s['lat'] for s in station_info_in['data']['stations']]
x_proj, y_proj = zip(*map(apply_transfomation, lon, lat))
index = [s['station_id'] for s in station_info_in['data']['stations']]
df = pd.DataFrame(data={
'x_proj': x_proj,
'y_proj': y_proj
},
index=index)
df.index.name = 'station_id'
return df
def update(self):
t_start = time()
self.station_history_fig, self.station_history_fig_source = self.create_station_history_fig(
)
self.station_avail_histogram, self.station_avail_histogram_source = self.create_station_avail_histogram(
)
print(f"Used: {(time() - t_start) * 1000} ms to regenerate figures")
t_start = time()
self._layout.children[0].children[1] = self.station_avail_histogram
self._layout.children[1].children[0] = self.station_history_fig
print(f"Used: {(time() - t_start)*1000} ms to update layout")
# self._layout.children[1].children[1] = self.two_station_heatmap()
def y_select_callback(self, attr, old, new):
self.update()
def x_select_callback(self, attr, old, new):
self.update()
def x_mul_select_callback(self, attr, old, new):
self.create_sliced_df()
self.station_history_fig, self.station_history_fig_source = self.create_station_history_fig(
)
self.station_avail_histogram, self.station_avail_histogram_source = self.create_station_avail_histogram(
)
self.extremes_annulus_source.data = self.create_extremes_figure_source_dict(
)
self.station_map_fig_source.selected.indices = [
self.id_coord_mapping_df.index.get_loc(s)
for s in self.x_mul_select.value
]
self._layout.children[0].children[1] = self.station_avail_histogram
self._layout.children[1].children[0] = self.station_history_fig
def date_rage_slider_callback(self, attr, old, new):
t_start = time()
self.create_sliced_df()
self.station_history_fig_source.data = self.create_station_history_fig_source_dict(
)
self.station_avail_histogram_source.data = self.create_station_avail_histogram_source_dict(
)
self.extremes_annulus_source.data = self.create_extremes_figure_source_dict(
)
print(f"Used: {(time() - t_start) * 1000} ms to calculate sources")
def hour_rage_slider_callback(self, attr, old, new):
t_start = time()
# self.station_history_fig_source.data = self.create_station_history_fig_source_dict()
self.create_sliced_df()
self.extremes_annulus_source.data = self.create_extremes_figure_source_dict(
)
self.station_avail_histogram_source.data = self.create_station_avail_histogram_source_dict(
)
print(f"Used: {(time() - t_start) * 1000} ms to calculate sources")
def histogram_policy_callback(self, attr, old, new):
self.station_avail_histogram_source.data = self.create_station_avail_histogram_source_dict(
)
"""This is the callback function that will update the figure curdoc
model."""
mainLayout.children[1].children[1] = create_figure()
def generate_selection_callback(metadata):
"""Generates and returns a callback function that updates a div element."""
def generated_callback(event):
"""The new callback function to be assigned."""
print(event)
mainLayout.children[2] = Paragraph(text=str(metadata))
return generated_callback
DATAFRAME_SEL.on_change('value', update_dataframe_selector)
MAKE_PLOT_BUTTON = Button(label="Build Plot")
MAKE_PLOT_BUTTON.on_click(build_fig_callback)
p = Paragraph(text="""The dataframe selector represents the selection
of one *.csv file.""")
controls = widgetbox(DATAFRAME_SEL, BOND_SEL, MAKE_PLOT_BUTTON, p)
mainLayout = layout(children=[[title_div], [controls,
create_figure()],
Paragraph()],
sizing_mode='fixed')
curdoc().add_root(mainLayout)
class StateDisplay:
def __init__(self, dataset=STATES):
self.dataset = dataset
self.state_selection = MultiSelect(
title="States:",
options=self.dataset,
value=["New York", "Texas"],
sizing_mode="stretch_both",
)
self.per_capita = RadioGroup(
labels=["Total", "Per Capita"],
active=0,
sizing_mode="stretch_width",
)
self.data_getter = RadioGroup(
labels=[
"Cases",
"Deaths",
"Positivity",
"Testing",
"Constant Positivity",
"Constant Testing",
],
active=0,
sizing_mode="stretch_width",
)
self.plot_type = RadioGroup(
labels=["Linear", "Logarithmic"],
active=0,
sizing_mode="stretch_width",
)
self.constant_date = DatePicker(
title="Constant Date",
value=(datetime.today() - timedelta(days=1)).date(),
sizing_mode="stretch_width",
)
self.show_total = CheckboxGroup(
labels=["Show total"],
sizing_mode="stretch_width",
)
self.total_only = CheckboxGroup(
labels=["Total only"],
sizing_mode="stretch_width",
)
self.src = None
self.p = None
self.logp = None
self.tooltips = [("State", "@state")]
def make_dataset(self, state_list):
by_state = {
"avg_date": [],
"avg_data": [],
"state": [],
"color": [],
"line-width": [],
}
color_cycle = cycle(Category20_20)
palette = [next(color_cycle) for _ in self.dataset]
show_total = self.show_total.active == [0]
total_only = self.total_only.active == [0]
totals = None
totals_denom = None
for state_name in state_list:
per_capita = self.per_capita.active == 1
data_getter = self.data_getter.labels[
self.data_getter.active].lower()
constant_date = self.constant_date.value
(
dates,
avg_dates,
data,
avg_data,
test_data,
label,
tot_positive,
tot_testing,
) = get_data(state_name, per_capita, data_getter, constant_date)
if tot_positive is None and tot_testing is None:
subtotal = pd.Series(avg_data.values[7:])
subtotal.index = pd.DatetimeIndex(avg_dates.values[7:])
subtotal_denom = None
else:
subtotal = pd.Series(tot_positive.values[7:])
subtotal.index = pd.DatetimeIndex(avg_dates.values[7:])
subtotal_denom = pd.Series(tot_testing.values[7:])
subtotal_denom.index = pd.DatetimeIndex(avg_dates.values[7:])
idx = pd.date_range(subtotal.index.min(), subtotal.index.max())
subtotal = subtotal.reindex(idx)
subtotal.interpolate(method="time", inplace=True)
if subtotal_denom is not None:
subtotal_denom = subtotal_denom.reindex(idx)
subtotal_denom.interpolate(method="time", inplace=True)
if totals is None:
totals = subtotal
if subtotal_denom is not None:
totals_denom = subtotal_denom
else:
idx = pd.date_range(
min(subtotal.index.min(), totals.index.min()),
max(subtotal.index.max(), totals.index.max()),
)
totals = totals.reindex(idx, fill_value=0)
subtotal = subtotal.reindex(idx, fill_value=0)
totals += subtotal
if subtotal_denom is not None:
totals_denom = totals_denom.reindex(idx, fill_value=0)
subtotal_denom = subtotal_denom.reindex(idx, fill_value=0)
totals_denom += subtotal_denom
if len(state_list) == 1 or not show_total or not total_only:
by_state["avg_date"].append(avg_dates.values)
by_state["avg_data"].append(avg_data.values)
by_state["state"].append(state_name)
by_state["color"].append(
palette[self.dataset.index(state_name)])
by_state["line-width"].append(1)
if totals_denom is not None:
totals /= totals_denom
if show_total:
by_state["avg_date"].append(totals.index.values)
by_state["avg_data"].append(totals.values)
by_state["state"].append("Total")
by_state["color"].append("black")
by_state["line-width"].append(2)
return label, ColumnDataSource(by_state)
def make_plot(self):
self.p = figure(
x_axis_label="Date",
x_axis_type="datetime",
y_axis_label="Total Cases",
width=900,
)
self.p.multi_line(
source=self.src,
xs="avg_date",
ys="avg_data",
legend_field="state",
color="color",
line_width="line-width",
)
self.p.add_tools(HoverTool(tooltips=self.tooltips))
self.p.legend.location = "top_left"
self.logp = figure(
x_axis_label="Date",
x_axis_type="datetime",
y_axis_label="Total Cases",
y_axis_type="log",
width=900,
)
self.logp.multi_line(
source=self.src,
xs="avg_date",
ys="avg_data",
legend_field="state",
color="color",
line_width="line-width",
)
self.logp.add_tools(HoverTool(tooltips=self.tooltips))
self.logp.legend.location = "top_left"
def update_data(self, label, src):
if self.src is None:
self.src = src
self.make_plot()
else:
self.src.data.update(src.data)
if self.plot_type.active == 0:
self.p.visible = True
self.logp.visible = False
else:
self.p.visible = False
self.logp.visible = True
self.p.yaxis.axis_label = label
self.logp.yaxis.axis_label = label
if len(self.data_getter.labels) == 1:
self.data_getter.visible = False
data_getter = self.data_getter.labels[self.data_getter.active].lower()
self.constant_date.visible = data_getter in (
"constant positivity",
"constant testing",
)
def update(self, attr, old, new):
states_to_plot = sorted(self.state_selection.value)
label, new_src = self.make_dataset(states_to_plot)
self.update_data(label, new_src)
self.show_total.visible = len(states_to_plot) != 1
self.total_only.visible = self.show_total.active == [0]
def run(self):
self.state_selection.on_change("value", self.update)
self.per_capita.on_change("active", self.update)
self.data_getter.on_change("active", self.update)
self.plot_type.on_change("active", self.update)
self.constant_date.on_change("value", self.update)
self.show_total.on_change("active", self.update)
self.total_only.on_change("active", self.update)
controls = column(
[
self.state_selection,
self.per_capita,
self.data_getter,
self.plot_type,
self.constant_date,
self.show_total,
self.total_only,
],
sizing_mode="fixed",
width=300,
height=600,
)
self.update(None, None, None)
plots = column(self.p, self.logp)
return row(controls, plots, sizing_mode="stretch_both")
import pandas as pd
import numpy as np
#Pandas version 0.22.0
#Bokeh version 0.12.10
#Numpy version 1.12.1
from bokeh.io import output_file, show,curdoc
from bokeh.models import Quad
from bokeh.layouts import row, layout,widgetbox
from bokeh.models.widgets import Select,MultiSelect
from bokeh.plotting import ColumnDataSource,Figure,reset_output,gridplot
d= {'A': [1,1,1,2,2,3,4,4,4,4,4], 'B': [1,2,2,2,3,3,4,5,6,6,6], 'C' : [2,2,2,2,2,3,4,5,6,6,6]}
df = pd.DataFrame(data=d)
names = ["A","B", "C"]
#Since bokeh.charts are deprecated so using the new method using numpy histogram
hist,edge = np.histogram(df['A'],bins=4)
#This is the method you need to pass the histogram objects to source data here it takes edge values for each bin start and end and hist gives count.
source = ColumnDataSource(data={'hist': hist, 'edges_rt': edge[1:], 'edges_lt':edge[:-1]})
plot = Figure(plot_height = 300,plot_width = 400)
#The quad is used to display the histogram using bokeh.
plot.quad(top='hist', bottom=0, left='edges_lt', right='edges_rt',fill_color="#036564",
line_color="#033649",source = source)
#When you change the selection it will this function and changes the source data so that values are updated.
def callback_menu(attr, old, new):
hist,edge = np.histogram(df[menu.value],bins=4)
source.data={'hist': hist,'edges_rt': edge[1:], 'edges_lt': edge[:-1]}
#These are interacting tools in the final graph
menu = MultiSelect(options=names,value= ['A','B'], title='Sensor Data')
menu.on_change('value', callback_menu)
layout = gridplot([[widgetbox(menu),plot]])
curdoc().add_root(layout)
def update_plots(attr, old, new):
b.children = [plot_state_by_year(), make_scatterplot()]
def update_plot_1(attr, old, new):
b.children[0] = plot_state_by_year()
states = [
'AL', 'AR', 'AZ', 'CO', 'CT', 'DC', 'DE', 'GA', 'HI', 'IA', 'ID', 'IL',
'IN', 'KS', 'KY', 'LA', 'MA', 'MD', 'ME', 'MI', 'MN', 'MO', 'MS', 'MT',
'NC', 'NE', 'NH', 'NM', 'NV', 'NY', 'OH', 'OK', 'OR', 'PA', 'RI', 'SC',
'SD', 'TN', 'TX', 'UT', 'VA', 'VT'
]
multi_select = MultiSelect(title="States:", value=['VT'], options=states)
checkbox_group = CheckboxGroup(
labels=["show US average", "show regression line"], active=[0, 1])
multi_select.on_change('value', update_plots)
checkbox_group.on_change('active', update_plots)
controls = widgetbox(multi_select, checkbox_group)
b = VBox(plot_state_by_year(), make_scatterplot())
l = row(controls, b)
curdoc().add_root(l)
plot.add_layout(legend, 'right')
plot.legend.click_policy = 'hide'
return plot
def update_plot():
page_layout.children[3].children[1] = create_plot()
animals = data['animal'].unique().tolist()
animals.sort()
animal_select = Select(title='Animal', options=animals, value=animals[0])
animal_select.on_change('value', lambda attr, old, new: animal_changed())
date_select = MultiSelect(title='Dates', size=10)
date_select.on_change('value', lambda attr, old, new: update_plot())
groupby_options = {
'masker level': 'masker_level',
'sensation level': 'sens_level',
'target center frequency': 'target_fc',
}
groupby_select = CheckboxButtonGroup(labels=list(groupby_options.keys()), active=[0])
groupby_select.on_change('active', lambda attr, old, new: update_plot())
animal_trials = ColumnDataSource()
animal_trials_plot = figure(title='number of trials', tools="", width=1000,
height=150)
animal_trials_plot.xaxis.axis_label = 'Session'
background.on_change("active", update_background)
map_controls = column(Div(text="<b>Kaartopties</b><br><br>Kaartlagen"),
map_layers, Div(text="Achtergrond"), background)
# %% define main filter selection and handlers
filters = list()
for name, subfilter in zip(data.filters.names, data.filters.filters):
select_filter = MultiSelect(
title=f"{name}:",
value=subfilter.value,
options=subfilter.options,
)
select_filter.size = min(len(subfilter.options), 7)
select_filter.on_change("value", update_on_filter_select)
filters += [select_filter]
# %% define location selection and handlers
select_locations = MultiSelect(title="Locaties:",
value=[],
options=data.locations.options)
select_locations.on_change("value", update_on_locations_select)
# select_locations.js_link("value",
# data.locations.source.selected,
# "indices")
# %% define parameter selection and handlers
select_parameters = MultiSelect(title="Parameters:",
value=[],
def update(attr, old, new):
layout.children[1] = plot_scatter()
##Create Sliders
columns = cl_clean
years = list(df['Year'].unique().astype(str))
regions = list(df['Region'].unique())
x_column = Select(title='X-Axis', value=columns[0], options=columns)
x_column.on_change('value', update)
y_column = Select(title='Y-Axis', value=columns[3], options=columns)
y_column.on_change('value', update)
size_column = Select(title='Size', value=columns[4], options=columns)
size_column.on_change('value', update)
year_column = Select(title='Year', value=years[-3], options=years)
year_column.on_change('value', update)
region_column = MultiSelect(title='Regions', value=regions[:], options=regions)
region_column.on_change('value',update)
controls = widgetbox([x_column, y_column, size_column, year_column, region_column], width=550)
layout = row(controls, plot_scatter())
curdoc().add_root(layout)
curdoc().title = "FH Scatterplot"
df_cases = {}
pNc0_select_results = Button(label='Add GeneMapper Results',
button_type='success')
pNc0_select_results.on_click(pNc0_on_results_click)
pNc0_results_text = TextAreaInput(value='<results file>',
disabled=True,
rows=5)
# select_host_case = Select(title='Select Host', options=list(source_cases.keys()))
p0c0_select_host_case = Select(title='Select Host', options=[])
p0c0_select_host_case.on_change('value', p0c0_on_host_click)
p0c0_select_donor_cases = MultiSelect(
title='Select Donor(s) <ctrl+click to multiselect>', options=[], size=20)
p0c0_select_donor_cases.on_change('value', p0c0_on_donor_change)
p0c0_export_template = Button(label='Export Template', button_type='warning')
p0c0_export_template.on_click(p0c0_on_export_template_click)
p0c0_enter_host_name = TextInput(title='Enter Host Name',
value='<type host name here>')
p1c0_enter_host_name = TextInput(title='Enter Host Name',
value='<type host name here>')
p1c0_select_template = Button(label='Select Template', button_type='success')
p1c0_select_template.on_click(p1c0_on_select_template_click)
p1c0_template_text = TextAreaInput(value='<template file>', disabled=True)
p1c0_select_samples = MultiSelect(
title='Select Sample(s) <ctrl+click to multiselect>', options=[], size=20)
select_term = Select(title="Selected Term:",
value=all_terms[-1],
options=all_terms)
select_term.on_change("value", update_term)
program_list = sorted(
list(pt.loc[((pt["year_term"] == select_term.value)
& (pt["stage"] == stage_list[stage_rg.active])),
"curriculum", ].dropna().unique()))
program = Select(title="Selected Academic Program:",
value=program_list[0],
options=program_list)
program.on_change("value", update_prog)
terms_opt = all_terms.copy()
terms_opt.remove(select_term.value)
terms = MultiSelect(
title="Other Displayed Terms: (ctrl-click to select/de-select)",
options=terms_opt,
size=5,
value=[terms_opt[-1]],
)
terms.on_change("value", update)
# layout
controls = widgetbox([stage_rg, select_term, program, terms])
layout = row(controls, create_figure(summ_t))
curdoc().add_root(layout)
curdoc().title = "Admissions Weekly Report"
def tab_visualize(csv):
csv_original = csv.copy()
csv_modified = csv.copy()
target_csv = {'csv': csv_original}
source_length = target_csv['csv'].shape[0]
table_source = ColumnDataSource(target_csv['csv'])
table_columns = [
TableColumn(field=col, title=col)
for col in list(target_csv['csv'].columns)
]
table_original = DataTable(source=table_source,
columns=table_columns,
width=1550,
height=250,
fit_columns=False,
name="Original")
g = target_csv['csv'].columns.to_series().groupby(
target_csv['csv'].dtypes).groups
g_list = list(g.keys())
float_list = []
rest_list = []
for l in g_list:
if ('float' or 'int' in str(l)):
float_list += list(g[l])
else:
rest_list += list(g[l])
print(float_list)
print(rest_list)
def make_dataset(col_list, range_start, range_end):
xs = []
ys = []
labels = []
colors = []
target_length = target_csv['csv'].shape[0]
end = range_end if (range_end < target_length) else target_length
target_data = target_csv['csv'][col_list +
rest_list].iloc[range_start:end]
target_x = list(np.arange(target_data.shape[0]) + range_start)
for col, i in zip(col_list, range(len(col_list))):
y = list(target_data[col].values)
xs.append(target_x)
ys.append(y)
labels.append(col)
colors.append(line_colors[i])
new_src = ColumnDataSource(data={
'x': xs,
'y': ys,
'label': labels,
'colors': colors
})
return new_src
def make_plot(src):
p = figure(plot_width=1300,
plot_height=400,
title='Raw data',
x_axis_label='Index',
y_axis_label='Sensor value')
p.multi_line('x',
'y',
legend='label',
color='colors',
line_width=1,
source=src)
tools = HoverTool()
TOOLTIPS = [("", ""), ("", "")]
return p
def update(attr, old, new):
column_to_plot = select_column.value
new_src = make_dataset(column_to_plot, range_select.value[0],
range_select.value[1])
src.data.update(new_src.data)
line_colors = Category20_16
line_colors.sort()
select_column = MultiSelect(title="Column visualization",
value=float_list,
options=float_list)
select_column.on_change("value", update)
range_select = RangeSlider(start=0,
end=source_length,
value=(0, int(source_length / 100)),
step=1,
title='Sensor range')
range_select.on_change('value', update)
src = make_dataset([float_list[0]], range_select.value[0],
range_select.value[1])
p = make_plot(src)
select_normalize = Select(title="Select normalize transformation",
options=["-", "Min-Max", "Z normalize", "Raw"])
button_get_normal = Button(label="Transform")
def normal_handler():
print("Normalize")
# cols_to_normalize = float_list
cols_to_normalize = select_transform.value
if (select_normalize.value == "Min-Max"):
scaler = preprocessing.MinMaxScaler()
csv_modified[cols_to_normalize] = scaler.fit_transform(
X=csv_original[cols_to_normalize].values)
target_csv['csv'] = csv_modified
table_source.data = ColumnDataSource(target_csv['csv']).data
csv[cols_to_normalize] = target_csv['csv'][cols_to_normalize]
print("Min Max Mormalize")
elif (select_normalize.value == "Z normalize"):
scaler = preprocessing.StandardScaler()
csv_modified[cols_to_normalize] = scaler.fit_transform(
X=csv_original[cols_to_normalize].values)
target_csv['csv'] = csv_modified
table_source.data = ColumnDataSource(target_csv['csv']).data
csv[cols_to_normalize] = target_csv['csv'][cols_to_normalize]
print("Z normalize")
elif (select_normalize.value == "Raw"):
csv_modified[cols_to_normalize] = csv_original[cols_to_normalize]
target_csv['csv'] = csv_modified
table_source.data = ColumnDataSource(target_csv['csv']).data
csv[cols_to_normalize] = target_csv['csv'][cols_to_normalize]
print("Raw")
button_get_normal.on_click(normal_handler)
select_transform = MultiSelect(title="Select columns for transformation",
value=list(target_csv['csv'].columns),
options=list(target_csv['csv'].columns))
controls = WidgetBox(select_normalize, select_transform, button_get_normal,
select_column, range_select)
layout = Column(Row(table_original), Row(controls, p))
tab = Panel(child=layout, title='Visualization')
return tab
def minimial_page_4_server_test(doc):
doc.title = "**testing demo page**"
user_dict = load_JSON_file_to_Dict(rel_User_fileName)
p = Paragraph(text="""
this is an initialized text widget
""",
width=200,
height=100)
text_box = widgetbox(p)
if __name__ == '__main__':
def button_reaction():
print("stopping test-server (self kill. restart)")
p.text = "stopping server"
server1.stop()
p.text = "stopping server .. failed"
toggle = Button(label='kill test-server', button_type='success')
else:
def button_reaction():
print("pressed button")
p.text = "json content is :\n " + str(user_dict)
toggle = Button(
label='smile:) with test', button_type='success'
) # Options: ‘default’, ‘primary’, ‘success’, ‘warning’, ‘danger’, ‘link’
toggle.on_click(button_reaction)
img_paths = []
img_paths.append(join(rel_DATA_DIR, 'logoScrnSht.png'))
img_paths.append(join(rel_DATA_DIR, 'tree.png'))
x_range = (-20, 10)
y_range = (20, 30)
factor = 1.2
figImg = figure(x_range=x_range,
y_range=y_range,
width=500,
height=400,
active_drag='pan',
active_scroll='wheel_zoom')
figImg.toolbar.logo = None
figImg.image_url(url=[img_paths[0]],
x=x_range[0] / factor,
y=(y_range[0] + y_range[1]) / 2,
w=(x_range[1] - x_range[0]) / factor,
h=(y_range[1] - y_range[0]) / factor,
anchor="bottom_left")
factor = 2
figImg.image_url(url=[img_paths[1]],
x=x_range[0] / factor,
y=(y_range[0] + y_range[1]) / 2,
w=(x_range[1] - x_range[0]) / factor,
h=(y_range[1] - y_range[0]) /
factor) #, anchor="bottom_left") default it left-up
multi_select = MultiSelect(title="Option:",
value=["foo", "quux"],
size=7,
options=[("foo", "Foo"), ("bar", "BAR"),
("baz", "bAz"), ("quux", "quux")])
def mSlct_update(attrname, old, new):
myString = ''
for i in multi_select.value:
myString += '\n' + i
myString += '\n' + str(range_slider.value[0])
myString += '\n' + str(range_slider.value[1])
myString += '\n' + text_input_as_filter.value
print("\n\n selected:\n", myString)
# myText.text = myString
multi_select.on_change('value', mSlct_update)
range_slider = RangeSlider(start=0,
end=10,
value=(1, 9),
step=.1,
title="Stuff")
range_slider.on_change('value', mSlct_update)
text_input_as_filter = TextInput(
value="default", title="Label:") # no workable callback option
doc_add_root(doc, toggle)
doc_add_root(doc, figImg)
doc_add_root(doc, text_box)
doc_add_root(doc, multi_select)
doc_add_root(doc, range_slider)
doc_add_root(doc, text_input_as_filter)
tooltip_fix_callback = CustomJS(code="""
var tooltips = document.getElementsByClassName("bk-tooltip");
for (var i = 0, len = tooltips.length; i < len; i ++) {
tooltips[i].style.top = ""; // unset what bokeh.js sets
tooltips[i].style.right = "";
tooltips[i].style.bottom = "";
tooltips[i].style.left = "";
tooltips[i].style.bottom = "0px";
tooltips[i].style.right = "-150px";
}
""")
# bind widget callbacks
color_class_select.on_change('value', update_color_class)
toggle_class_select.on_change('value', update_toggle_class)
class_toggle_multi_select.on_change('value', update_class_selection)
file_select_dropdown.on_click(file_select_handler)
hover_tip_tool.callback = tooltip_fix_callback
update_toggle_class('value', '', features_list[0])
control_panel = column([
file_select_dropdown, color_class_select, toggle_class_select,
class_toggle_multi_select
],
sizing_mode="stretch_height",
width=200)
p.add_tools(wheel_zoom_tool)
p.add_tools(hover_tip_tool)
p.toolbar.active_scroll = wheel_zoom_tool
curdoc().add_root(row(control_panel, p, sizing_mode='stretch_both'))
wordsource_up.data = newsource.data
def update2(attr, old, new):
entity = multi_select2.value
newdf_down = make_df(entity_bag_2021, average_sentiment_array, entity[0],
-1, spacing)
newsource = ColumnDataSource(newdf_down)
wordsource_down.data = newsource.data
menu = [(ent_key[key], key) for key in ent_key.keys()]
multi_select1 = MultiSelect(title="Entity type",
value=["PERSON", "person"],
options=menu)
multi_select1.on_change('value', update1)
multi_select2 = MultiSelect(title="Entity type",
value=["ORG", "Organization"],
options=menu)
multi_select2.on_change('value', update2)
# ipdb.set_trace()
pre = PreText(text="""Select article by clicking on circles""",
width=500,
height=100)
p.tools.append(TapTool(plot=p))
from help_text import text_dict
header_text = Div(text="""<pre> <font size="6"><a href="http://192.168.86.29:5006/plojo">Plojo</a> Help Document</font><pre>""",width=400)
topic_list = [
chr(9608)*2+' Top Row Buttons ','+---- Upload/Browse/Fitting Button','+---- Information Box','+---- Edit Button','+---- Plot Button','+---- Load/Save Button',
chr(9608)*2+' Upload Layout ', '+---- Upload Data Options',
chr(9608)*2+' Browse Layout ','+---- Project/Experiment... Tabs','+---- plojo Keyword Search','+---- Edit/Save Experiment Information',
chr(9608)*2+' Fitting Layout ','+---- Curve Fitting with plojo',
chr(9608)*2+' Simuojo ', '+---- How to use simuojo?',
chr(9608)*2+' Fitting Methods ','+---- How does fitting work?','+---- Supported Fitting Models','+---- Confidence Intervals'
]
topic_key = ['toprow','ubfbutton','infobox','editbutton','plotbutton','loadsavebutton',
'uploadlayout','uploadoptions','browselayout','tabs','search','editinfo','fittinglayout','curvefit',
'simuojo','howtosimuojo','fitmethod','howfit','supportedfitmodel','confidence']
topic_menu = [i for i in zip(topic_key,topic_list)]
topic_select = MultiSelect(title='Topic',value=['none'],options=topic_menu,size=30)
text_show=Div(text='Select a topic to view.',width=800,height=800)
def topic_select_cb(attr,old,new):
new=new[0]
text_show.text = text_dict[new]
topic_select.on_change('value',topic_select_cb)
div_1 = Div(text='',width=50)
display_layout = layout([header_text],[div_1,topic_select,text_show])
curdoc().add_root(display_layout)
dtcds=ColumnDataSource(data=setupdict)
# dtcds.on_change('data',on_change_data_source)
dtcolumns=[TableColumn(field='accs',title='GBAccession')]
dtbl=DataTable(source=dtcds,columns=dtcolumns,width=200,height=80,editable=True,selectable=True)
dtbl.source.selected.on_change('indices',tablecallback)
#layout=column(row(dtbl,gms,acw),row(p1,p2))
jscallback=CustomJS(args={'cds':ptree.leaf_cds,'dtcds':dtcds},code=stuffcode)
p1.add_tools(TapTool(callback=jscallback))#,names=['leaf_node']))
#cooldude=CustomJS(args={'cds':leaf_source},code=coolcode)
pms=MultiSelect(title='Select phylum',\
options=[x[0] for x in collections.Counter(ptree.leaf_cds.data['phylum']).most_common()],\
width=200,height=70)
pms.on_change('value',lambda attr,old,new:pmsfunc())
cms=MultiSelect(title='Select class',
options=[x[0] for x in collections.Counter(ptree.leaf_cds.data['class']).most_common()],\
width=200,height=70)
cms.on_change('value',lambda attr,old,new:cmsfunc())
gms=MultiSelect(title='Select genus',\
options=[x[0] for x in collections.Counter(ptree.leaf_cds.data['genus']).most_common()],\
width=200,height=70)
gms.on_change('value',lambda attr,old,new:gmsfunc())
kms=MultiSelect(title='Kingdom',\
options=[x[0] for x in collections.Counter(ptree.leaf_cds.data['superkingdom']).most_common()],\
width=200,height=70)
kms.on_change('value',lambda attr,old,new:kmsfunc())
NIGHTS_SLIDER.on_change(c.VALUE, update_data)
# Range Slider Widget
PRICE = FILTER_PROPERTIES[c.PRICE]
PRICE_SLIDER = RangeSlider(start=PRICE[0],
end=PRICE[1],
value=(PRICE[0], PRICE[1]),
step=50,
title='Nightly Price')
PRICE_SLIDER.on_change(c.VALUE, update_data)
# Multi Select Widgets
AMENITIES_SELECT = MultiSelect(title='Amenities:',
value=[],
options=FILTER_PROPERTIES[c.AMENITIES])
AMENITIES_SELECT.on_change(c.VALUE, update_data)
PROPERTY_TYPE_SELECT = MultiSelect(title='Property Type:',
value=[],
options=FILTER_PROPERTIES[c.PT])
PROPERTY_TYPE_SELECT.on_change(c.VALUE, update_data)
NEIGHBOURHOOD_SELECT = MultiSelect(title='Neighbourhood:',
value=[],
options=FILTER_PROPERTIES[c.NC])
NEIGHBOURHOOD_SELECT.on_change(c.VALUE, update_data)
# Checkbox Group (Multi Select) Widgets
NG_LIST = FILTER_PROPERTIES[c.NGC]
NEIGHBOURHOOD_GROUP = CheckboxButtonGroup(labels=NG_LIST,
active=list(range(0, len(NG_LIST))))
PS3C2Voltage.line(x='x', y='voltages8', source=source)
PS3C3Current.line(x='x', y='currents9', source=source)
PS3C3Voltage.line(x='x', y='voltages9', source=source)
file_control.on_change('value', file_handler)
apply_button.on_click(apply_settings)
current_control.on_change('value', current_handler)
voltage_control.on_change('value', voltage_handler)
power_control.on_change('value', power_handler)
ocp_control.on_change('value', ocp_handler)
file_control.on_change('value', file_handler)
directory_control.on_change('value', file_handler)
comment_box.on_change('value', comment_handler)
channel_dropdown.on_change('value', channel_handler)
start_button.on_click(start_button_handler)
connect_button.on_click(connect_button_handler)
supply_dropdown.on_change('value', multiselect_handler)
t0 = time.time()
curdoc().add_root(
row(
column(supply_textbox, supply_dropdown, connect_button,
current_control, voltage_control, power_control, ocp_control,
channel_dropdown, apply_button, directory_control, file_control,
start_button, comment_box),
column(PS1C1Current, PS1C1Voltage, PS1C2Current, PS1C2Voltage,
PS1C3Current, PS1C3Voltage),
column(PS2C1Current, PS2C1Voltage, PS2C2Current, PS2C2Voltage,
PS2C3Current, PS2C3Voltage),
column(PS3C1Current, PS3C1Voltage, PS3C2Current, PS3C2Voltage,
PS3C3Current, PS3C3Voltage)))
update_map(filtered_data)
slider_active_toggle.label = "slider not active"
slider_active_toggle.button_type = "default"
# assign callbacks
play_button = Toggle(label="PLAY",
button_type="primary",
width=100,
callback=callback_play)
time_slider.on_change('value', callback_time_slider)
slider_active_toggle.on_click(callback_toggle_slider_activity)
pattern_select.on_change('active', callback_pattern_selection)
aggregate_select.on_change('active', callback_aggregation_selection)
groupby_select.on_change('active', callback_groupby_selection)
type_filter.on_change('value', callback_type_filter)
geo_source.on_change('selected', callback_map_selection)
select_all_types_button.on_click(callback_select_all_types)
## end callbacks
# headers
map_head = Div(text="<h2>Spatial distribution of incidents</h2>",
css_classes=["plot-head"],
width=LEFT_COLUMN_WIDTH)
ts_head = Div(text="<h2>Time distribution of incidents</h2>",
css_classes=["plot-head"],
width=RIGHT_COLUMN_WIDTH)
status_available_style = {"font-size": "8pt", "color": "green"}
status_unavailable_style = {"font-size": "8pt", "color": "red"}
status = Div(text="""<i>Status: at your service</i>""",
style={
def graphs_change():
"""Callback on change of selected graph type"""
d = curdoc()
_remove_fig(d)
_remove_selection(d)
graph_val = d.get_model_by_name(GRAPH_SELECTION).value
model_id, message_name, model_type = run_handlers.get_modelid_messagename_type(
d)
props = run_handlers.get_model_properties(model_id, message_name,
model_type)
if graph_val in ["line", "scatter", "step"]:
# never want to plot this special string field
field_options = [
"{0} : {1}".format(k, props[k]) for k in props
if not any(apv in k for apv in [APV_MODEL])
]
xselect = Select(title="X Axis",
value=DEFAULT_UNSELECTED,
options=field_options + [DEFAULT_UNSELECTED],
name=X_AXIS_SELECTION)
yselect = Select(title="Y Axis",
value=DEFAULT_UNSELECTED,
options=field_options + [DEFAULT_UNSELECTED],
name=Y_AXIS_SELECTION)
xselect.on_change('value', lambda attr, old, new: make_2axis_graph())
yselect.on_change('value', lambda attr, old, new: make_2axis_graph())
d.add_root(
column(Div(text=""),
row(widgetbox([xselect]), widgetbox([yselect])),
name=FIELD_SELECTION))
if graph_val in ["image"]:
# alter the field options for known non-image fields
field_options = [
"{0} : {1}".format(k, props[k]) for k in props
if not any(apv in k for apv in [APV_RECVD, APV_SEQNO, APV_MODEL])
]
imageselect = Select(title="Image Field",
value=DEFAULT_UNSELECTED,
options=[DEFAULT_UNSELECTED] + field_options,
name=IMAGE_SELECTION)
mimeselect = Select(title="MIME Type",
value=DEFAULT_UNSELECTED,
options=[DEFAULT_UNSELECTED] +
SUPPORTED_MIME_TYPES,
name=MIME_SELECTION)
imageselect.on_change('value',
lambda attr, old, new: image_selection_change())
mimeselect.on_change('value',
lambda attr, old, new: image_selection_change())
d.add_root(
column(Div(text=""),
widgetbox([imageselect, mimeselect]),
name=IMAGE_MIME_SELECTION))
if graph_val in ["table"]:
# TODO: limit selectable columns to whose of the same size (table height)
# use just the field name; don't show properties in the multi-select box
col_options = [
k for k in props
if not any(apv in k for apv in [APV_RECVD, APV_SEQNO, APV_MODEL])
]
columnmultiselect = MultiSelect(title="Columns:",
value=[],
options=col_options,
name=COLUMN_MULTISELECT)
columnmultiselect.on_change(
'value', lambda attr, old, new: column_selection_change())
d.add_root(
column(Div(text=""),
widgetbox([columnmultiselect]),
name=COLUMN_SELECTION))
if graph_val in ["raw"]:
p = figure(plot_width=500,
plot_height=500,
background_fill_color="white",
y_range=(-40, 0),
title="",
name=FIGURE_MODEL)
p.xaxis.visible = False
p.yaxis.visible = False
sind = run_handlers.get_source_index(d.session_context.id, model_id,
message_name)
_install_callback_and_cds(sind, model_id, message_name, stream_limit=1)
p.text(x='apv_sequence_number',
y=0,
text='apv_model_as_string',
source=d.get_model_by_name(sind),
text_font_size="10pt",
text_line_height=0.7,
text_baseline="top",
text_align="left")
p.x_range.follow = "end" # don't jam all the data into the graph; "window" it
p.x_range.follow_interval = 1 # don't jam all the data into the graph; "window" it
p.x_range.range_padding = 0
d.add_root(p)
update_files_button = Button(label="Update Files", button_type="default", width=50)
update_files_button.on_click(reload_all_files)
auto_update_toggle_button = Toggle(label="Auto Update", button_type="default", width=50, active=True)
auto_update_toggle_button.on_click(toggle_auto_update)
unload_file_button = Button(label="Unload", button_type="danger", width=50)
unload_file_button.on_click(unload_file)
# files selection box
files_selector = Select(title="Files:", options=[""])
files_selector.on_change('value', change_data_selector)
# data selection box
data_selector = MultiSelect(title="Data:", options=[], size=12)
data_selector.on_change('value', select_data)
# x axis selection box
x_axis_selector_title = Div(text="""X Axis:""", height=10)
x_axis_selector = RadioButtonGroup(labels=x_axis_options, active=0)
x_axis_selector.on_click(change_x_axis)
# toggle second axis button
toggle_second_axis_button = Button(label="Toggle Second Axis", button_type="success")
toggle_second_axis_button.on_click(toggle_second_axis)
# averaging slider
# This data source is just used to communicate / trigger the real callback
averaging_slider_dummy_source = ColumnDataSource(data=dict(value=[]))
averaging_slider_dummy_source.on_change('data', update_averaging)
averaging_slider = Slider(title="Averaging window", start=1, end=101, step=10, callback_policy='mouseup')
def map_viz_tab():
def plot_sensor_path(sensors, df_final):
for i in sensors:
#plotter.line(x=path_data.get_group(i).x, y=path_data.get_group(i).y, name=str(i), color="black")
plotter.line(x=df_final['x'].loc[df_final['sid'] == i],
y=df_final['y'].loc[df_final['sid'] == i],
color="orange")
def updateOverlays(attr, old, new):
overlays = checkbox_btn_group.active
if 0 in overlays:
img_hsp = "https://upload.wikimedia.org/wikipedia/commons/d/d0/Flag_for_hospital_ship_of_the_Regia_Marina.svg"
hospital_data = dict(url=[img_hsp] * 8,
x=df_hospitalLocation.x,
y=df_hospitalLocation.y)
source_hospital.data = hospital_data
else:
h_x, h_y, h_url = [], [], []
hospital_data = dict(url=h_url, x=h_x, y=h_y)
source_hospital.data = hospital_data
if 1 in overlays:
x_patch, y_patch, x_vor_ls, y_vor_ls = get_voronoi(
df_hospitalLocation.x, df_hospitalLocation.y)
patch_data = dict(xs=x_patch, ys=y_patch)
lines_data = dict(xs=x_vor_ls, ys=y_vor_ls)
source_vor.data = patch_data
source_vor_ls.data = lines_data
else:
x_patch, y_patch, x_vor_ls, y_vor_ls = [], [], [], []
patch_data = dict(xs=x_patch, ys=y_patch)
lines_data = dict(xs=x_vor_ls, ys=y_vor_ls)
source_vor.data = patch_data
source_vor_ls.data = lines_data
if 2 in overlays:
color_mapper = LinearColorMapper(palette=palette, low=0, high=50)
mp.fill_color = {'field': 'Value', 'transform': color_mapper}
mp.fill_alpha = 1.0
tick_labels = {
'0': '0',
'10': '10',
'20': '20',
'30': '30',
'40': '40',
'50': '>50'
}
color_bar = ColorBar(color_mapper=color_mapper,
label_standoff=5,
width=500,
height=20,
border_line_color=None,
location=(0, 0),
orientation='horizontal',
major_label_overrides=tick_labels)
plotter.add_layout(color_bar, 'below')
else:
mp.fill_color = 'lightslategrey'
mp.fill_alpha = 0.5
def updateMotionMap(attr, old, new):
check = checkbox_btn_group1.active
xmin = -13326251
if 0 in check:
img_state = [
"https://i.imgur.com/IBpHIs1.png",
"https://i.imgur.com/oawpbdU.png",
"https://i.imgur.com/kigeppa.png",
"https://i.imgur.com/mHAUX9K.png",
"https://i.imgur.com/pxbaYlp.png",
"https://i.imgur.com/QNhcnRn.png",
"https://i.imgur.com/GB2fRMS.png",
"https://i.imgur.com/qXfEJNL.png",
"https://i.imgur.com/QZOTgG9.png",
"https://i.imgur.com/sE1U89y.png",
"https://i.imgur.com/vAxwSQE.png",
"https://i.imgur.com/yO1iOCw.png",
"https://i.imgur.com/jFpJ2UQ.png",
"https://i.imgur.com/lVkwzYH.png",
"https://i.imgur.com/Q519cud.png",
"https://i.imgur.com/FtnTUAC.png",
"https://i.imgur.com/j2D9ud6.png",
"https://i.imgur.com/Tb4tWI5.png",
"https://i.imgur.com/yhl5nAX.png"
]
states_x = [
xmin - 28000, xmin - 22500, xmin - 16000, xmin - 12000,
xmin - 22000, xmin - 22500, xmin - 1000, xmin - 6000,
xmin - 14000, xmin - 8000, xmin - 4700, xmin - 4700,
xmin - 9000, xmin - 16000, xmin - 19500, xmin - 19500,
xmin - 14000, xmin - 13000, xmin - 16500
]
states_y = [
19000, 19700, 20000, 17000, 12000, 16000, 11000, 3800, 6000,
5900, 7000, 10500, 12500, 17000, 17000, 13500, 9200, 13500,
13000
]
w = [
4000, 5000, 4000, 4000, 4000, 4000, 3000, 4800, 5000, 2500,
4000, 4000, 4000, 3000, 3000, 3000, 4300, 3500, 3500
]
h = [
3600, 3000, 3000, 3000, 3000, 3000, 6000, 4800, 3000, 5000,
4000, 3000, 4000, 2000, 2000, 3000, 2700, 3500, 3500
]
states_data = dict(url=img_state, x=states_x, y=states_y, w=w, h=h)
source_states.data = states_data
else:
h_x, h_y, h_url, w, h = [], [], [], [], []
states_data = dict(url=h_url, x=h_x, y=h_y, w=w, h=h)
source_states.data = states_data
if 1 in check:
source_path1.data = data_path1
else:
source_path1.data = data_path
def update_time_frame(attr, old, new):
""" update the time frame and load new dataframes
"""
timeline.value = time_start
time_current = time_start
if time_frame.active == 0:
timeline.step = 5
df_mobile_location_cur = df_mobileLocation_raw
df_static_reading_cur = df_staticSensors_raw
df_mobile_reading_cur = df_mobileSensors_raw
if time_frame.active == 1:
timeline.step = 60
df_mobile_location_cur = df_mobileLocation_min
df_static_reading_cur = df_staticSensors_min
df_mobile_reading_cur = df_mobileSensors_min
if time_frame.active == 2:
timeline.step = 3600
df_mobile_location_cur = df_mobileLocation_hr
df_static_reading_cur = df_staticSensors_hr
df_mobile_reading_cur = df_mobileSensors_hr
static_sensors_update(attr, old, new)
mobile_sensors_update(attr, old, new)
def getDFfromDB(table_name):
url = join(basename(split(dirname(__file__))[0]), 'data',
'StHimarkDB.db')
conn = sq.connect(url)
df = pd.read_sql_query("select * from " + table_name + ";", conn)
return df
def static_sensors_update(attr, old, new):
time_current = datetime.fromtimestamp(timeline.value + baseTime)
sid, x, y, val, user = [], [], [], [], []
data_new = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'value': val,
'user': user,
})
source_static.data = data_new
#clean(source_static_locations)
selected = static_sensors_ms.value
selectedStaticSensors.clear()
for name in selected:
selectedStaticSensors.append(name.split("_", 1)[1])
for sensor in selectedStaticSensors:
sid.append(sensor)
x.append(df_staticLocation['x'].loc[df_staticLocation['sid'] ==
int(sensor)].values.item())
y.append(df_staticLocation['y'].loc[df_staticLocation['sid'] ==
int(sensor)].values.item())
val.append(df_static_reading_cur[sensor].loc[
df_static_reading_cur['Timestamp'] ==
time_current].values.item())
user.append('Sensor ' + sensor)
data_new = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'value': val,
'user': user,
})
source_static.data = data_new
def mobile_sensors_update(attr, old, new):
time_current = datetime.fromtimestamp(timeline.value + baseTime)
greencar = 'https://i.imgur.com/YyWzmgH.png'
selected = mobile_sensors_ms.value
overlays = checkbox_btn_group.active
path_flag = False
if 3 in overlays:
path_flag = True
selectedMobileSensors.clear()
sid,x,y,clr,val,user, x_path, y_path,img=[],[],[],[],[],[],[],[],[]
data_new_mobile = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'colo': clr,
'value': val,
'user': user,
'url': img,
})
source_mobile.data = data_new_mobile
df_path = pd.DataFrame(columns=['sid', 'x', 'y'])
data_path = collections.OrderedDict({
'x_path': x_path,
'y_path': y_path,
})
source_path.data = data_path
safety_thresh = safe_threshold.value
for name in selected:
selectedMobileSensors.append(name.split("_", 1)[1])
img = [greencar] * len(selectedMobileSensors)
for sensor in selectedMobileSensors:
col_x = '(\'x\', \'{}\')'.format(sensor)
col_y = '(\'y\', \'{}\')'.format(sensor)
sid.append(sensor)
x.append(df_mobile_location_cur[col_x].loc[
df_mobile_location_cur['Timestamp'] ==
time_current].values.item())
y.append(df_mobile_location_cur[col_y].loc[
df_mobile_location_cur['Timestamp'] ==
time_current].values.item())
val1 = df_mobile_reading_cur[sensor].loc[
df_mobile_reading_cur['Timestamp'] ==
time_current].values.item()
if val1 == None:
val1 = 0
user.append(df_mobileUsers['user'].loc[df_mobileUsers['sensor'] ==
int(sensor)].values.item())
if int(float(val1)) > safety_thresh:
clr.append('darkred')
#clr.append(redcar)
else:
clr.append('lawngreen')
#clr.append(greencar)
val.append(val1)
#clr.append(RGB( 255 - int(sensor), (int(sensor)*2)+50, int(sensor)*4))
if path_flag == True:
df_temp = pd.DataFrame()
df_temp['x'] = df_mobile_location_cur[col_x]
df_temp['y'] = df_mobile_location_cur[col_y]
df_temp['sid'] = sensor
df_path = df_path.append(df_temp)
data_new_mobile = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'colo': clr,
'value': val,
'user': user,
'url': img,
})
source_mobile.data = data_new_mobile
if path_flag == True:
data_path = collections.OrderedDict({
'x_path': [
df_path['x'].loc[df_path['sid'] == i]
for i in selectedMobileSensors
],
'y_path': [
df_path['y'].loc[df_path['sid'] == i]
for i in selectedMobileSensors
],
})
source_path.data = data_path
#df_path.to_csv('total_path.csv', index=None, header=True)
#path_data = df_path.groupby('sid')
#plot_sensor_path(selectedMobileSensors, df_path)
def update_safeT(attr, old, new):
global safety_thresh
safety_thresh = safe_threshold.value
def update_time(attr, old, new):
greencar = 'https://i.imgur.com/YyWzmgH.png'
safety_thresh = safe_threshold.value
time_current = datetime.fromtimestamp(timeline.value + baseTime)
text = template.format(curTime=time_current)
label.text = str(time_current)
some_div.text = text
sid, x, y, clr, val, user, img = [], [], [], [], [], [], []
if 2 in checkbox_btn_group.active:
radiationFlag = True
else:
radiationFlag = False
if radiationFlag == True:
time1 = str(time_current)
new_data3 = json_data(time1)
geosource.geojson = new_data3
data_new_mobile = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'colo': clr,
'value': val,
'user': user,
'url': img,
})
source_mobile.data = data_new_mobile
data_new_static = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'value': val,
'user': user,
})
source_static.data = data_new_static
img = [greencar] * len(selectedMobileSensors)
for sensor in selectedMobileSensors:
col_x = '(\'x\', \'{}\')'.format(sensor)
col_y = '(\'y\', \'{}\')'.format(sensor)
sid.append(sensor)
x.append(df_mobile_location_cur[col_x].loc[
df_mobile_location_cur['Timestamp'] ==
time_current].values.item())
y.append(df_mobile_location_cur[col_y].loc[
df_mobile_location_cur['Timestamp'] ==
time_current].values.item())
val1 = df_mobile_reading_cur[sensor].loc[
df_mobile_reading_cur['Timestamp'] ==
time_current].values.item()
if val1 == None:
val1 = 0
if int(float(val1)) > safety_thresh:
clr.append('red')
#clr.append(redcar)
else:
clr.append('green')
#clr.append(greencar)
#clr.append(RGB( 255 - int(sensor), (int(sensor)*2)+50, int(sensor)*4))
val.append(val1)
user.append(df_mobileUsers['user'].loc[df_mobileUsers['sensor'] ==
int(sensor)].values.item())
data_new_mobile = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'colo': clr,
'value': val,
'user': user,
'url': img,
})
source_mobile.data = data_new_mobile
x, y, val, user, sid = [], [], [], [], []
for sensor in selectedStaticSensors:
sid.append(sensor)
x.append(df_staticLocation['x'].loc[df_staticLocation['sid'] ==
int(sensor)].values.item())
y.append(df_staticLocation['y'].loc[df_staticLocation['sid'] ==
int(sensor)].values.item())
val.append(df_static_reading_cur[sensor].loc[
df_static_reading_cur['Timestamp'] ==
time_current].values.item())
user.append('Sensor ' + sensor)
data_new_static = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'value': val,
'user': user,
})
source_static.data = data_new_static
def clearStaticSensors():
sid, x, y, clr, val, user = [], [], [], [], [], []
static_sensors_ms.value = []
data_new_static = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'value': val,
'user': user,
})
source_static.data = data_new_static
def clearMobileSensors():
mobile_sensors_ms.value = []
sid,x,y,clr,val,user, x_path, y_path,img=[],[],[],[],[],[],[],[],[]
data_path = collections.OrderedDict({
'x_path': x_path,
'y_path': y_path,
})
source_path.data = data_path
data_new_mobile = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'colo': clr,
'value': val,
'user': user,
'url': img,
})
source_mobile.data = data_new_mobile
def animate_update():
time_current = timeline.value + timeline.step
if time_current > time_end:
time_current = time_start
timeline.value = time_current
update_time(None, None, None)
def animate():
global callback_id
if btn_animate.label == '► Play':
btn_animate.label = '❚❚ Pause'
callback_id = curdoc().add_periodic_callback(animate_update, 200)
else:
btn_animate.label = '► Play'
curdoc().remove_periodic_callback(callback_id)
def json_data(timestamp):
#time = df_hour_data['Timestamp'].loc[df_hour_data['Timestamp'] ==timestamp]
time1 = pd.to_datetime(timestamp)
time1 = time1.replace(minute=0, second=0)
timestamp = str(time1.to_pydatetime())
df_temp = df_hour_data_group.get_group(timestamp)
merged = stHimarkShape.merge(df_temp,
left_on='Nbrhood',
right_on='Neighbourhood',
how='left')
merged_json = json.loads(merged.to_json())
return json.dumps(merged_json)
#Declare all the variables and datasources here
plotter, stHimarkShape, gsource = displayMap()
selectedStaticSensors, selectedMobileSensors = [], []
time_start = 0
time_end = 1
time_current = 0
safety_thresh = 40
#Get Dataframe for static sensors
sid,x,y,clr,val,user,x_path, y_path, img=[],[],[],[],[],[],[],[],[]
data_static = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'value': val,
})
source_static = ColumnDataSource(data=data_static)
data_mobile = collections.OrderedDict({
'sid': sid,
'x_loc': x,
'y_loc': y,
'colo': clr,
'value': val,
'user': user,
'url': img,
})
source_mobile = ColumnDataSource(data=data_mobile)
data_path = collections.OrderedDict({
'x_path': [x_path],
'y_path': [y_path],
})
source_path = ColumnDataSource(data=data_path)
url = join(basename(split(dirname(__file__))[0]), 'data', 'total_path.csv')
df_tp = pd.read_csv(url)
data_path1 = collections.OrderedDict({
'x_path': [df_tp['x'].loc[df_tp['sid'] == i] for i in range(1, 51)],
'y_path': [df_tp['y'].loc[df_tp['sid'] == i] for i in range(1, 51)],
})
source_path1 = ColumnDataSource(data=data_path)
df_staticSensors_hr = getDFfromDB("StaticSensorReading_hours")
df_mobileSensors_hr = getDFfromDB("MobileSensorReading_hours")
df_staticSensors_min = getDFfromDB("StaticSensorReading_minutes")
df_mobileSensors_min = getDFfromDB("MobileSensorReading_minutes")
df_staticSensors_raw = getDFfromDB("StaticSensorReading_raw")
df_mobileSensors_raw = getDFfromDB("MobileSensorReading_raw")
df_staticLocation = getDFfromDB("StaticSensorLocation")
df_hospitalLocation = getDFfromDB("HospitalLocation")
df_mobileLocation_hr = getDFfromDB("MobileSensorLocation_hours")
df_mobileLocation_min = getDFfromDB("MobileSensorLocation_minutes")
df_mobileLocation_raw = getDFfromDB("MobileSensorLocation_raw")
#read mobile sensor users data
url = join(basename(split(dirname(__file__))[0]), 'data', 'mobileuser.csv')
df_mobileUsers = pd.read_csv(url)
df_mobileLocation_hr['Timestamp'] = pd.to_datetime(
df_mobileLocation_hr['Timestamp'])
df_mobileLocation_min['Timestamp'] = pd.to_datetime(
df_mobileLocation_min['Timestamp'])
df_mobileLocation_raw['Timestamp'] = pd.to_datetime(
df_mobileLocation_raw['Timestamp'])
df_mobileSensors_hr['Timestamp'] = pd.to_datetime(
df_mobileSensors_hr['Timestamp'])
df_mobileSensors_min['Timestamp'] = pd.to_datetime(
df_mobileSensors_min['Timestamp'])
df_mobileSensors_raw['Timestamp'] = pd.to_datetime(
df_mobileSensors_raw['Timestamp'])
df_staticSensors_hr['Timestamp'] = pd.to_datetime(
df_staticSensors_hr['Timestamp'])
df_staticSensors_min['Timestamp'] = pd.to_datetime(
df_staticSensors_min['Timestamp'])
df_staticSensors_raw['Timestamp'] = pd.to_datetime(
df_staticSensors_raw['Timestamp'])
df_static_reading_cur = df_staticSensors_raw
df_mobile_reading_cur = df_mobileSensors_raw
df_mobile_location_cur = df_mobileLocation_raw
#Radiation Map
url = join(basename(split(dirname(__file__))[0]), 'data',
'df_hour_combined.csv')
df_hour_data = pd.read_csv(url)
df_hour_data_group = df_hour_data.groupby('Timestamp')
time = df_hour_data['Timestamp'][0]
df_first = df_hour_data_group.get_group(time)
merged = stHimarkShape.merge(df_first,
left_on='Nbrhood',
right_on='Neighbourhood')
static_list = [1, 4, 6, 9, 11, 12, 13, 14, 15]
mobile_list = list(range(1, 51))
static_sensor_list = {}
mobile_sensor_list = {}
for sensor in static_list:
static_sensor_list.update({int(sensor): "Sensor_" + str(sensor)})
for sensor in mobile_list:
mobile_sensor_list.update({int(sensor): "Sensor_" + str(sensor)})
static_sensor_list = collections.OrderedDict(
sorted(static_sensor_list.items()))
mobile_sensor_list = collections.OrderedDict(
sorted(mobile_sensor_list.items()))
df_staticSensors_hr['Timestamp'] = pd.to_datetime(
df_staticSensors_hr['Timestamp'])
time_start = df_staticSensors_hr['Timestamp'][0]
time_current = time_start
time_end = df_staticSensors_hr['Timestamp'][len(df_staticSensors_hr.index)
- 1]
baseTime = datetime.timestamp(time_start)
time_start = datetime.timestamp(time_start) - baseTime
time_end = datetime.timestamp(time_end) - baseTime
#Widget: Multiselect --- Create two multiselect widgets for static and mobile sensors
static_sensors_ms = MultiSelect(title="Static Sensors:",
options=list(static_sensor_list.values()),
height=250)
static_sensors_ms.on_change('value', static_sensors_update)
mobile_sensors_ms = MultiSelect(title="Mobile Sensors:",
options=list(mobile_sensor_list.values()),
height=250)
mobile_sensors_ms.on_change('value', mobile_sensors_update)
controls = WidgetBox(row([static_sensors_ms, mobile_sensors_ms]))
btn_staticClear = Button(label='Clear Static Selection')
btn_mobileClear = Button(label='Clear Mobile Selection')
btn_staticClear.on_click(clearStaticSensors)
btn_mobileClear.on_click(clearMobileSensors)
btn_group = WidgetBox(
row([
WidgetBox(btn_staticClear, width=310),
WidgetBox(btn_mobileClear, width=310)
]))
overlay_div = Div(text='<b>Map Overlays</b>',
style={
'font-size': '120%',
'color': 'black'
})
checkbox_btn_group = CheckboxButtonGroup(labels=[
'Show Hospitals', 'Hospital Vornoi Map', 'Radiation Map', 'Trace Paths'
],
active=[])
checkbox_btn_group.on_change('active', updateOverlays)
checkbox_btn_group1 = CheckboxButtonGroup(
labels=['State Labels', 'Trace Motion Map'], active=[])
checkbox_btn_group1.on_change('active', updateMotionMap)
timeframe_div = Div(text='<b>Time Frame</b>',
style={
'font-size': '120%',
'color': 'black'
})
time_frame = RadioButtonGroup(labels=["Raw", "By Minutes", "By Hours"],
active=0,
name="Sort By:")
time_frame.on_change('active', update_time_frame)
template = ("""
<b>Timestamp: </b> <span class='number'>{curTime}</span>
""")
text = template.format(curTime=time_current)
some_div = Div(text=text, style={'font-size': '100%', 'color': 'black'})
timeline = Slider(title="",
value=0,
start=time_start,
end=time_end,
step=5)
timeline.show_value = False
timeline.on_change('value', update_time)
btn_animate = Button(label='► Play', width=180)
btn_animate.on_click(animate)
x_patch, y_patch, x_vor_ls, y_vor_ls = [], [], [], []
patch_data = dict(xs=x_patch, ys=y_patch)
lines_data = dict(xs=x_vor_ls, ys=y_vor_ls)
source_vor = ColumnDataSource()
source_vor_ls = ColumnDataSource()
source_vor.data = patch_data
source_vor_ls.data = lines_data
h_x, h_y, h_url = [], [], []
hospital_data = dict(url=h_url, x=h_x, y=h_y)
source_hospital = ColumnDataSource()
source_hospital.data = hospital_data
w_s, h_s = [], []
states_data = dict(url=h_url, x=h_x, y=h_y, w=w_s, h=h_s)
source_states = ColumnDataSource()
source_states.data = states_data
palette = brewer['RdYlGn'][5]
color_mapper = LinearColorMapper(palette=palette, low=0, high=50)
merged_json = json.loads(merged.to_json())
json_data1 = json.dumps(merged_json)
geosource = GeoJSONDataSource(geojson=json_data1)
tick_labels = {
'0': '0',
'10': '10',
'20': '20',
'30': '30',
'40': '40',
'50': '>50'
}
color_bar = ColorBar(color_mapper=color_mapper,
label_standoff=5,
width=500,
height=20,
border_line_color=None,
location=(0, 0),
orientation='horizontal',
major_label_overrides=tick_labels)
plotter.add_layout(color_bar, 'below')
mp = Patches(xs='xs',
ys='ys',
fill_color='lightslategrey',
line_color="black",
line_width=0.05,
fill_alpha=0.5)
plotter.add_glyph(geosource, mp)
plotter.patches('xs',
'ys',
source=source_vor,
alpha=0.3,
line_width=1,
fill_color='lightslategrey',
line_color='black')
plotter.multi_line('xs',
'ys',
source=source_vor_ls,
alpha=1,
line_width=1,
line_color='black')
safe_threshold = Slider(title="Safety Threshold(In cpm)",
value=safety_thresh,
start=0,
end=100,
step=1)
safe_threshold.on_change('value', update_safeT)
layout = column(
row([
plotter,
column([
controls, btn_group, overlay_div, checkbox_btn_group,
checkbox_btn_group1, timeframe_div, time_frame,
row([some_div, btn_animate]), timeline, safe_threshold
])
]))
glyph = MultiLine(xs="x_path",
ys="y_path",
line_color="saddlebrown",
line_width=0.8,
line_alpha=0.5)
plotter.add_glyph(source_path1, glyph)
glyph = MultiLine(xs="x_path",
ys="y_path",
line_color="darkred",
line_width=2,
line_alpha=0.9)
plotter.add_glyph(source_path, glyph)
image1 = ImageURL(url='url', x="x", y="y", w=600, h=600, anchor="center")
plotter.add_glyph(source_hospital, image1)
image_states = ImageURL(url='url',
x="x",
y="y",
w="w",
h="h",
anchor="center")
plotter.add_glyph(source_states, image_states)
label = Label(x=-13358000,
y=2000,
text=str(time_current),
text_font_size='20pt',
text_color='yellowgreen')
plotter.add_layout(label)
plotter.hex(name="static_hover",
x='x_loc',
y='y_loc',
color="yellow",
size=12,
alpha=1,
source=source_static)
carimage = ImageURL(url='url',
x='x_loc',
y='y_loc',
w=600,
h=1100,
anchor='center')
plotter.add_glyph(source_mobile, carimage)
plotter.circle(name="dynamic_hover",
x='x_loc',
y='y_loc',
fill_color='colo',
line_color='colo',
size=6,
alpha=1,
source=source_mobile)
hover = HoverTool(names=["static_hover", "dynamic_hover"],
tooltips=[("Sensor", "@sid"), ("Radiation", "@value"),
("User", "@user")],
show_arrow=False)
plotter.tools = [hover]
#plotter.diamond(x='x', y ='y', color='green',size=15, source = source_hospital)
img_path = "https://upload.wikimedia.org/wikipedia/commons/b/b8/Nuclear_plant.svg"
plotter.image_url(url=[img_path],
x=-13334385.723761385,
y=18109.34344275895,
w=1000,
h=1000,
anchor='center')
tab = Panel(child=layout, title='Visual Analysis')
return tab
