def __init__(self):
self.per_capita = RadioGroup(
labels=["Total", "Per Capita", "Logarithmic"],
active=0,
sizing_mode="stretch_width",
)
self.data_getter = RadioGroup(
labels=["Cases", "Deaths", "Positivity"],
active=0,
sizing_mode="stretch_width",
)
self.date = DatePicker(title="Date", sizing_mode="stretch_width")
self.save_files = CheckboxGroup(labels=["Save files"],
sizing_mode="stretch_width")
self.button = Button(label="► Play", sizing_mode="stretch_width")
self.tooltips = [("Name", "@name"), ("Value", "@value")]
self.src = None
self.p = None
self.callback = None
self.counter = None
self.tempdir = None
self.filenames = None
def initialize(self, widget_lst):
self.radiobutton = RadioGroup(active=self.default_value,
labels=self.label,
inline=self.inline)
widget_lst.append(self.radiobutton)
if self.callback is not None:
self.radiobutton.on_click(self.callback)
class radiobutton():
def __init__(self, widget_lst, default_value, label, inline=True):
self.widget_lst = widget_lst
self.radiobutton = None
self.initialize(default_value, label, inline)
def initialize(self, default_value, label, inline):
self.radiobutton = RadioGroup(active=default_value,
labels=label,
inline=inline)
self.widget_lst.append(self.radiobutton)
def add_callback(self, callback):
self.radiobutton.on_click(callback)
def file_callback(attr, old, new):
global raw_df, hist_df
loaded_file_div.text = '<font color=#006699>' + "Loaded file" + ': </font>' + \
file_source.data['file_name'][0]
raw_contents = file_source.data['file_contents'][0]
# remove the prefix that JS adds
prefix, b64_contents = raw_contents.split(",", 1)
file_contents = base64.b64decode(b64_contents).decode()
# read in new rawdata
raw_df = esp8266_aux.preprocess_csv_string(file_contents)
MAC_list = esp8266_aux.get_MAC_list(raw_df)
# replace old MAC list by a new list.
mac_radio_group_column.children.pop()
mac_radio_group = RadioGroup(labels=MAC_list, active=0)
mac_radio_group.on_click(mac_radio_group_callback)
mac_radio_group_column.children.append(mac_radio_group)
# calculate histogram for the first MAC
hist_df = time_series_histogram.histogram_of_time(
raw_df, MAC_list[0], time_window_length=time_window)
histogram_line.data_source.data = ColumnDataSource(hist_df).data
class radiobutton():
def __init__(self, widget_lst, default_value, label, inline=True):
self.label = label
self.default_value = default_value
self.inline = inline
self.radiobutton = None
self.callback = None
# self.initialize(default_value, label, inline)
widget_lst.append(self)
def initialize(self, widget_lst):
self.radiobutton = RadioGroup(active=self.default_value,
labels=self.label,
inline=self.inline)
widget_lst.append(self.radiobutton)
if self.callback is not None:
self.radiobutton.on_click(self.callback)
def add_callback(self, callback):
self.callback = callback
if self.radiobutton is not None:
self.radiobutton.on_click(self.callback)
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 __init__(self):
super().__init__()
self.state = "New York, Washington"
self.menu = COUNTIES
self.state_selection = Dropdown(menu=self.menu,
label=self.state,
sizing_mode="stretch_width")
self.data_getter = RadioGroup(
labels=[
"Cases",
"Deaths",
],
active=0,
sizing_mode="stretch_width",
)
def __init__(self, renderer):
self.file_input = Dropdown(label="Select dataset", menu=[])
for dataset_name in SQLDBInformer(DbConn({})).get_all_schemas():
if dataset_name in set(["information_schema", "performance_schema", "sys", "defaultDB", "mysql"]):
continue
if dataset_name[:3] == "pg_":
continue
self.file_input.menu.append(dataset_name)
self.run_id_dropdown = Dropdown(label="select run id here", menu=[])
self.ground_truth_id_dropdown = Dropdown(label="select ground truth id here", menu=[])
self.score_slider = RangeSlider(start=0, end=1, value=(0, 1), step=.1, callback_policy='mouseup',
title="score range")
self.max_elements_slider = Slider(start=1000, end=100000, value=10000, step=1000,
callback_policy='mouseup', title="max render")
self.range_link_radio = RadioGroup(labels=["Link read plot to x-range", "Link read plot to y-range"],
active=0, orientation="horizontal")
self.full_render_button = Button(label="render without limit")
self.render_mems_button = Button(label="render MEMs")
self.delete_button = Button(label="Delete Dataset")
self.force_read_id = TextInput(value="", title="Render reads with ids (comma seperated list):")
self.file_input.on_change("value", lambda x,y,z: self.file_input_change(renderer))
self.run_id_dropdown.on_change("value", lambda x,y,z: self.run_id_change(renderer))
self.ground_truth_id_dropdown.on_change("value", lambda x,y,z: self.ground_id_change(renderer))
self.score_slider.on_change("value_throttled", lambda x,y,z: self.slider_change(renderer))
self.max_elements_slider.on_change("value_throttled", lambda x,y,z: self.slider_change(renderer))
self.full_render_button.on_event(ButtonClick, lambda x: self.full_render(renderer))
self.render_mems_button.on_event(ButtonClick, lambda x: self.render_mems_button_event(renderer))
self.delete_button.on_event(ButtonClick, lambda x: self.delete_button_event(renderer))
self.force_read_id.on_change("value", lambda x,y,z: self.forced_read_ids_change(renderer))
self.spinner_div = Div(text=html_file("spinner"), sizing_mode="scale_both", visible=False)
self.condition = threading.Condition()
self.subset_buttons = CheckboxButtonGroup(labels=["Render false-positives", "Render false-negatives",
"Render true-positives", "Compute Stats"],
active=[0, 1, 2])
self.subset_buttons.on_click(lambda x: self.forced_read_ids_change(renderer))
self.blur_slider = Slider(start=0, end=500, value=100, step=1, callback_policy='mouseup',
title="Blur")
self.blur_slider.on_change("value_throttled", lambda x,y,z: self.slider_change(renderer))
CustomJS(
code="console.log('dropdown_disabled: ' + this.value, this.toString())"
))
#dropdown_split = Dropdown(label="Split button", button_type="danger", menu=menu, default_value="default")
#dropdown_split.on_click(lambda value: print('dropdown_split: %s' % value))
#dropdown_split.js_on_click(CustomJS(code="console.log('dropdown_split: ' + this.value, this.toString())"))
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"],
active=[0, 1])
checkbox_group.on_click(lambda value: print('checkbox_group: %s' % value))
checkbox_group.js_on_click(
CustomJS(
code="console.log('checkbox_group: ' + this.active, this.toString())"))
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_group.on_click(lambda value: print('radio_group: %s' % value))
radio_group.js_on_click(
CustomJS(
code="console.log('radio_group: ' + this.active, this.toString())"))
checkbox_button_group = CheckboxButtonGroup(
labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_button_group.on_click(
lambda value: print('checkbox_button_group: %s' % value))
checkbox_button_group.js_on_click(
CustomJS(
code=
"console.log('checkbox_button_group: ' + this.active, this.toString())"
))
def plotting(self):
#Tools = [hover, TapTool(), BoxZoomTool(), BoxSelectTool(), PreviewSaveTool(), ResetTool()]
TOOLS="crosshair,pan,wheel_zoom,box_zoom,reset,hover,previewsave"
tab_plots = []
#output_file("test.html")
self.all_elements = []
self.elements_comparison = []
for attr_id, i in zip(self.attribute_ids, range(len(self.attribute_ids))):
"""
create plots for each datafile and put them in a tab.
"""
list_of_datasets = getattr(self, attr_id)
y_axis_units = [x["y_unit"] for x in list_of_datasets]
x_axis_units = [x["x_unit"] for x in list_of_datasets]
figure_obj = figure(plot_width = 1000, plot_height = 800, y_axis_type = "log",
title = attr_id, tools = TOOLS)
#figure_obj.axes.major_label_text_font_size("12pt")
#figure_obj.major_label_text_font_size("12pt")
setattr(self, attr_id+"_"+"figure_obj",figure_obj)
figure_obj.yaxis.axis_label = y_axis_units[0]
figure_obj.xaxis.axis_label = x_axis_units[0]
if not all(x == y_axis_units[0] for x in y_axis_units):
for unit, data in zip(y_axis_units, list_of_datasets):
if not unit == y_axis_units[0]:
figure_obj.extra_y_ranges = {"foo": Range1d(start = np.amin(data["data"]["y"]),
end = np.amax(data["data"]["y"]))}
figure_obj.add_layout(LogAxis(y_range_name = "foo", axis_label = unit), "right")
break
if not all(x == x_axis_units[0] for x in x_axis_units):
for unit, data in zip(x_axis_units, list_of_datasets):
if not unit == x_axis_units[0]:
figure_obj.extra_x_ranges = {"bar": Range1d(start = np.amin(data["data"]["x"]),
end = np.amax(data["data"]["x"]))}
figure_obj.add_layout(LinearAxis(x_range_name = "bar", axis_label = unit), "above")
break
figure_obj.xaxis.axis_label = list_of_datasets[0]["x_unit"]
colour_list = Spectral11 + RdPu9 + Oranges9
colour_indices = [0, 2, 8, 10, 12, 14, 20, 22, 1, 3, 9, 11, 13, 15]
list_of_elements = []
for dataset, color_index in zip(list_of_datasets, colour_indices):
self.all_elements.append(dataset["sample element"]) #strip isotope number
color = colour_list[color_index]
source = ColumnDataSource(data = dataset["data"]) #Datastructure for source of plotting
setattr(self, attr_id+"_"+dataset["sample element"]+"_source", source) #Source element generalized for all plotting
list_of_elements.append(dataset["sample element"])
figure_obj.line("x", "y", source = getattr(self, attr_id+"_"+dataset["sample element"]
+"_source"), line_width = 2, line_color = color,
legend = dataset["sample element"], name = dataset["sample element"],
)
hover = figure_obj.select_one(HoverTool).tooltips = [("element", "@element"), ("(x,y)", "($x, $y)")]
radio_group = RadioGroup(labels = list_of_elements, active=0)
"""
Need to fetch default variables from input file and replace DEFAULT
Block of code produces the layout of buttons and callbacks
"""
#Calculations on the dataset
text_input_rsf = TextInput(value = "default", title = "RSF (at/cm^3): ")
do_integral_button = Button(label = "Calibration Integral")
smoothing_button = Button(label = "Smoothing on selected curve")
text_input_sputter = TextInput(value = "default", title = "Sputter speed: float unit")
text_input_crater_depth = TextInput(value = "default", title = "Depth of crater in: float")
radio_group.on_change("active", lambda attr, old, new: None)
text_input_xval_integral = TextInput(value = "0", title = "x-value for calibration integral ")
text_input_yval_integral = TextInput(value = "0", title = "y-value for calibration integral ")
#Save files for later use
save_flexDPE_button = Button(label = "Save element for FlexPDE")
save_all_flexDPE_button = Button(label = "Save all elements for FlexPDE")
#Pointers to methods on click / change handlers
do_integral_button.on_click(lambda identity = self.attribute_ids[i], radio = radio_group,
x_box = text_input_xval_integral, y_box = text_input_yval_integral:
self.integrate(identity, radio, x_box, y_box))
smoothing_button.on_click(lambda identity = self.attribute_ids[i], radio = radio_group:
self.smoothing(identity, radio) )
save_flexDPE_button.on_click(lambda identity = self.attribute_ids[i], radio = radio_group:
self.write_to_flexPDE(identity, radio))
save_all_flexDPE_button.on_click(lambda identity = self.attribute_ids[i], radio = radio_group:
self.write_all_to_flexPDE(identity, radio))
text_input_rsf.on_change("value", lambda attr, old, new, radio = radio_group,
identity = self.attribute_ids[i], text_input = text_input_rsf, which = "rsf":
self.update_data(identity, radio, text_input, new, which))
text_input_sputter.on_change("value", lambda attr, old, new, radio = radio_group,
identity = self.attribute_ids[i], text_input = text_input_sputter, which = "sputter":
self.update_data(identity, radio, text_input, new, which))
text_input_crater_depth.on_change("value", lambda attr, old, new, radio = radio_group,
identity = self.attribute_ids[i], text_input = text_input_crater_depth, which = "crater_depth":
self.update_data(identity, radio, text_input, new, which))
#Initialization of actual plotting.
tab_plots.append(Panel(child = hplot(figure_obj,
vform(radio_group, save_flexDPE_button, save_all_flexDPE_button),
vform(text_input_rsf, smoothing_button, text_input_sputter, text_input_crater_depth),
vform(text_input_xval_integral, text_input_yval_integral, do_integral_button)),
title = attr_id))
"""
Check to see if one or more element exists in the samples and creat a comparison plot for each
of those elements.
"""
for element in self.all_elements:
checkers = list(self.all_elements)
checkers.remove(element)
if element in checkers and not element in self.elements_comparison:
self.elements_comparison.append(element)
"""create plots for each element that is to be compared """
for comparison_element in self.elements_comparison:
colour_list = Spectral11 + RdPu9 + Oranges9
colour_indices = [0, 2, 8, 10, 12, 14, 20, 22, 1, 3, 9, 11, 13, 15]
figure_obj = figure(plot_width = 1000, plot_height = 800, y_axis_type = "log", title = comparison_element, tools = TOOLS)
#figure_obj.xaxis.major_label_text_font_size("12pt")
#figure_obj.yaxis.major_label_text_font_size("12pt")
y_axis_units = []
x_axis_units = []
comparison_datasets = []
for attr_id, color_index in zip(self.attribute_ids, colour_indices):
list_of_datasets = getattr(self, attr_id)
for dataset in list_of_datasets:
if dataset["sample element"] == comparison_element:
comparison_datasets.append(dataset)
y_axis_units.append(dataset["y_unit"])
x_axis_units.append(dataset["x_unit"])
figure_obj.xaxis.axis_label = comparison_datasets[-1]["x_unit"]
figure_obj.yaxis.axis_label = comparison_datasets[-1]["y_unit"]
if not all(x == y_axis_units[-1] for x in y_axis_units):
for unit, data in zip(y_axis_units, comparison_datasets):
if not unit == y_axis_units[-1]:
figure_obj.extra_y_ranges = {"foo": Range1d(start = np.amin(data["data"]["y"]),
end = np.amax(data["data"]["y"]))}
figure_obj.add_layout(LogAxis(y_range_name = "foo", axis_label = unit), "right")
break
if not all(x == x_axis_units[-1] for x in x_axis_units):
for unit, data in zip(x_axis_units, comparison_datasets):
if not unit == x_axis_units[-1]:
figure_obj.extra_x_ranges = {"bar": Range1d(start = np.amin(data["data"]["x"]),
end = np.amax(data["data"]["x"]))}
figure_obj.add_layout(LinearAxis(x_range_name = "bar", axis_label = unit), "above")
break
for attr_id, color_index in zip(self.attribute_ids, colour_indices):
list_of_datasets = getattr(self, attr_id)
for dataset in list_of_datasets:
if dataset["sample element"] == comparison_element:
color = colour_list[color_index]
"""
Logic that ensures that plots get put with correspoinding axes.
"""
if dataset["x_unit"] != x_axis_units[-1] or dataset["y_unit"] != y_axis_units[-1]:
if dataset["x_unit"] != x_axis_units[-1] and dataset["y_unit"] != y_axis_units[-1]:
figure_obj.line("x", "y", source = getattr(self, attr_id+"_"+dataset["sample element"]+"_source"), line_width = 2,
line_color = color, legend = attr_id, x_range_name = "bar", y_range_name = "foo")
elif dataset["x_unit"] != x_axis_units[-1]:
figure_obj.line("x", "y", source = getattr(self, attr_id+"_"+dataset["sample element"]+"_source"), line_width = 2,
line_color = color, legend = attr_id, x_range_name = "bar")
else:
figure_obj.line("x", "y", source = getattr(self, attr_id+"_"+dataset["sample element"]+"_source"), line_width = 2,
line_color = color, legend = attr_id, y_range_name = "foo")
else:
figure_obj.line("x", "y", source = getattr(self, attr_id+"_"+dataset["sample element"]+"_source"), line_width = 2,
line_color = color, legend = attr_id)
tab_plots.append(Panel(child = figure_obj, title = comparison_element))
tabs = Tabs(tabs = tab_plots)
session = push_session(curdoc())
session.show()
session.loop_until_closed()
# use the css_classes to reference this object in /templates/styles.css
example_slider = LatexSlider(title="\\text{example}=",
value_unit="\\frac{Sv}{m \\cdot kg}",
value=initial_value,
start=start_value,
end=end_value,
step=0.5,
width=400,
css_classes=["slider"])
example_slider.on_change(
'value', slider_cb_fun) # callback function is called when value changes
# radio button: round and only one active selection per group allowed
# active=0 to select the the first button by default
# inline=True to place the buttons horizontally
radio_group_01 = RadioGroup(labels=["1", "2"], active=0, inline=True)
radio_group_02 = RadioGroup(labels=["3", "4"])
radio_group_01.on_change("active", radio_cb_fun)
radio_group_02.on_change("active", radio_cb_fun_2)
# radio button group: buttons that are merged next to each other, only one active selection per group allowed
radio_button_group = RadioButtonGroup(labels=["Item 1", "Item 2", "Item 3"],
active=0,
width=200)
##################################
# Costum Objects #
##################################
# build a new object
my_object = TA_example_class(42)
from datetime import date
from random import randint
import string
refresh = Button(label="Refresh")
btnGroupTitle = RadioButtonGroup(
name='title',
labels=["begins with...", "...contains...", "...ends with"],
active=1)
btnGroupDept = RadioButtonGroup(
name='dept',
labels=["begins with...", "...contains...", "...ends with"],
active=1)
paragraph = Paragraph(text="option")
optionGroup = RadioGroup(labels=["and", "or"],
active=0,
width=100,
inline=True)
btnGroupLetters = RadioButtonGroup(labels=list(string.ascii_uppercase),
active=-1)
title_input = TextInput(value="", title="Title:", placeholder="contains....")
dept_input = TextInput(value="",
title="Department:",
placeholder="contains....")
layout_query = layout([
[widgetbox(btnGroupLetters, width=1000)],
[widgetbox(btnGroupTitle),
widgetbox(btnGroupDept)],
[
widgetbox(title_input),
widgetbox(paragraph, optionGroup, width=100),
def first_tab_create(filterData):
########method1: create data source for plots
# dummy data that will be replaced by button values once we get those implemented (right now only granulaity button is implemented)
all_min_date = filterData.groupby('dataid').agg(min)["time"]
all_max_date = filterData.groupby('dataid').agg(max)["time"]
dummy_daterange = ['2019-05-01', '2019-08-20']
dummy_home_id = 27
dummy_data_type = 'car1'
dummy_granularity = '15 Minutes'
def plot1_data(house, daterange=dummy_daterange, data=dummy_data_type, xaxis=dummy_granularity):
# house is an integer number ex. 27
# daterange is an array with 2 strings, start date and end date. ex. ['2019-05-01','2019-08-09']
# weekdays is an ordered list 0-6 of integers ex. [1,4,6] (these are the days we want to exclude)
# data is a string ex. 'car1'
# xaxis is also a string ex. 'hour'
houseData = filterData[filterData['dataid'] == house].sort_values('time', ascending=True)[[data, 'time']]
# that cuts the house, sorts by ascending time, and pulls out only the type of data that was requested
houseData.index = houseData['time'] # reindex by the datetime
houseData = houseData.loc[daterange[0]:daterange[1], :] # cut to the days requested
# Now we get into the xaxis user options #
if xaxis == '15 Minutes':
houseData = houseData.drop(columns="time")
if xaxis == 'Hour':
houseData = houseData.resample('1h').mean()
houseData[data]=houseData[data]*3600/3600
if xaxis == 'Day':
houseData = houseData.resample('1d').mean()
houseData[data] = houseData[data] * 3600 / 3600 * 24
if xaxis == 'Week':
houseData = houseData.resample('1w').mean()
houseData[data] = houseData[data] * 3600 / 3600 *24 * 7
if xaxis == 'Month':
houseData = houseData.resample('1m').mean()
houseData[data] = houseData[data] * 3600 / 3600 *24 * 7 * 30 ############this computation is wrong because n stadard month but just go with it for now
# if none of these, 15 Minutes is implied and passed through
return ColumnDataSource(houseData)
def plot2_data(house,daterange=dummy_daterange,weekdays = [],data=dummy_data_type,xaxis=dummy_granularity):
houseData = filterData[filterData['dataid'] == house].sort_values('time', ascending = True)[[data,'time']]
# that cuts the house, sorts by ascending time, and pulls out only the type of data that was requested
houseData.index = houseData['time'] # reindex by the datetime
houseData = houseData.loc[daterange[0]:daterange[1],:] # cut to the days requested
for i in weekdays:
houseData = houseData[houseData['time'].dt.dayofweek != i] # cut out days we dont want
if xaxis == 'avgday':
houseData = houseData.resample('1d').sum() ####chjange to mean
houseData['time'] = houseData.index
houseData = houseData.groupby(houseData['time'].dt.dayofweek)[data].mean()
houseData.index = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
if xaxis == 'avghour':
houseData = houseData.resample('1h').mean()
houseData['time'] = houseData.index
houseData = houseData.groupby(houseData['time'].dt.hour)[data].mean() # Does not account for UTC change!
houseData = pd.DataFrame(data = houseData)
houseData['axis'] = houseData.index
return ColumnDataSource(houseData)
# now we need to set up our plot axis
##########method2: create plots
def plot1_plot(src):
# create the plot every time a change occurs
plot1 = figure(title="Energy Consumption Per Period", x_axis_type="datetime", x_axis_label="Date",
y_axis_label="Energy Consumption [kWh]")
plot1.line('time', "grid", source=src, ) # simple line plot #data_type_available[data_type_selector.active]
return plot1 # plot object type
def plot2_plot(src):
plot2 = figure(x_range = (0,23), y_range=(-7,2), title='Average Power Consumption For Hours in a Day') # gotta do the ranges as mins and maxes
plot2.vbar(x='axis', top = 'grid', width=1, source=src)
plot2.yaxis.axis_label = 'Power Consumption [kW]'
plot2.xaxis.axis_label = 'Hour of the Day'
#plot2 = figure(title = 'PLOT2')
#plot2.line('axis','grid', source = src)
return plot2
#########Method3: Update App
def update(attr, old, new): # still a little unsure how the update function gets values passed in implicitly
# these values to be replaced with button/user inputs
home_id_to_plot = 27
daterange_to_plot = ['2019-05-01', '2019-08-20']
data_type_to_plot = 'grid'
exclude_days_to_plot = []
avg_to_plot = 'avghour'
# home_id_to_plot = int(home_id_selector.value)
# print(attr, old, new)
# if home_id_selector.value == new:
# daterange_to_plot = [all_min_date[home_id_to_plot].strftime("%Y-%m-%d"), all_max_date[home_id_to_plot].strftime("%Y-%m-%d")]
# date_range_slider.start=all_min_date[home_id_to_plot]
# date_range_slider.end=all_max_date[home_id_to_plot]
# date_range_slider.value=(all_min_date[home_id_to_plot],all_max_date[home_id_to_plot])
# print("if 1 truth")
# else:
daterange_raw = list(date_range_slider.value_as_datetime)
daterange_to_plot = [daterange_raw[0].strftime("%Y-%m-%d"), daterange_raw[1].strftime("%Y-%m-%d")]
# print("falsyy")
# date_range_slider.update(start=all_min_date[home_id_to_plot], end=all_max_date[home_id_to_plot],
# value=(all_min_date[home_id_to_plot], all_max_date[home_id_to_plot]))
# print("after:",new)
# print(attr,old,new)
# daterange_to_plot=list(string_date1,string_date2)
# daterange_to_plot=dummy_daterange
data_type_to_plot = "grid" # data_type_available[data_type_selector.active]
# only working button call so far
granularity_to_plot = granularity_1.labels[granularity_1.active]
# granularity_to_plot= [granularity_1.labels[i] for i in granularity_1.active]
print("before data create")
# create a new data source
new_src1 = plot1_data(home_id_to_plot, daterange=daterange_to_plot, data=data_type_to_plot,
xaxis=granularity_to_plot)
new_src2 = plot2_data(home_id_to_plot, daterange=daterange_to_plot,
weekdays=exclude_days_to_plot, data=data_type_to_plot,xaxis=avg_to_plot)
print("before data update")
# push new data to the source data the rest of the app is usig for plot1
src1.data.update(new_src1.data)
src2.data.update(new_src2.data)
print("updated data")
# def new_home(attr,old,new):
# return
############# Add widgets
# only the granularity implemented so far
granularity_1 = RadioGroup(
labels=["15 Minutes", "Hour", "Day", "Week", "Month"], active=0)
granularity_1.on_change('active',
update) # not sure exactly how this works but runs update on the change of the button and passes through the value of the button
home_ids_available = np.unique(filterData['dataid'])
home_ids_available= list(map(str, home_ids_available))
home_id_selector = Dropdown(label="Home ID to Plot", button_type="warning", menu=home_ids_available)
home_ids_available = list(map(str, home_ids_available))
home_id_selector = Dropdown(label="Home ID to Plot", button_type="warning", menu=home_ids_available, value="27")
# home_id_selector.on_change('value', update) #############put back in later!!!!1
date_range_slider = DateRangeSlider(title="Date Range: ", start=date(2019, 5, 1), end=date(2019, 8, 20),
value=(date(2019, 5, 1), date(2019, 8, 20)), step=1, callback_policy = 'mouseup')
date_range_slider.on_change("value", update)
# data_type_selector = RadioButtonGroup(labels=["Net Home Consumption","Solar Generation","EV Consumption"],active=0)
# data_type_selector.on_change('active',update)
# data_type_available=["grid","solar","car1"]
############ Initialize opening plot and data
src1 = plot1_data(int(home_ids_available[0]), ['2019-05-01', '2019-08-20'], 'grid',
'15 Minutes') # start with a data range we know is correct
plot1 = plot1_plot(src1)
src2 = plot2_data(27,['2019-05-01', '2019-08-20'],[],'grid','avghour')
plot2 = plot2_plot(src2)
##### Formatting of the app screen
# Put controls in a single element (add more later to format)
controls = WidgetBox(granularity_1, home_id_selector, date_range_slider) # data_type_selector)
# Create a row layout
layout = row(controls, column(plot1,plot2))
# Make a tab with the layout
tab = Panel(child=layout, title='First Tab')
return tab
class DVHs:
def __init__(self, sources, time_series, correlation, regression,
custom_title, data_tables):
self.sources = sources
self.time_series = time_series
self.correlation = correlation
self.regression = regression
self.dvh_review_rois = []
self.query = None
self.temp_dvh_info = Temp_DICOM_FileSet()
self.dvh_review_mrns = self.temp_dvh_info.mrn
if self.dvh_review_mrns[0] != '':
self.dvh_review_rois = self.temp_dvh_info.get_roi_names(
self.dvh_review_mrns[0]).values()
self.dvh_review_mrns.append('')
else:
self.dvh_review_rois = ['']
# Add Current row to source
self.add_endpoint_row_button = Button(label="Add Endpoint",
button_type="primary",
width=200)
self.add_endpoint_row_button.on_click(self.add_endpoint)
self.ep_row = Select(value='', options=[''], width=50, title="Row")
self.ep_options = [
"Dose (Gy)", "Dose (%)", "Volume (cc)", "Volume (%)"
]
self.select_ep_type = Select(value=self.ep_options[0],
options=self.ep_options,
width=180,
title="Output")
self.select_ep_type.on_change('value', self.select_ep_type_ticker)
self.ep_text_input = TextInput(value='',
title="Input Volume (cc):",
width=180)
self.ep_text_input.on_change('value', self.ep_text_input_ticker)
self.ep_units_in = RadioButtonGroup(labels=["cc", "%"],
active=0,
width=100)
self.ep_units_in.on_change('active', self.ep_units_in_ticker)
self.delete_ep_row_button = Button(label="Delete",
button_type="warning",
width=100)
self.delete_ep_row_button.on_click(self.delete_ep_row)
tools = "pan,wheel_zoom,box_zoom,reset,crosshair,save"
self.plot = figure(plot_width=1050,
plot_height=500,
tools=tools,
logo=None,
active_drag="box_zoom")
self.plot.min_border_left = options.MIN_BORDER
self.plot.min_border_bottom = options.MIN_BORDER
self.plot.add_tools(
HoverTool(show_arrow=False,
line_policy='next',
tooltips=[('Label', '@mrn @roi_name'), ('Dose', '$x'),
('Volume', '$y')]))
self.plot.xaxis.axis_label_text_font_size = options.PLOT_AXIS_LABEL_FONT_SIZE
self.plot.yaxis.axis_label_text_font_size = options.PLOT_AXIS_LABEL_FONT_SIZE
self.plot.xaxis.major_label_text_font_size = options.PLOT_AXIS_MAJOR_LABEL_FONT_SIZE
self.plot.yaxis.major_label_text_font_size = options.PLOT_AXIS_MAJOR_LABEL_FONT_SIZE
self.plot.yaxis.axis_label_text_baseline = "bottom"
self.plot.lod_factor = options.LOD_FACTOR # level of detail during interactive plot events
# Add statistical plots to figure
stats_median_1 = self.plot.line(
'x',
'median',
source=sources.stats_1,
line_width=options.STATS_1_MEDIAN_LINE_WIDTH,
color=options.GROUP_1_COLOR,
line_dash=options.STATS_1_MEDIAN_LINE_DASH,
alpha=options.STATS_1_MEDIAN_ALPHA)
stats_mean_1 = self.plot.line(
'x',
'mean',
source=sources.stats_1,
line_width=options.STATS_1_MEAN_LINE_WIDTH,
color=options.GROUP_1_COLOR,
line_dash=options.STATS_1_MEAN_LINE_DASH,
alpha=options.STATS_1_MEAN_ALPHA)
stats_median_2 = self.plot.line(
'x',
'median',
source=sources.stats_2,
line_width=options.STATS_2_MEDIAN_LINE_WIDTH,
color=options.GROUP_2_COLOR,
line_dash=options.STATS_2_MEDIAN_LINE_DASH,
alpha=options.STATS_2_MEDIAN_ALPHA)
stats_mean_2 = self.plot.line(
'x',
'mean',
source=sources.stats_2,
line_width=options.STATS_2_MEAN_LINE_WIDTH,
color=options.GROUP_2_COLOR,
line_dash=options.STATS_2_MEAN_LINE_DASH,
alpha=options.STATS_2_MEAN_ALPHA)
# Add all DVHs, but hide them until selected
self.plot.multi_line('x',
'y',
source=sources.dvhs,
selection_color='color',
line_width=options.DVH_LINE_WIDTH,
alpha=0,
line_dash=options.DVH_LINE_DASH,
nonselection_alpha=0,
selection_alpha=1)
# Shaded region between Q1 and Q3
iqr_1 = self.plot.patch('x_patch',
'y_patch',
source=sources.patch_1,
alpha=options.IQR_1_ALPHA,
color=options.GROUP_1_COLOR)
iqr_2 = self.plot.patch('x_patch',
'y_patch',
source=sources.patch_2,
alpha=options.IQR_2_ALPHA,
color=options.GROUP_2_COLOR)
# Set x and y axis labels
self.plot.xaxis.axis_label = "Dose (Gy)"
self.plot.yaxis.axis_label = "Normalized Volume"
# Set the legend (for stat dvhs only)
legend_stats = Legend(items=[("Median", [stats_median_1]),
("Mean", [stats_mean_1]),
("IQR", [iqr_1]),
("Median", [stats_median_2]),
("Mean", [stats_mean_2]),
("IQR", [iqr_2])],
location=(25, 0))
# Add the layout outside the plot, clicking legend item hides the line
self.plot.add_layout(legend_stats, 'right')
self.plot.legend.click_policy = "hide"
self.download_endpoints_button = Button(label="Download Endpoints",
button_type="default",
width=150)
self.download_endpoints_button.callback = CustomJS(
args=dict(source=sources.endpoint_calcs),
code=open(join(dirname(__file__), "download_endpoints.js")).read())
# Setup axis normalization radio buttons
self.radio_group_dose = RadioGroup(
labels=["Absolute Dose", "Relative Dose (Rx)"],
active=0,
width=200)
self.radio_group_dose.on_change('active', self.radio_group_ticker)
self.radio_group_volume = RadioGroup(
labels=["Absolute Volume", "Relative Volume"], active=1, width=200)
self.radio_group_volume.on_change('active', self.radio_group_ticker)
# Setup selectors for dvh review
self.select_reviewed_mrn = Select(title='MRN to review',
value='',
options=self.dvh_review_mrns,
width=300)
self.select_reviewed_mrn.on_change('value',
self.update_dvh_review_rois)
self.select_reviewed_dvh = Select(title='ROI to review',
value='',
options=[''],
width=360)
self.select_reviewed_dvh.on_change('value',
self.select_reviewed_dvh_ticker)
self.review_rx = TextInput(value='', title="Rx Dose (Gy):", width=170)
self.review_rx.on_change('value', self.review_rx_ticker)
if options.LITE_VIEW:
self.layout = column(
Div(text="<b>DVH Analytics v%s</b>" % options.VERSION),
row(self.radio_group_dose,
self.radio_group_volume), self.add_endpoint_row_button,
row(self.ep_row, Spacer(width=10), self.select_ep_type,
self.ep_text_input, Spacer(width=20),
self.ep_units_in, self.delete_ep_row_button,
Spacer(width=50), self.download_endpoints_button),
data_tables.ep)
else:
self.layout = column(
Div(text="<b>DVH Analytics v%s</b>" % options.VERSION),
row(custom_title['1']['dvhs'], Spacer(width=50),
custom_title['2']['dvhs']),
row(self.radio_group_dose, self.radio_group_volume),
row(self.select_reviewed_mrn, self.select_reviewed_dvh,
self.review_rx), self.plot,
Div(text="<b>DVHs</b>", width=1200), data_tables.dvhs,
Div(text="<hr>", width=1050),
Div(text="<b>Define Endpoints</b>",
width=1000), self.add_endpoint_row_button,
row(self.ep_row, Spacer(width=10), self.select_ep_type,
self.ep_text_input, Spacer(width=20),
self.ep_units_in, self.delete_ep_row_button,
Spacer(width=50), self.download_endpoints_button),
data_tables.ep, Div(text="<b>DVH Endpoints</b>",
width=1200), data_tables.endpoints)
def add_endpoint(self):
if self.sources.endpoint_defs.data['row']:
temp = self.sources.endpoint_defs.data
for key in list(temp):
temp[key].append('')
temp['row'][-1] = len(temp['row'])
self.sources.endpoint_defs.data = temp
new_options = [str(x + 1) for x in range(len(temp['row']))]
self.ep_row.options = new_options
self.ep_row.value = new_options[-1]
else:
self.ep_row.options = ['1']
self.ep_row.value = '1'
self.sources.endpoint_defs.data = dict(row=['1'],
output_type=[''],
input_type=[''],
input_value=[''],
label=[''],
units_in=[''],
units_out=[''])
if not self.ep_text_input.value:
self.ep_text_input.value = '1'
self.update_ep_source()
clear_source_selection(self.sources, 'endpoint_defs')
def update_ep_source(self):
if self.ep_row.value:
r = int(self.ep_row.value) - 1
if 'Dose' in self.select_ep_type.value:
input_type, output_type = 'Volume', 'Dose'
if '%' in self.select_ep_type.value:
units_out = '%'
else:
units_out = 'Gy'
units_in = ['cc', '%'][self.ep_units_in.active]
label = "D_%s%s" % (self.ep_text_input.value, units_in)
else:
input_type, output_type = 'Dose', 'Volume'
if '%' in self.select_ep_type.value:
units_out = '%'
else:
units_out = 'cc'
units_in = ['Gy', '%'][self.ep_units_in.active]
label = "V_%s%s" % (self.ep_text_input.value, units_in)
try:
input_value = float(self.ep_text_input.value)
except:
input_value = 1
patch = {
'output_type': [(r, output_type)],
'input_type': [(r, input_type)],
'input_value': [(r, input_value)],
'label': [(r, label)],
'units_in': [(r, units_in)],
'units_out': [(r, units_out)]
}
self.sources.endpoint_defs.patch(patch)
self.update_source_endpoint_calcs()
def ep_units_in_ticker(self, attr, old, new):
if self.query.allow_source_update:
self.update_ep_text_input_title()
self.update_ep_source()
def update_ep_text_input_title(self):
if 'Dose' in self.select_ep_type.value:
self.ep_text_input.title = "Input Volume (%s):" % [
'cc', '%'
][self.ep_units_in.active]
else:
self.ep_text_input.title = "Input Dose (%s):" % [
'Gy', '%'
][self.ep_units_in.active]
def select_ep_type_ticker(self, attr, old, new):
if self.query.allow_source_update:
if 'Dose' in new:
self.ep_units_in.labels = ['cc', '%']
else:
self.ep_units_in.labels = ['Gy', '%']
self.update_ep_text_input_title()
self.update_ep_source()
def ep_text_input_ticker(self, attr, old, new):
if self.query.allow_source_update:
self.update_ep_source()
def delete_ep_row(self):
if self.ep_row.value:
new_ep_source = self.sources.endpoint_defs.data
index_to_delete = int(self.ep_row.value) - 1
new_source_length = len(
self.sources.endpoint_defs.data['output_type']) - 1
if new_source_length == 0:
clear_source_data(self.sources, 'endpoint_defs')
self.ep_row.options = ['']
self.ep_row.value = ''
else:
for key in list(new_ep_source):
new_ep_source[key].pop(index_to_delete)
for i in range(index_to_delete, new_source_length):
new_ep_source['row'][i] -= 1
self.ep_row.options = [
str(x + 1) for x in range(new_source_length)
]
if self.ep_row.value not in self.ep_row.options:
self.ep_row.value = self.ep_row.options[-1]
self.sources.endpoint_defs.data = new_ep_source
self.update_source_endpoint_calcs(
) # not efficient, but still relatively quick
clear_source_selection(self.sources, 'endpoint_defs')
def update_ep_row_on_selection(self, attr, old, new):
self.query.allow_source_update = False
if new:
data = self.sources.endpoint_defs.data
r = min(new)
# update row
self.ep_row.value = self.ep_row.options[r]
# update input value
self.ep_text_input.value = str(data['input_value'][r])
# update input units radio button
if '%' in data['units_in'][r]:
self.ep_units_in.active = 1
else:
self.ep_units_in.active = 0
# update output
if 'Dose' in data['output_type'][r]:
if '%' in data['units_in'][r]:
self.select_ep_type.value = self.ep_options[1]
else:
self.select_ep_type.value = self.ep_options[0]
else:
if '%' in data['units_in'][r]:
self.select_ep_type.value = self.ep_options[3]
else:
self.select_ep_type.value = self.ep_options[2]
self.query.allow_source_update = True
def update_source_endpoint_calcs(self):
if self.query.current_dvh:
group_1_constraint_count, group_2_constraint_count = group_constraint_count(
self.sources)
ep = {'mrn': ['']}
ep_group = {'1': {}, '2': {}}
table_columns = []
ep['mrn'] = self.query.current_dvh.mrn
ep['uid'] = self.query.current_dvh.study_instance_uid
ep['group'] = self.sources.dvhs.data['group']
ep['roi_name'] = self.sources.dvhs.data['roi_name']
table_columns.append(TableColumn(field='mrn', title='MRN'))
table_columns.append(TableColumn(field='group', title='Group'))
table_columns.append(
TableColumn(field='roi_name', title='ROI Name'))
data = self.sources.endpoint_defs.data
for r in range(len(data['row'])):
ep_name = str(data['label'][r])
table_columns.append(
TableColumn(field=ep_name,
title=ep_name,
formatter=NumberFormatter(format="0.00")))
x = data['input_value'][r]
if '%' in data['units_in'][r]:
endpoint_input = 'relative'
x /= 100.
else:
endpoint_input = 'absolute'
if '%' in data['units_out'][r]:
endpoint_output = 'relative'
else:
endpoint_output = 'absolute'
if 'Dose' in data['output_type'][r]:
ep[ep_name] = self.query.current_dvh.get_dose_to_volume(
x,
volume_scale=endpoint_input,
dose_scale=endpoint_output)
for g in GROUP_LABELS:
if self.time_series.current_dvh_group[g]:
ep_group[g][
ep_name] = self.time_series.current_dvh_group[
g].get_dose_to_volume(
x,
volume_scale=endpoint_input,
dose_scale=endpoint_output)
else:
ep[ep_name] = self.query.current_dvh.get_volume_of_dose(
x,
dose_scale=endpoint_input,
volume_scale=endpoint_output)
for g in GROUP_LABELS:
if self.time_series.current_dvh_group[g]:
ep_group[g][
ep_name] = self.time_series.current_dvh_group[
g].get_volume_of_dose(
x,
dose_scale=endpoint_input,
volume_scale=endpoint_output)
if group_1_constraint_count and group_2_constraint_count:
ep_1_stats = calc_stats(ep_group['1'][ep_name])
ep_2_stats = calc_stats(ep_group['2'][ep_name])
stats = []
for i in range(len(ep_1_stats)):
stats.append(ep_1_stats[i])
stats.append(ep_2_stats[i])
ep[ep_name].extend(stats)
else:
ep[ep_name].extend(calc_stats(ep[ep_name]))
self.sources.endpoint_calcs.data = ep
# Update endpoint calc from review_dvh, if available
if self.sources.dvhs.data['y'][0] != []:
review_ep = {}
rx = float(self.sources.dvhs.data['rx_dose'][0])
volume = float(self.sources.dvhs.data['volume'][0])
data = self.sources.endpoint_defs.data
for r in range(len(data['row'])):
ep_name = str(data['label'][r])
x = data['input_value'][r]
if '%' in data['units_in'][r]:
endpoint_input = 'relative'
x /= 100.
else:
endpoint_input = 'absolute'
if '%' in data['units_out'][r]:
endpoint_output = 'relative'
else:
endpoint_output = 'absolute'
if 'Dose' in data['output_type'][r]:
if endpoint_input == 'relative':
current_ep = dose_to_volume(y, x)
else:
current_ep = dose_to_volume(y, x / volume)
if endpoint_output == 'relative' and rx != 0:
current_ep = current_ep / rx
else:
if endpoint_input == 'relative':
current_ep = volume_of_dose(y, x * rx)
else:
current_ep = volume_of_dose(y, x)
if endpoint_output == 'absolute' and volume != 0:
current_ep = current_ep * volume
review_ep[ep_name] = [(0, current_ep)]
review_ep['mrn'] = [(0, self.select_reviewed_mrn.value)]
self.sources.endpoint_calcs.patch(review_ep)
self.update_endpoint_view()
if not options.LITE_VIEW:
self.time_series.update_options()
def update_endpoint_view(self):
if self.query.current_dvh:
rows = len(self.sources.endpoint_calcs.data['mrn'])
ep_view = {
'mrn': self.sources.endpoint_calcs.data['mrn'],
'group': self.sources.endpoint_calcs.data['group'],
'roi_name': self.sources.endpoint_calcs.data['roi_name']
}
for i in range(1, options.ENDPOINT_COUNT + 1):
ep_view["ep%s" %
i] = [''] * rows # filling table with empty strings
for r in range(len(self.sources.endpoint_defs.data['row'])):
if r < options.ENDPOINT_COUNT: # limiting UI to ENDPOINT_COUNT for efficiency
key = self.sources.endpoint_defs.data['label'][r]
ep_view["ep%s" %
(r + 1)] = self.sources.endpoint_calcs.data[key]
self.sources.endpoint_view.data = ep_view
if not options.LITE_VIEW:
self.correlation.update_or_add_endpoints_to_correlation()
categories = list(self.correlation.data['1'])
categories.sort()
self.regression.x.options = [''] + categories
self.regression.y.options = [''] + categories
self.correlation.validate_data()
self.correlation.update_correlation_matrix()
self.regression.update_data()
def update_source_endpoint_view_selection(self, attr, old, new):
if new:
self.sources.endpoint_view.selected.indices = new
def update_dvh_table_selection(self, attr, old, new):
if new:
self.sources.dvhs.selected.indices = new
def update_dvh_review_rois(self, attr, old, new):
if self.select_reviewed_mrn.value:
if new != '':
self.dvh_review_rois = self.temp_dvh_info.get_roi_names(
new).values()
self.select_reviewed_dvh.options = self.dvh_review_rois
self.select_reviewed_dvh.value = self.dvh_review_rois[0]
else:
self.select_reviewed_dvh.options = ['']
self.select_reviewed_dvh.value = ['']
else:
self.select_reviewed_dvh.options = ['']
self.select_reviewed_dvh.value = ''
patches = {
'x': [(0, [])],
'y': [(0, [])],
'roi_name': [(0, '')],
'volume': [(0, '')],
'min_dose': [(0, '')],
'mean_dose': [(0, '')],
'max_dose': [(0, '')],
'mrn': [(0, '')],
'rx_dose': [(0, '')]
}
self.sources.dvhs.patch(patches)
def calculate_review_dvh(self):
global x, y
patches = {
'x': [(0, [])],
'y': [(0, [])],
'roi_name': [(0, '')],
'volume': [(0, 1)],
'min_dose': [(0, '')],
'mean_dose': [(0, '')],
'max_dose': [(0, '')],
'mrn': [(0, '')],
'rx_dose': [(0, 1)]
}
try:
if not self.sources.dvhs.data['x']:
self.query.update_data()
else:
file_index = self.temp_dvh_info.mrn.index(
self.select_reviewed_mrn.value)
roi_index = self.dvh_review_rois.index(
self.select_reviewed_dvh.value)
structure_file = self.temp_dvh_info.structure[file_index]
plan_file = self.temp_dvh_info.plan[file_index]
dose_file = self.temp_dvh_info.dose[file_index]
key = list(
self.temp_dvh_info.get_roi_names(
self.select_reviewed_mrn.value))[roi_index]
rt_st = dicomparser.DicomParser(structure_file)
rt_structures = rt_st.GetStructures()
review_dvh = dvhcalc.get_dvh(structure_file, dose_file, key)
dicompyler_plan = dicomparser.DicomParser(plan_file).GetPlan()
roi_name = rt_structures[key]['name']
volume = review_dvh.volume
min_dose = review_dvh.min
mean_dose = review_dvh.mean
max_dose = review_dvh.max
if not self.review_rx.value:
rx_dose = float(dicompyler_plan['rxdose']) / 100.
self.review_rx.value = str(round(rx_dose, 2))
else:
rx_dose = round(float(self.review_rx.value), 2)
x = review_dvh.bincenters
if max(review_dvh.counts):
y = np.divide(review_dvh.counts, max(review_dvh.counts))
else:
y = review_dvh.counts
if self.radio_group_dose.active == 1:
f = 5000
bin_count = len(x)
new_bin_count = int(bin_count * f / (rx_dose * 100.))
x1 = np.linspace(0, bin_count, bin_count)
x2 = np.multiply(
np.linspace(0, new_bin_count, new_bin_count),
rx_dose * 100. / f)
y = np.interp(x2, x1, review_dvh.counts)
y = np.divide(y, np.max(y))
x = np.divide(np.linspace(0, new_bin_count, new_bin_count),
f)
if self.radio_group_volume.active == 0:
y = np.multiply(y, volume)
patches = {
'x': [(0, x)],
'y': [(0, y)],
'roi_name': [(0, roi_name)],
'volume': [(0, volume)],
'min_dose': [(0, min_dose)],
'mean_dose': [(0, mean_dose)],
'max_dose': [(0, max_dose)],
'mrn': [(0, self.select_reviewed_mrn.value)],
'rx_dose': [(0, rx_dose)]
}
except:
pass
self.sources.dvhs.patch(patches)
self.update_source_endpoint_calcs()
def select_reviewed_dvh_ticker(self, attr, old, new):
self.calculate_review_dvh()
def review_rx_ticker(self, attr, old, new):
if self.radio_group_dose.active == 0:
self.sources.dvhs.patch(
{'rx_dose': [(0, round(float(self.review_rx.value), 2))]})
else:
self.calculate_review_dvh()
def radio_group_ticker(self, attr, old, new):
if self.sources.dvhs.data['x'] != '':
self.query.update_data()
self.calculate_review_dvh()
def add_query_link(self, query):
self.query = query
def compare():
# if proj among arguments, show this tree first.
try:
proj_a = int(request.args.get('proj_a', None))
proj_b = int(request.args.get('proj_b', None))
except (TypeError, ValueError):
proj_a = proj_b = None
include = request.args.get('include', None)
# list of projects (and proj_names) used to create dropdown project selector
upload_list = UserFile.query.filter_by(user_id=current_user.id).\
filter_by(run_complete=True).order_by(UserFile.file_id).all()
if len(upload_list) > 1:
# Use specified project from args or highest file_id as CURRENT PROJECT
current_proj = upload_list[-1] # override if valid proj specified
if proj_a and proj_b:
current_temp_a = [u for u in upload_list if u.file_id == proj_a]
current_temp_b = [u for u in upload_list if u.file_id == proj_b]
# if not among user's finished projects, use highest file_id
if len(current_temp_a) == 1 and len(current_temp_b) == 1:
current_proj_a = current_temp_a[0]
current_proj_b = current_temp_b[0]
else:
current_proj_a = upload_list[-2]
current_proj_b = upload_list[-1]
else:
current_proj_a = upload_list[-2]
current_proj_b = upload_list[-1]
detail_path1 = naming_rules.get_detailed_path(current_proj_a)
detail_path2 = naming_rules.get_detailed_path(current_proj_b)
js_name1 = naming_rules.get_js_name(current_proj_a)
js_name2 = naming_rules.get_js_name(current_proj_b)
xlabel = u"Effect size ({})".format(current_proj_a.get_fancy_filename())
ylabel = u"Effect size ({})".format(current_proj_b.get_fancy_filename())
# load pathways with 1+ mutation in 1+ patients,
# ignoring ones with 'cancer' etc in name
all_paths1 = load_pathway_list_from_file(detail_path1)
all_paths2 = load_pathway_list_from_file(detail_path2)
# IDs with p<0.05 and +ve effect
sig_p = OrderedDict(
[(i.path_id, i.nice_name) for i in all_paths1 if i.gene_set])
sig_pids1 = [i for i in sig_p]
sig_p2 = OrderedDict(
[(i.path_id, i.nice_name) for i in all_paths2 if i.gene_set])
sig_pids2 = [i for i in sig_p2]
sig_p.update(sig_p2) # ORDERED by proj1 effect size
# BUILD DATAFRAME WITH ALL sig PATHWAYS, proj1 object order.
pway_names = sig_p.values() # order important
columns = ['path_id', 'pname', 'ind1', 'ind2', 'e1', 'e2', 'e1_only',
'e2_only', 'q1', 'q2']
df = pd.DataFrame(index=sig_p.keys(), data={'pname': pway_names},
columns=columns)
for path_group, evar, qvar, ind, sigs in \
[(all_paths1, 'e1', 'q1', 'ind1', sig_pids1),
(all_paths2, 'e2', 'q2', 'ind2', sig_pids2)]:
for path in path_group:
path_id = path.path_id
if path_id not in sig_p:
continue
df.loc[path_id, evar] = get_effect(path)
df.loc[path_id, qvar] = get_q(path)
temp_ind = sigs.index(path_id) if path_id in sigs else -1
df.loc[path_id, ind] = temp_ind
df.ind1.fillna(-1, inplace=True)
df.ind2.fillna(-1, inplace=True)
df.e1_only = df.where(df.e2.isnull())['e1']
df.e2_only = df.where(df.e1.isnull())['e2']
inds1 = list(df.ind1)
inds2 = list(df.ind2)
source = ColumnDataSource(data=df)
source_full = ColumnDataSource(data=df)
source.name, source_full.name = 'data_visible', 'data_full'
# SET UP FIGURE
minx = df.e1.min()
minx *= 1 - minx / abs(minx) * 0.2
miny = df.e2.min()
miny *= 1 - miny/abs(miny) * 0.2
maxx = df.e1.max() * 1.2
maxy = df.e2.max() * 1.2
TOOLS = "lasso_select,box_select,hover,crosshair,pan,wheel_zoom,"\
"box_zoom,reset,tap,help" # poly_select,lasso_select, previewsave
# SUPLOTS
p = figure(plot_width=DIM_COMP_W, plot_height=DIM_COMP_H, tools=TOOLS,
title=None, logo=None, toolbar_location="above",
x_range=Range1d(minx, maxx), y_range=Range1d(miny, maxy),
x_axis_type="log", y_axis_type="log"
)
pb = figure(plot_width=DIM_COMP_SM, plot_height=DIM_COMP_H, tools=TOOLS,
y_range=p.y_range, x_axis_type="log", y_axis_type="log")
pa = figure(plot_width=DIM_COMP_W, plot_height=DIM_COMP_SM, tools=TOOLS,
x_range=p.x_range, x_axis_type="log", y_axis_type="log")
pp = figure(plot_width=DIM_COMP_SM, plot_height=DIM_COMP_SM,
tools=TOOLS, outline_line_color=None)
# SPANS
p.add_layout(plot_fns.get_span(1, 'height'))
p.add_layout(plot_fns.get_span(1, 'width'))
pa.add_layout(plot_fns.get_span(1, 'height'))
pb.add_layout(plot_fns.get_span(1, 'width'))
# STYLE
for ax in [p, pa, pb]:
ax.grid.visible = False
ax.outline_line_width = 2
ax.background_fill_color = 'whitesmoke'
for ax in [pa, pb]:
ax.xaxis.visible = False
ax.yaxis.visible = False
pa.title.text = xlabel
pb.title.text = ylabel
pa.title_location, pa.title.align = 'below', 'center'
pb.title_location, pb.title.align = 'left', 'center'
# WIDGETS
q_input = TextInput(value='', title="P* cutoff",
placeholder='e.g. 0.05')
gene_input = TextInput(value='', title="Gene list",
placeholder='e.g. TP53,BRAF')
radio_include = RadioGroup(labels=["Include", "Exclude"], active=0)
widgets = widgetbox(q_input, gene_input, radio_include, width=200,
css_classes=['widgets_sg'])
grid = gridplot([[pb, p, widgets],
[Spacer(width=DIM_COMP_SM), pa, Spacer()]],
sizing_mode='fixed')
cb_inclusion = CustomJS(args=dict(genes=gene_input), code="""
var gene_str = genes.value
if (!gene_str)
return;
var include = cb_obj.active == 0 ? true : false
selectPathwaysByGenes(gene_str, include);
""")
cb_genes = CustomJS(args=dict(radio=radio_include), code="""
var gene_str = cb_obj.value
if (!gene_str)
return;
var include = radio.active == 0 ? true : false
selectPathwaysByGenes(gene_str, include);
""")
radio_include.js_on_change('active', cb_inclusion)
gene_input.js_on_change('value', cb_genes)
# SCATTER
p.circle("e1", "e2", source=source, **SCATTER_KW)
pa.circle('e1_only', 1, source=source, **SCATTER_KW)
pb.circle(1, 'e2_only', source=source, **SCATTER_KW)
# HOVER
for hover in grid.select(dict(type=HoverTool)):
hover.tooltips = OrderedDict([
("name", "@pname"),
("effects", "(@e1, @e2)"),
("P*", ("(@q1, @q2)"))
])
# ADD Q FILTERING CALLBACK
callback = CustomJS(args=dict(source=source, full=source_full), code="""
// get old selection indices, if any
var prv_selected = source.selected['1d'].indices;
var prv_select_full = []
for(var i=0; i<prv_selected.length; i++){
prv_select_full.push(scatter_array[prv_selected[i]])
}
var new_selected = []
var q_val = cb_obj.value;
if(q_val == '')
q_val = 1
var fullset = full.data;
var n_total = fullset['e1'].length;
// Convert float64arrays to array
var col_names = %s ;
col_names.forEach(function(col_name){
source.data[col_name] = [].slice.call(source.data[col_name])
source.data[col_name].length = 0
})
scatter_array.length = 0;
var j = -1; // new glyph indices
for (i = 0; i < n_total; i++) {
this_q1 = fullset['q1'][i];
this_q2 = fullset['q2'][i];
if(this_q1 <= q_val || this_q2 <= q_val){
j++; // preserve previous selection if still visible
col_names.forEach(function(col){
source.data[col].push(fullset[col][i]);
})
scatter_array.push(i)
if($.inArray(i, prv_select_full) > -1){
new_selected.push(j);
}
}
}
source.selected['1d'].indices = new_selected;
source.trigger('change');
updateIfSelectionChange_afterWait();
""" % columns)
q_input.js_on_change('value', callback)
script, div = plot_fns.get_bokeh_components(grid)
proj_dir_a = naming_rules.get_project_folder(current_proj_a)
proj_dir_b = naming_rules.get_project_folder(current_proj_b)
if os.path.exists(os.path.join(proj_dir_a, 'matrix_svg_cnv')) and \
os.path.exists(os.path.join(proj_dir_b, 'matrix_svg_cnv')):
has_cnv = True
else:
has_cnv = False
else: # not enough projects yet!
flash("Two completed projects are required for a comparison.",
"warning")
return redirect(url_for('.index'))
return render_template('pway/compare.html',
current_projs=[current_proj_a, current_proj_b],
inds_use=[inds1, inds2],
has_cnv=has_cnv,
js_name_a=js_name1,
js_name_b=js_name2,
projects=upload_list,
bokeh_script=script,
bokeh_div=div, include_genes=include,
resources=plot_fns.resources)
def plotting(self):
if self.debug:
self.debug_file = open("debug_output.txt", "w")
self.debug_file.write("Initialized plotting subroutine \n")
TOOLS="pan,wheel_zoom,box_zoom,reset,hover,previewsave"
tab_plots = []
self.all_elements = []
self.elements_comparison = []
for filename in self.filenames:
if "ITO" in filename:
tab_plots.append(self.mass_plotting(filename))
continue
data_dict = self.data_generation(filename)
self.data_test(data_dict)
name_check = data_dict["gen_info"]["DATA FILES"]
attr_id = name_check[1][4][:-3] + "_" + name_check[2][2]
self.attribute_ids.append(attr_id)
attr_extra_y_ranges = False
attr_extra_x_ranges = False
local_source_line = []
"""
create plots for each datafile and put them in a tab.
"""
y_axis_units = [x["y_unit"] for x in data_dict["data"]]
x_axis_units = [x["x_unit"] for x in data_dict["data"]]
figure_obj = figure(plot_width = 1000, plot_height = 800, y_axis_type = "log",
title = attr_id, tools = TOOLS)
#figure_obj.axes.major_label_text_font_size("12pt")
#figure_obj.major_label_text_font_size("12pt")
hover = figure_obj.select(dict(type = HoverTool))
hover.tooltips = [
("Element:", "@element"),
("(x, y):", "($x, $y)")]
self.figure_data.append((figure_obj, data_dict))
figure_obj.yaxis.axis_label = y_axis_units[0]
figure_obj.xaxis.axis_label = x_axis_units[0]
if not all(x == y_axis_units[0] for x in y_axis_units):
for unit, dataset in zip(y_axis_units, data_dict["data"]):
if not unit == y_axis_units[0]:
extra_y_ranges_exists = attr_extra_y_ranges
extra_y_ranges_exists = True
if self.debug:
self.debug_file.write("Added extra y-axis for file_id: %s, element: %s | New length %g \n"
%(attr_id, dataset["sample_element"], len(figure_obj.yaxis)))
figure_obj.extra_y_ranges = {"foo": Range1d(start = np.amin(dataset["y"]),
end = np.amax(dataset["y"]))}
figure_obj.add_layout(LogAxis(y_range_name = "foo", axis_label = unit), "right")
break
if not all(x == x_axis_units[0] for x in x_axis_units):
for unit, dataset in zip(x_axis_units, data_dict["data"]):
if not unit == x_axis_units[0]:
extra_x_ranges_exists = attr_extra_x_ranges
extra_x_ranges_exists = True
if self.debug:
self.debug_file.write("Added extra x-axis for file_id: %s, element: %s. | New length %g \n"
%(attr_id, dataset["sample_element"], len(figure_obj.yaxis)))
figure_obj.extra_x_ranges = {"bar": Range1d(start = np.amin(dataset["x"]),
end = np.amax(dataset["x"]))}
figure_obj.add_layout(LinearAxis(x_range_name = "bar", axis_label = unit), "above")
break
figure_obj.xaxis.axis_label = x_axis_units[0]
colour_list = Spectral11 + RdPu9 + Oranges9
colour_indices = [0, 2, 8, 10, 12, 14, 20, 22, 1, 3, 9, 11, 13, 15]
list_of_elements = []
source_list = []
line_list = []
for dataset, color_index in zip(data_dict["data"], colour_indices):
self.all_elements.append(dataset["sample_element"]) #strip isotope number
color = colour_list[color_index]
source = ColumnDataSource(data = dataset) #Datastructure for source of plotting
self.source_test(source)
list_of_elements.append(dataset["sample_element"])
line_glyph = figure_obj.line("x", "y", source = source,
line_width = 2,
line_color = color,
legend = dataset["sample_element"])
if self.debug:
self.debug_file.write("Create line object on figure %s at %s \n" %(id(figure_obj), id(line_glyph)))
line_list.append(line_glyph)
source_list.append(source)
local_source_line.append([[source, line] for source, line in zip(source_list, line_list)])
self.source_line.append(local_source_line)
#Calculations on the dataset
text_input_rsf = TextInput(value = "default", title = "RSF or SF (at/cm^3): ")
do_integral_button = Button(label = "Calibration integral")
smoothing_button = Button(label = "smth selct elem")
matplot_button = Button(label = "Create matplotlib fig")
text_input_sputter = TextInput(value = "default", title = "Sputter speed: number unit")
text_input_crater_depth = TextInput(value = "default", title = "Depth of crater in: number unit")
radio_group = RadioGroup(labels = list_of_elements, active=0)
text_input_xval_integral = TextInput(value = "0", title = "x-delimiter ")
text_input_dose = TextInput(value = "0", title = "Dose[cm^-2] ")
#Save files for later use
save_flexDPE_button = Button(label = "Save element for FlexPDE")
save_all_flexDPE_button = Button(label = "Save all elements for FlexPDE")
save_textfile_button = Button(label = "Sava Data in textfile")
#Pointers to methods on click / change handlers
radio_group.on_change("active", lambda attr, old, new: None)
matplot_button.on_click(lambda source_list = source_list:
self.matplotlib_export(source_list))
do_integral_button.on_click(lambda
source_list = source_list,
line_list = line_list,
source_line = self.source_line,
figure_data = self.figure_data,
data_dict = data_dict,
radio = radio_group,
x_box = text_input_xval_integral,
dose = text_input_dose,
extra_y_ranges = attr_extra_y_ranges:
self.integrate(data_dict, source_list, line_list, source_line, figure_data, radio, x_box, dose, extra_y_ranges))
smoothing_button.on_click(lambda
source_list = source_list,
radio = radio_group,
data_dict = data_dict,
x_box = text_input_xval_integral:
self.smoothing(source_list, data_dict, radio, x_box) )
save_flexDPE_button.on_click(lambda
source_list = source_list,
attrname = attr_id,
radio = radio_group:
self.write_to_flexPDE(source_list, attrname, radio))
save_all_flexDPE_button.on_click(lambda
source_list = source_list,
attrname = attr_id:
self.write_all_to_flexPDE(source_list, attrname))
save_textfile_button.on_click(lambda
data_dict = data_dict,
source_list = source_list,
attrname = attr_id,
radio = radio_group:
self.write_new_datafile(data_dict, source_list, attrname,radio))
text_input_rsf.on_change("value", lambda attr, old, new,
radio = radio_group,
data_dict = data_dict,
figure = figure_obj,
source_list = source_list,
text_input = text_input_rsf,
line_list = line_list,
which = "rsf":
self.update_data(line_list, data_dict, source_list, figure, radio, text_input, new, which))
text_input_sputter.on_change("value", lambda attr, old, new,
radio = radio_group,
data_dict = data_dict,
figure = figure_obj,
source_list = source_list,
text_input = text_input_sputter,
which = "sputter":
self.update_data(data_dict, source_list, figure, radio, text_input, new, which))
text_input_crater_depth.on_change("value", lambda attr, old, new,
radio = radio_group,
data_dict = data_dict,
source_list = source_list,
figure = figure_obj,
text_input = text_input_crater_depth,
which = "crater_depth":
self.update_data(data_dict, source_list, figure, radio, text_input, new, which))
#Initialization of actual plotting.
tab_plots.append(Panel(child = hplot(figure_obj,
vform(
vform(radio_group, save_flexDPE_button, save_all_flexDPE_button, save_textfile_button, matplot_button),
vform(text_input_rsf, smoothing_button, text_input_sputter, text_input_crater_depth)
),
vform(text_input_xval_integral, text_input_dose, do_integral_button)),
title = attr_id))
"""
Check to see if one or more element exists in the samples and creat a comparison plot for each
of those elements.
"""
for element in self.all_elements:
checkers = list(self.all_elements)
checkers.remove(element)
if element in checkers and not element in self.elements_comparison:
self.elements_comparison.append(element)
"""create plots for each element that is to be compared """
for comparison_element in self.elements_comparison:
figure_obj = figure(plot_width = 1000, plot_height = 800, y_axis_type = "log", title = comparison_element, tools = TOOLS)
#figure_obj.xaxis.major_label_text_font_size("12pt")
#figure_obj.yaxis.major_label_text_font_size("12pt")
y_axis_units = []
x_axis_units = []
comparison_datasets = []
for data_dict_iter in self.column(self.figure_data, 1):
for dataset in data_dict_iter["data"]:
if dataset["sample_element"] == comparison_element:
comparison_datasets.append(dataset)
y_axis_units.append(dataset["y_unit"])
x_axis_units.append(dataset["x_unit"])
figure_obj.xaxis.axis_label = comparison_datasets[-1]["x_unit"]
figure_obj.yaxis.axis_label = comparison_datasets[-1]["y_unit"]
if not all(x == y_axis_units[-1] for x in y_axis_units):
for unit, data in zip(y_axis_units, comparison_datasets):
if not unit == y_axis_units[-1]:
figure_obj.extra_y_ranges = {"foo": Range1d(start = np.amin(data["y"]),
end = np.amax(data["y"]))}
figure_obj.add_layout(LogAxis(y_range_name = "foo", axis_label = unit), "right")
break
if not all(x == x_axis_units[-1] for x in x_axis_units):
for unit, data in zip(x_axis_units, comparison_datasets):
if not unit == x_axis_units[-1]:
figure_obj.extra_x_ranges = {"bar": Range1d(start = np.amin(data["x"]),
end = np.amax(data["x"]))}
figure_obj.add_layout(LinearAxis(x_range_name = "bar", axis_label = unit), "above")
break
active_sources = []
for data_dict, source_line_nested, attr_id, color_index in zip(self.column(self.figure_data, 1), self.source_line, self.attribute_ids, colour_indices):
for dataset, source_lis_coup, in zip(data_dict["data"], source_line_nested[0]):
source_local = source_lis_coup[0]
active_sources.append(source_local)
self.source_test(source_local)
self.source_dataset_test(source_local, dataset)
if dataset["sample_element"] == comparison_element:
color = colour_list[color_index]
"""
Logic that ensures that plots get put with correspoinding axes.
"""
if dataset["x_unit"] != x_axis_units[-1] or dataset["y_unit"] != y_axis_units[-1]:
if dataset["x_unit"] != x_axis_units[-1] and dataset["y_unit"] != y_axis_units[-1]:
name_check = data_dict["gen_info"]["DATA FILES"]
attr_id = name_check[1][4][:-3] + "_" + name_check[2][2]
figure_obj.line("x", "y", source = source_local,
line_width = 2,
line_color = color,
legend = attr_id,
x_range_name = "bar",
y_range_name = "foo")
elif dataset["x_unit"] != x_axis_units[-1]:
figure_obj.line("x", "y", source = source_local,
line_width = 2,
line_color = color,
legend = attr_id,
x_range_name = "bar")
else:
figure_obj.line("x", "y", source = source_local,
line_width = 2,
line_color = color,
legend = attr_id,
y_range_name = "foo")
else:
figure_obj.line("x", "y", source = source_local,
line_width = 2,
line_color = color,
legend = attr_id)
matplot_button = Button(label = "Create matplotlib fig")
save_all_flexDPE_button = Button(label = "Save all elements for FlexPDE")
matplot_button.on_click(lambda source_list = active_sources:
self.matplotlib_export(source_list))
save_all_flexDPE_button.on_click(lambda
source_list = active_sources,
attrname = comparison_element:
self.write_all_to_flexPDE(source_list, attrname))
tab_plots.append(Panel(child = hplot(figure_obj, vform(save_all_flexDPE_button, matplot_button)),
title = comparison_element))
tabs = Tabs(tabs = tab_plots)
#curdoc().add_root(tabs)
session = push_session(curdoc())
session.show()
session.loop_until_closed()
menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"), None, ("Item 3", "item_3_value")]
dropdown = Dropdown(label="Dropdown button", button_type="warning", menu=menu)
dropdown.js_on_click(CustomJS(code="console.log('dropdown: ' + this.value, this.toString())"))
dropdown_disabled = Dropdown(label="Dropdown button (disabled)", button_type="warning", disabled=True, menu=menu)
dropdown_disabled.js_on_click(CustomJS(code="console.log('dropdown_disabled: ' + this.value, this.toString())"))
#dropdown_split = Dropdown(label="Split button", button_type="danger", menu=menu, default_value="default")
#dropdown_split.js_on_click(CustomJS(code="console.log('dropdown_split: ' + this.value, this.toString())"))
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_group.js_on_click(CustomJS(code="console.log('checkbox_group: ' + this.active, this.toString())"))
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_group.js_on_click(CustomJS(code="console.log('radio_group: ' + this.active, this.toString())"))
checkbox_button_group = CheckboxButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_button_group.js_on_click(CustomJS(code="console.log('checkbox_button_group: ' + this.active, this.toString())"))
radio_button_group = RadioButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_button_group.js_on_click(CustomJS(code="console.log('radio_button_group: ' + this.active, this.toString())"))
widget_box = WidgetBox(children=[
button, button_disabled,
toggle_inactive, toggle_active,
dropdown, dropdown_disabled, #dropdown_split,
checkbox_group, radio_group,
checkbox_button_group, radio_button_group,
])
dropdown.on_click(lambda value: print('dropdown: %s' % value))
dropdown.js_on_click(CustomJS(code="console.log('dropdown: ' + this.value, this.toString())"))
dropdown_disabled = Dropdown(label="Dropdown button (disabled)", button_type="warning", menu=menu)
dropdown_disabled.on_click(lambda value: print('dropdown_disabled: %s' % value))
dropdown_disabled.js_on_click(CustomJS(code="console.log('dropdown_disabled: ' + this.value, this.toString())"))
#dropdown_split = Dropdown(label="Split button", button_type="danger", menu=menu, default_value="default")
#dropdown_split.on_click(lambda value: print('dropdown_split: %s' % value))
#dropdown_split.js_on_click(CustomJS(code="console.log('dropdown_split: ' + this.value, this.toString())"))
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_group.on_click(lambda value: print('checkbox_group: %s' % value))
checkbox_group.js_on_click(CustomJS(code="console.log('checkbox_group: ' + this.active, this.toString())"))
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_group.on_click(lambda value: print('radio_group: %s' % value))
radio_group.js_on_click(CustomJS(code="console.log('radio_group: ' + this.active, this.toString())"))
checkbox_button_group = CheckboxButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_button_group.on_click(lambda value: print('checkbox_button_group: %s' % value))
checkbox_button_group.js_on_click(CustomJS(code="console.log('checkbox_button_group: ' + this.active, this.toString())"))
radio_button_group = RadioButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_button_group.on_click(lambda value: print('radio_button_group: %s' % value))
radio_button_group.js_on_click(CustomJS(code="console.log('radio_button_group: ' + this.active, this.toString())"))
widgetBox = WidgetBox(children=[
button, button_disabled,
toggle_inactive, toggle_active,
dropdown, dropdown_disabled, #dropdown_split,
from bokeh.plotting import figure
x=[3,4,6,12,10,1,5,6,3,8]
y=[7,1,3,4,1,6,10,4,10,3]
label=['Red', 'Orange', 'Red', 'Orange','Red', 'Orange','Red', 'Orange','Red', 'Orange',]
df=pd.DataFrame({'x':x,'y':y,'label':label})
source = ColumnDataSource(data=dict(x=df.x, y=df.y,label=df.label))
plot_figure = figure(title='Radio Group',plot_height=450, plot_width=600,
tools="save,reset", toolbar_location="below")
plot_figure.scatter('x', 'y',color='label', source=source, size=10)
radio_group = RadioGroup(labels=["Red", "Orange"])
def radiogroup_click(attr,old,new):
active_radio=radio_group.active ##Getting radio button value
# filter the dataframe with value in radio-button
if active_radio==0:
selected_df = df[df['label'] == 'Red']
elif active_radio==1:
selected_df = df[df['label'] == "Orange"]
source.data=dict(x=selected_df.x, y=selected_df.y,label=selected_df.label)
radio_group.on_change('active',radiogroup_click)
def __init__(self):
self.grepolis = Grepolis()
imgRessource = []
for v in ["Bois", "Pierre", "Argent"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgRessource.append(Image(d))
colRess = column(*[img.figure for img in imgRessource])
self.inputRess = [
TextInput(value="", title=el + " :", width=150)
for el in ["Bois", "Pierre", "Argent"]
]
colinputRess = column(*self.inputRess)
imgDieu = []
for v in ["Athena", "Artemis", "Hades", "Zeus", "Poseidon", "Hera"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgDieu.append(Image(d, multiplier=3))
rowDieu = [HFill(5)]
for img in imgDieu:
rowDieu.append(HFill(5))
rowDieu.append(img.figure)
rowDieu = row(*rowDieu)
imgAtt = []
for v in ["Att_hack", "Att_sharp", "Att_distance"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgAtt.append(Image(d))
colAtt = column(*[img.figure for img in imgAtt])
self.inputAtt = [
TextInput(value="", title=el + " :", width=150)
for el in ["Contondantes", "Blanches", "De Jet"]
]
colinputAtt = column(*self.inputAtt)
imgDef = []
for v in ["Def_hack", "Def_sharp", "Def_distance"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgDef.append(Image(d))
colDef = column(*[img.figure for img in imgDef])
self.inputDef = [
TextInput(value="", title=el + " :", width=150)
for el in ["Contondantes", "Blanches", "De Jet"]
]
rowinputDef = column(*self.inputDef)
imgOther = []
for v in ["Vitesse", "Butin", "Faveur"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgOther.append(Image(d))
colOther = column(*[img.figure for img in imgOther])
self.inputFavBut = [
TextInput(value="", title=el + " :", width=150)
for el in ["Vitesse", "Butin", "Faveur"]
]
self.inputOther = column(*self.inputFavBut)
self.imgUnit = []
for v in [
"Combattant", "Frondeur", "Archer", "Hoplite", "Cavalier",
"Char", "Envoye", "Centaure", "Pegase"
]:
r = "static/" + v + ".jpg"
d = dict(url=[r])
self.imgUnit.append(Image(d, multiplier=2))
rowUnit = row(HFill(10), *[img.figure for img in self.imgUnit])
imgDefAtt = []
for v in ["Pop", "Attaque", "Defense"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgDefAtt.append(Image(d))
rowInputUnit = [HFill(10)]
self.unitInput = [
TextInput(value="", title=el + " :", width=80) for el in [
"Combattant", "Frondeur", "Archer", "Hoplite", "Cavalier",
"Char", "Envoye", "Centaure", "Pegase"
]
]
for inp in self.unitInput:
rowInputUnit.append(inp)
rowInputUnit.append(HFill(30))
rowInputUnit = row(HFill(10), *rowInputUnit)
self.selectUnit = CheckboxButtonGroup(labels=[
"Combattant", "Frondeur", "Archer", "Hoplite", "Cavalier", "Char",
"Envoye", "Centaure", "Pegase"
],
active=[i for i in range(9)])
self.selectUnit.on_change("active", self.updateSelectUnit)
self.Dieu = RadioButtonGroup(
labels=["Athena", "Artemis", "Hades", "Zeus", "Poseidon", "Hera"],
active=0,
width=1110)
self.Dieu.on_change('active', self.updateUnit)
self.attdef = RadioButtonGroup(labels=["Attaque", "Defense"],
active=0,
width=200)
self.attdef.on_change('active', self.switchAttDef)
self.typeAtt = RadioGroup(
labels=["Armes Contondantes", "Armes Blanches", "Armes de Jet"],
active=0,
width=150)
self.typeAtt.on_change('active', self.process2)
self.imgFaveur = Image(dict(url=["static/" + "Faveur" + ".png"]))
self.launch = Button(label="Lancer")
self.launch.on_click(self.process)
self.inputPop = TextInput(value="1500",
title="Population : ",
width=120)
self.inputPop.on_change("value", self.process2)
self.inputFav = TextInput(value="1500",
title="Faveur Max : ",
width=120)
self.inputFav.on_change("value", self.process2)
rowPop = row(HFill(10), self.typeAtt, imgDefAtt[1].figure, self.attdef,
HFill(30), imgDefAtt[2].figure, HFill(50),
imgDefAtt[0].figure, self.inputPop, HFill(50),
self.imgFaveur.figure, self.inputFav, HFill(50))
self.doc = column(
rowDieu, self.Dieu, VFill(20), rowPop, VFill(20), self.selectUnit,
rowUnit, rowInputUnit, VFill(20),
row(HFill(50), colRess, colinputRess,
HFill(40), colAtt, colinputAtt, HFill(40), colDef, rowinputDef,
HFill(40), colOther, self.inputOther))
#curdoc().add_root(column(rowDieu,self.Dieu,VFill(20),rowPop,VFill(20),self.selectUnit,rowUnit,rowInputUnit,VFill(20),row(HFill(50),colRess,colinputRess,HFill(40),colAtt,colinputAtt,HFill(40),colDef,rowinputDef,HFill(40),colOther,self.inputOther)))
self.process(None)
def select_battype_handler(attr, old, new):
settings['bat_type'] = new
select_battype.on_change('value', select_battype_handler)
select_chrg_type = Select(title="Charge Type", value="Charge", options=["Charge", "Discharge", "Cycle", "Re-Peak", "AutoCharge", "Balance Charge", "Fast Charge", "Storage"])
def select_chrg_type_handler(attr, old, new):
settings['chrg_type'] = new
select_chrg_type.on_change('value', select_chrg_type_handler)
maxmah_slider = Slider(start=50, end=24000, value=1, step=50, title="Bat. Specified Capacity, mah")
def maxmah_handler(attr, old, new):
settings['nominal_mah'] = new
maxmah_slider.on_change('value', maxmah_handler)
DC_radio_group = RadioGroup(labels=["Discharge/Charge", "Charge/Discharge"], active=0)
def DC_radio_handler(new):
settings['DC'] = new
DC_radio_group.on_click(DC_radio_handler)
select_cells = Select(title = "No. of Cells", value ="4", options = [str(i) for i in range(1,13)])
def select_cells_handler(attr, old, new):
settings['cells'] = new
select_cells.on_change('value', select_cells_handler)
#imax discharge/charge # of cycles; imax limit is 5
#no way to read this from imax only shows up in set up packet
select_cycles = Select(title = "Cycles", value ="1", options = [str(i) for i in range(1,6)])
def select_cycles_handler(attr, old, new):
settings['cycles'] = new
select_cycles.on_change('value', select_cycles_handler)
def __init__(self, sources, time_series, correlation, regression,
custom_title, data_tables):
self.sources = sources
self.time_series = time_series
self.correlation = correlation
self.regression = regression
self.dvh_review_rois = []
self.query = None
self.temp_dvh_info = Temp_DICOM_FileSet()
self.dvh_review_mrns = self.temp_dvh_info.mrn
if self.dvh_review_mrns[0] != '':
self.dvh_review_rois = self.temp_dvh_info.get_roi_names(
self.dvh_review_mrns[0]).values()
self.dvh_review_mrns.append('')
else:
self.dvh_review_rois = ['']
# Add Current row to source
self.add_endpoint_row_button = Button(label="Add Endpoint",
button_type="primary",
width=200)
self.add_endpoint_row_button.on_click(self.add_endpoint)
self.ep_row = Select(value='', options=[''], width=50, title="Row")
self.ep_options = [
"Dose (Gy)", "Dose (%)", "Volume (cc)", "Volume (%)"
]
self.select_ep_type = Select(value=self.ep_options[0],
options=self.ep_options,
width=180,
title="Output")
self.select_ep_type.on_change('value', self.select_ep_type_ticker)
self.ep_text_input = TextInput(value='',
title="Input Volume (cc):",
width=180)
self.ep_text_input.on_change('value', self.ep_text_input_ticker)
self.ep_units_in = RadioButtonGroup(labels=["cc", "%"],
active=0,
width=100)
self.ep_units_in.on_change('active', self.ep_units_in_ticker)
self.delete_ep_row_button = Button(label="Delete",
button_type="warning",
width=100)
self.delete_ep_row_button.on_click(self.delete_ep_row)
tools = "pan,wheel_zoom,box_zoom,reset,crosshair,save"
self.plot = figure(plot_width=1050,
plot_height=500,
tools=tools,
logo=None,
active_drag="box_zoom")
self.plot.min_border_left = options.MIN_BORDER
self.plot.min_border_bottom = options.MIN_BORDER
self.plot.add_tools(
HoverTool(show_arrow=False,
line_policy='next',
tooltips=[('Label', '@mrn @roi_name'), ('Dose', '$x'),
('Volume', '$y')]))
self.plot.xaxis.axis_label_text_font_size = options.PLOT_AXIS_LABEL_FONT_SIZE
self.plot.yaxis.axis_label_text_font_size = options.PLOT_AXIS_LABEL_FONT_SIZE
self.plot.xaxis.major_label_text_font_size = options.PLOT_AXIS_MAJOR_LABEL_FONT_SIZE
self.plot.yaxis.major_label_text_font_size = options.PLOT_AXIS_MAJOR_LABEL_FONT_SIZE
self.plot.yaxis.axis_label_text_baseline = "bottom"
self.plot.lod_factor = options.LOD_FACTOR # level of detail during interactive plot events
# Add statistical plots to figure
stats_median_1 = self.plot.line(
'x',
'median',
source=sources.stats_1,
line_width=options.STATS_1_MEDIAN_LINE_WIDTH,
color=options.GROUP_1_COLOR,
line_dash=options.STATS_1_MEDIAN_LINE_DASH,
alpha=options.STATS_1_MEDIAN_ALPHA)
stats_mean_1 = self.plot.line(
'x',
'mean',
source=sources.stats_1,
line_width=options.STATS_1_MEAN_LINE_WIDTH,
color=options.GROUP_1_COLOR,
line_dash=options.STATS_1_MEAN_LINE_DASH,
alpha=options.STATS_1_MEAN_ALPHA)
stats_median_2 = self.plot.line(
'x',
'median',
source=sources.stats_2,
line_width=options.STATS_2_MEDIAN_LINE_WIDTH,
color=options.GROUP_2_COLOR,
line_dash=options.STATS_2_MEDIAN_LINE_DASH,
alpha=options.STATS_2_MEDIAN_ALPHA)
stats_mean_2 = self.plot.line(
'x',
'mean',
source=sources.stats_2,
line_width=options.STATS_2_MEAN_LINE_WIDTH,
color=options.GROUP_2_COLOR,
line_dash=options.STATS_2_MEAN_LINE_DASH,
alpha=options.STATS_2_MEAN_ALPHA)
# Add all DVHs, but hide them until selected
self.plot.multi_line('x',
'y',
source=sources.dvhs,
selection_color='color',
line_width=options.DVH_LINE_WIDTH,
alpha=0,
line_dash=options.DVH_LINE_DASH,
nonselection_alpha=0,
selection_alpha=1)
# Shaded region between Q1 and Q3
iqr_1 = self.plot.patch('x_patch',
'y_patch',
source=sources.patch_1,
alpha=options.IQR_1_ALPHA,
color=options.GROUP_1_COLOR)
iqr_2 = self.plot.patch('x_patch',
'y_patch',
source=sources.patch_2,
alpha=options.IQR_2_ALPHA,
color=options.GROUP_2_COLOR)
# Set x and y axis labels
self.plot.xaxis.axis_label = "Dose (Gy)"
self.plot.yaxis.axis_label = "Normalized Volume"
# Set the legend (for stat dvhs only)
legend_stats = Legend(items=[("Median", [stats_median_1]),
("Mean", [stats_mean_1]),
("IQR", [iqr_1]),
("Median", [stats_median_2]),
("Mean", [stats_mean_2]),
("IQR", [iqr_2])],
location=(25, 0))
# Add the layout outside the plot, clicking legend item hides the line
self.plot.add_layout(legend_stats, 'right')
self.plot.legend.click_policy = "hide"
self.download_endpoints_button = Button(label="Download Endpoints",
button_type="default",
width=150)
self.download_endpoints_button.callback = CustomJS(
args=dict(source=sources.endpoint_calcs),
code=open(join(dirname(__file__), "download_endpoints.js")).read())
# Setup axis normalization radio buttons
self.radio_group_dose = RadioGroup(
labels=["Absolute Dose", "Relative Dose (Rx)"],
active=0,
width=200)
self.radio_group_dose.on_change('active', self.radio_group_ticker)
self.radio_group_volume = RadioGroup(
labels=["Absolute Volume", "Relative Volume"], active=1, width=200)
self.radio_group_volume.on_change('active', self.radio_group_ticker)
# Setup selectors for dvh review
self.select_reviewed_mrn = Select(title='MRN to review',
value='',
options=self.dvh_review_mrns,
width=300)
self.select_reviewed_mrn.on_change('value',
self.update_dvh_review_rois)
self.select_reviewed_dvh = Select(title='ROI to review',
value='',
options=[''],
width=360)
self.select_reviewed_dvh.on_change('value',
self.select_reviewed_dvh_ticker)
self.review_rx = TextInput(value='', title="Rx Dose (Gy):", width=170)
self.review_rx.on_change('value', self.review_rx_ticker)
if options.LITE_VIEW:
self.layout = column(
Div(text="<b>DVH Analytics v%s</b>" % options.VERSION),
row(self.radio_group_dose,
self.radio_group_volume), self.add_endpoint_row_button,
row(self.ep_row, Spacer(width=10), self.select_ep_type,
self.ep_text_input, Spacer(width=20),
self.ep_units_in, self.delete_ep_row_button,
Spacer(width=50), self.download_endpoints_button),
data_tables.ep)
else:
self.layout = column(
Div(text="<b>DVH Analytics v%s</b>" % options.VERSION),
row(custom_title['1']['dvhs'], Spacer(width=50),
custom_title['2']['dvhs']),
row(self.radio_group_dose, self.radio_group_volume),
row(self.select_reviewed_mrn, self.select_reviewed_dvh,
self.review_rx), self.plot,
Div(text="<b>DVHs</b>", width=1200), data_tables.dvhs,
Div(text="<hr>", width=1050),
Div(text="<b>Define Endpoints</b>",
width=1000), self.add_endpoint_row_button,
row(self.ep_row, Spacer(width=10), self.select_ep_type,
self.ep_text_input, Spacer(width=20),
self.ep_units_in, self.delete_ep_row_button,
Spacer(width=50), self.download_endpoints_button),
data_tables.ep, Div(text="<b>DVH Endpoints</b>",
width=1200), data_tables.endpoints)
)
)
for l in new_relative_source.columns.tolist()]
for old, new in zip(abs_point_sources, new_abs_point_sources):
old.data.update(new.data)
for old, new in zip(rel_point_sources, new_rel_point_sources):
old.data.update(new.data)
# Create Input controls
timegroupoptionsmapper = {0:"A", 1:"M", 2:"D"}
trendingoptionsmapper = {0:False, 1:True}
timegroupoptions = ["Year", "Month", "Day"]
top_n = Slider(title="Number of top-n items to display", value=10, start=1, end=10, step=1)
dictchooser = Select(title="dictionaries", options=dictionaries, value=dictionaries[-2])
timegroup = RadioGroup(labels=timegroupoptions, active=0)
trending_chooser = RadioGroup(labels=["absolute counts", "period-to-period change"], active=0)
initial_subset = get_subset(dictchooser.value)
abs_sources = [ColumnDataSource(dict(date=initial_subset[0].index, y=initial_subset[0][l])) for l in initial_subset[0].columns.tolist()[:top_n.value]]
rel_sources = [ColumnDataSource(dict(date=initial_subset[1].index, y=initial_subset[1][l])) for l in initial_subset[1].columns.tolist()[:top_n.value]]
abs_point_sources = [ColumnDataSource(dict(date=[initial_subset[0][l].idxmax()],
y=[initial_subset[0][l].max()],
text=[str(int(initial_subset[0][l].max()))]
)
)
for l in initial_subset[0].columns.tolist()[:top_n.value]]
rel_point_sources = [ColumnDataSource(dict(date=[initial_subset[1][l].idxmax()],
y=[initial_subset[1][l].max()],
text=[str(int(initial_subset[0][l].max()))]
)
x_axis_type="datetime",
tools=[HoverTool(),
ResetTool(),
BoxZoomTool()])
line1 = plot_trend.line(x=dates, y=counts, line_width=2)
line1_datasource = line1.data_source
plot_trend.xaxis.axis_label = "Date"
plot_trend.yaxis.axis_label = "Relevant Tweet Count"
# Widgets - Search, button
button_go = Button(label="Search Revelant Tweets", button_type="success")
button_go.on_click(bt_compare_click)
rad_text = PreText(text="Choose Word Embedding :")
radio_group = RadioGroup(labels=["WordNet Synset", "Word2Vec"],
inline=True,
active=1)
user_text = PreText(text="")
################################
src = ColumnDataSource(data=dict(Lat=[], Long=[], CreatedAt=[], tweet_text=[]))
# separate latitude and longitude points for the borders of the states.
state_xs = [us_states[code]["lons"] for code in us_states]
state_ys = [us_states[code]["lats"] for code in us_states]
hover2 = HoverTool(tooltips=[("Tweet", "@tweet_text")])
# init figure
plot_tweet = figure(
title="Origin of Tweets",
view=view1,
columns=table_columns,
width=500,
selectable=True,
scroll_to_selection=True,
css_classes=['filter_topics_table'])
filter_custom_table_source = ColumnDataSource(data={})
filter_custom_table = DataTable(source=filter_custom_table_source,
columns=table_columns,
width=500,
selectable=True,
css_classes=['filter_custom_table'])
radio_group_area = RadioGroup(labels=[
"All", "Top Topics", "Trends", "Trend Clustering", "Custom Trends",
"Topic Clustering", "Filter"
],
active=0,
inline=True,
width=400)
n_menu = [("5", "5"), ("10", "10"), ("20", "20"), ("30", "30")]
n_clusters_menu = [("20", "20"), ("50", "50"), ("100", "100"), ("300", "300"),
("500", "500")]
scores = [("0", "0"), ("0.1", "0.1"), ("0.25", "0.25"), ("0.5", "0.5"),
("1", "1")]
top_n_dropdown = Dropdown(label="Show Top 10 Phrases",
button_type="warning",
menu=n_menu,
value="10")
top_n_clusters_dropdown = Dropdown(label="Show Top 100 Clusters",
button_type="warning",
menu=n_clusters_menu,
toggle = Toggle(label="Toggle button", type="success")
toggle.on_click(toggle_handler)
menu = [("Item 1", "item_1"), ("Item 2", "item_2"), None, ("Item 3", "item_3")]
dropdown = Dropdown(label="Dropdown button", type="warning", menu=menu)
dropdown.on_click(dropdown_handler)
menu = [("Item 1", "foo"), ("Item 2", "bar"), None, ("Item 3", "baz")]
split = Dropdown(label="Split button", type="danger", menu=menu, default_action="baz")
split.on_click(split_handler)
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_group.on_click(checkbox_group_handler)
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_group.on_click(radio_group_handler)
checkbox_button_group = CheckboxButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_button_group.on_click(checkbox_button_group_handler)
radio_button_group = RadioButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_button_group.on_click(radio_button_group_handler)
vbox = VBox(children=[button, toggle, dropdown, split, checkbox_group, radio_group, checkbox_button_group, radio_button_group])
document.add(vbox)
session.store_document(document)
if __name__ == "__main__":
link = session.object_link(document.context)
menu = [("Item 1", "item_1"), ("Item 2", "item_2"), None, ("Item 3", "item_3")]
dropdown = Dropdown(label="Dropdown button", type="warning", menu=menu)
dropdown.on_click(dropdown_handler)
menu = [("Item 1", "foo"), ("Item 2", "bar"), None, ("Item 3", "baz")]
split = Dropdown(label="Split button",
type="danger",
menu=menu,
default_value="baz")
split.on_click(split_handler)
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"],
active=[0, 1])
checkbox_group.on_click(checkbox_group_handler)
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_group.on_click(radio_group_handler)
checkbox_button_group = CheckboxButtonGroup(
labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_button_group.on_click(checkbox_button_group_handler)
radio_button_group = RadioButtonGroup(
labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_button_group.on_click(radio_button_group_handler)
vbox = VBox(children=[
button, toggle, dropdown, split, checkbox_group, radio_group,
checkbox_button_group, radio_button_group
])
import pandas as pd
import matplotlib as plt
import numpy as np
from datetime import datetime, timedelta as dt
from pathlib import Path
from bokeh.plotting import figure, output_file, show, curdoc
from bokeh.layouts import row, widgetbox, gridplot
from bokeh.models import HoverTool
from bokeh.models.widgets import Select, RangeSlider, RadioGroup
my_data = pd.DataFrame() # initialize empty data frame
my_folder = pd.DataFrame()
radio_group = RadioGroup(
labels=["Demo Sensor 1", "Demo Sensor 2", "Eng Sensor 1", "Eng Sensor 2"],
active=0)
folder_name = ['Demo1', 'Demo2', 'Eng1', 'Eng2']
for name in folder_name:
print('Current Folder: ', name)
my_input = name
pathlist = Path(my_input).glob('**/*.csv') # gather all files in folder
# iterate through the provided folder and load all files to my_data
for path in pathlist:
path_in_str = str(path)
my_file = pd.read_csv(path,
parse_dates=[
'Timestamp for sample frequency every 15 min'
]) # read in data from chosen folder
my_file.set_index(keys='Timestamp for sample frequency every 15 min',
def initialize(self, default_value, label, inline):
self.radiobutton = RadioGroup(active=default_value,
labels=label,
inline=inline)
self.widget_lst.append(self.radiobutton)
def release_tab(src_csv):
# Make Dataset for all States per Year
def make_dataset(state):
new_src = src_csv.query('STATEID ==' + state + 'and YEAR >= 1983')
return ColumnDataSource(new_src)
# draw the plot
def make_plot(src):
print('draw plot')
m = figure(plot_width=800,
plot_height=600,
title="National Prisoner Release Statistics",
x_axis_label='Year',
y_axis_label='Number of Prisoners')
# Male
# RLUNEXPM: UNCONDITIONAL RELEASE EXPIRATIONS OF SENTENCE, MALE
rm = m.circle(src.data['YEAR'],
src.data['RLUNEXPM'],
size=7,
color='navy',
alpha=0.5,
hover_fill_alpha=1.0,
hover_fill_color='navy')
# RLCOSUPM: SUPERVISED MANDATORY RELEASE, MALE
sm = m.circle(src.data['YEAR'],
src.data['RLCOSUPM'],
size=7,
color='red',
alpha=0.5,
hover_fill_alpha=1.0,
hover_fill_color='red')
# RLCODPM: DISCRETIONARY PAROLE, MALE
pm = m.circle(src.data['YEAR'],
src.data['RLCODPM'],
size=7,
color='green',
alpha=0.5,
hover_fill_alpha=1.0,
hover_fill_color='green')
# Female
# RLUNEXPM: UNCONDITIONAL RELEASE EXPIRATIONS OF SENTENCE, FEMALE
rf = m.square(src.data['YEAR'],
src.data['RLUNEXPF'],
size=7,
color='navy',
alpha=0.5,
hover_fill_alpha=1.0,
hover_fill_color='navy')
# RLCOSUPM: SUPERVISED MANDATORY RELEASE, FEMALE
sf = m.square(src.data['YEAR'],
src.data['RLCOSUPF'],
size=7,
color='red',
alpha=0.5,
hover_fill_alpha=1.0,
hover_fill_color='red')
# RLCODPM: DISCRETIONARY PAROLE, FEMALE
pf = m.square(src.data['YEAR'],
src.data['RLCODPF'],
size=7,
color='green',
alpha=0.5,
hover_fill_alpha=1.0,
hover_fill_color='green')
# adding tooltips
h = HoverTool(tooltips=[('Year', '@x'), ('# of Prisoners', '@y')])
m.add_tools(h)
# Legend
legendm = Legend(items=[(
'Male, Unconditional Release',
[rm]), ('Male, Supervised Release',
[sm]), ('Male, Parole',
[pm]), ('Female, Unconditional Release',
[rf]), ('Female, Supervised Release',
[sf]), ('Female, Parole', [pf])])
m.add_layout(legendm, 'right')
m.legend.click_policy = 'hide'
return m
# update function
def update(attr, old, new):
# get list of variables to update
state = state_select.active
print(str(state + 1))
# update the dataset
new_src = make_dataset(str(state + 1))
src.data = make_dataset(str(state + 1))
# Widgets
state_select = RadioGroup(labels=['Alabama', 'Alaska'], active=0)
state_select.on_change('active', update)
src = make_dataset('1')
p = make_plot(src)
# add the controls
controls = WidgetBox(state_select)
# create a layout
layout = row(controls, p)
# add a tab
tab = Panel(child=layout, title='Prison Releases')
print('release')
return tab
def __init__(self, protocol):
self.protocol = protocol # link to Protocol tab so we can info in the protocol tab
self.source = ColumnDataSource(data=dict(mrn=[]))
self.source.selected.on_change('indices', self.source_listener)
# self.source.on_change('data', self.update_toxicity_grades_from_table)
self.data = [
] # This will keep all data from query, self.source may display a subset
self.clear_source_selection_button = Button(label='Clear Selection',
button_type='primary',
width=150)
self.clear_source_selection_button.on_click(
self.clear_source_selection)
self.protocol_select = Select(value='All Data',
options=['All Data', 'None'],
title='Protocol:')
self.protocol_select.on_change('value', self.protocol_ticker)
self.update_protocol_options()
self.display_by = RadioGroup(labels=[
'Display by Institutional ROI', 'Display by Physician ROI'
],
active=0)
self.display_by.on_change('active', self.display_by_ticker)
self.physician = Select(value='',
options=[''],
title='Physician:',
width=150)
self.physician.on_change('value', self.physician_ticker)
self.roi = Select(value='', options=[''], title='Institutional ROI:')
self.roi.on_change('value', self.roi_ticker)
self.mrn_input_count = 0
self.toxicity_grade_input_count = 0
self.mrn_input = TextAreaInput(value='',
title="MRN Input:",
rows=30,
cols=25,
max_length=2000)
self.mrn_input.on_change('value', self.mrn_input_ticker)
self.toxicity_grade_input = TextAreaInput(
value='',
title="Toxicity Grade Input:",
rows=30,
cols=5,
max_length=500)
self.toxicity_grade_input.on_change('value',
self.toxicity_input_ticker)
self.update_button = Button(label='Update',
button_type='primary',
width=425)
self.update_button.on_click(self.update_toxicity_grades)
self.update_update_button_status()
self.columns = ['mrn', 'roi_name', 'toxicity_grade']
relative_widths = [1, 1, 1, 1]
column_widths = [int(250. * rw) for rw in relative_widths]
table_columns = [
TableColumn(field=c, title=c, width=column_widths[i])
for i, c in enumerate(self.columns)
]
table_columns.insert(
1,
TableColumn(field='protocol',
title='protocol',
width=column_widths[0]))
table_columns.insert(
1,
TableColumn(field='physician',
title='physician',
width=column_widths[0] / 3))
self.table = DataTable(source=self.source,
columns=table_columns,
width=800,
editable=True,
height=600)
self.update_physicians()
note = Div(
text=
'<b>NOTE</b>: MRNs input below that are not in the table to the left will be '
'ignored on update.')
self.layout = column(
self.protocol_select, row(self.display_by, self.physician,
self.roi),
row(
self.table, Spacer(width=50),
column(note, self.update_button,
self.clear_source_selection_button,
row(self.mrn_input, self.toxicity_grade_input))))
def html_postages(coord=None, idx=None, veto=None, info=None, layer_list=None, BoxSize=40):
plots = {}
sources = []
layers = []
RA, DEC = coord[0], coord[1]
scale_unit='pixscale'
scale=0.262
boxsize = BoxSize #2*m*radius*3600
radius = BoxSize/(2 * 3600)
size = int(round(boxsize/scale))
figsize = int(128)
#print('BoxSize', boxsize)
#print('Size', size)
idx_list = idx #random.sample(list(idx), rows*cols)
if info is None:
info = {'RA':RA, 'DEC':DEC}
if veto is None:
veto = {'all':np.ones_like(RA, dtype=bool)}
if layer_list is None:
layer_list = ['dr9f-south', 'dr9f-south-model', 'dr9f-south-resid', 'dr9g-south', 'dr9g-south-model', 'dr9g-south-resid',
'dr9f-north', 'dr9f-north-model', 'dr9f-north-resid', 'dr9g-north', 'dr9g-north-model', 'dr9g-north-resid']
for idx in idx_list:
RAidx = RA[idx]
DECidx = DEC[idx]
ramin, ramax = RAidx-radius, RAidx+radius
decmin, decmax = DECidx-radius, DECidx+radius
dra = (ramax - ramin)/40
ddec = (decmax - decmin)/40
mask = (RA > ramin + dra) & (RA < ramax - dra) & (DEC > decmin + ddec) & (DEC < decmax - ddec)
TOOLTIPS = []
for key in info.keys():
TOOLTIPS.append((key, '@'+key))
p = figure(plot_width=2*figsize, plot_height=2*figsize, tooltips=TOOLTIPS, tools="tap, save, zoom_in, zoom_out, crosshair")
p.axis.visible = False
p.toolbar.logo = None
p.toolbar_location = None
#p.min_border = 0
layers2 = []
for layer in layer_list:
source='https://www.legacysurvey.org/viewer-dev/jpeg-cutout/?ra=%.12f&dec=%.12f&%s=%g&layer=%s&size=%g' % (RAidx, DECidx, scale_unit, scale, layer, size)
url='https://www.legacysurvey.org/viewer-dev?ra=%.12f&dec=%.12f&layer=%s&zoom=15' %(RAidx, DECidx, layer)
imfig_source = ColumnDataSource(data=dict(url=[source], txt=[source]))
image1 = ImageURL(url="url", x=0, y=1, w=size, h=size, anchor='bottom_left')
img_source = p.add_glyph(imfig_source, image1)
layers2.append(img_source)
taptool = p.select(type=TapTool)
taptool.callback = OpenURL(url=url)
colors = ['green', 'red', 'blue', 'cyan', 'yellow']
circle_i = []
for color, key, val in zip(colors, veto.keys(), veto.values()):
ravpix, decvpix = coordtopix(center=[RAidx, DECidx], coord=[RA[(mask) & (val)], DEC[(mask) & (val)]], size=size, scale=scale)
data = {}
data['x'] = ravpix
data['y'] = decvpix
for info_key, info_val in zip(info.keys(), info.values()):
if isinstance(info_val[0], (bytes, bytearray)):
data[info_key] = np.array(info_val)[(mask) & (val)].astype('U13')
else:
data[info_key] = np.array(info_val)[(mask) & (val)]
sourceCirc = ColumnDataSource(data=data)
circle = p.circle('x', 'y', source=sourceCirc, size=15, fill_color=None, line_color=color, line_width=3)
circle_i.append(circle)
lineh = Span(location=size/2, dimension='height', line_color='white', line_dash='solid', line_width=1)
linew = Span(location=size/2, dimension='width', line_color='white', line_dash='solid', line_width=1)
p.add_layout(lineh)
p.add_layout(linew)
p.background_fill_color = "black"
#p.outline_line_width = 15
#p.outline_line_alpha = 0.7
p.xgrid.grid_line_color = None
p.ygrid.grid_line_color = None
plots[str(idx)] = p
sources.append(circle_i)
layers.append(layers2)
checkbox = CheckboxGroup(labels=list(veto.keys()), active=list(np.arange(len(veto))))
iterable = [elem for part in [[('_'.join(['line',str(figid),str(lineid)]),line) for lineid,line in enumerate(elem)] for figid,elem in enumerate(sources)] for elem in part]
checkbox_code = ''.join([elem[0]+'.visible=checkbox.active.includes('+elem[0].split('_')[-1]+');' for elem in iterable])
callback = CustomJS(args={key:value for key,value in iterable+[('checkbox',checkbox)]}, code=checkbox_code)
# print('===== plots ======')
# print(checkbox_code)
# print('====')
# print({key:value for key,value in iterable+[('checkbox',checkbox)]})
checkbox.js_on_click(callback)
#script, div = components(plots)
#print(div)
radio = RadioGroup(labels=layer_list, active=len(layer_list)-1)
iterable2 = [elem for part in [[('_'.join(['line',str(figid),str(lineid)]),line) for lineid,line in enumerate(elem)] for figid,elem in enumerate(layers)] for elem in part]
#
N = len(layer_list)
text = []
for elem in iterable2[::N]:
for n in range(N):
text.append('%s%s.visible=false;' %(elem[0][:-1], str(n)))
for n in range(N):
if n == 0: text.append('if (cb_obj.active == 0) {%s%s.visible = true;}' %(elem[0][:-1], str(0)))
if n != 0: text.append('else if (cb_obj.active == %s) {%s%s.visible = true;}' %(str(n), elem[0][:-1], str(n)))
radiogroup_code = ''.join(text)
callback2 = CustomJS(args={key:value for key,value in iterable2+[('radio',radio)]}, code=radiogroup_code)
radio.js_on_change('active', callback2)
# for key,val in zip(plots.keys(), plots.values()):
# print(key, '\t', val)
#script, div = components(plots)
#controls = WidgetBox(radio, checkbox)
#plots['controls'] = components(radio)
#script_2, div_2 = components(controls)
#print('===== plots ======')
plots['checkbox'] = checkbox
plots['radio'] = radio
return components(plots)
source=runs_cds,
line_width=4,
line_color="blue")
fig.line(x='Match_ID',
y='shots',
source=shots_cds,
line_width=4,
line_color="Orange")
fig.xaxis.major_label_orientation = "vertical"
slider = Slider(start=min(bats_man_data.Year_bats),
end=max(bats_man_data.Year_bats),
step=1,
value=min(bats_man_data.Year_bats),
title='Year of Play')
radiogroup_batsman = RadioGroup(labels=bats_man_name_list, active=0)
run_type = RadioButtonGroup(labels=['Number of 4s', 'Number of 6s'], active=0)
radiogroup_oppo = RadioGroup(labels=opposition_list, active=0)
def update(attr, old, new):
yr1 = slider.value
print('Slider Value is : ', yr1)
selected_batsman = bats_man_name_list[radiogroup_batsman.active]
print('Selected batsman is : ', selected_batsman)
selected_oppo = opposition_list[radiogroup_oppo.active]
print('Selected Opposition Team is : ', selected_oppo)
button_value = run_type.active
class Toxicity:
def __init__(self, protocol):
self.protocol = protocol # link to Protocol tab so we can info in the protocol tab
self.source = ColumnDataSource(data=dict(mrn=[]))
self.source.selected.on_change('indices', self.source_listener)
# self.source.on_change('data', self.update_toxicity_grades_from_table)
self.data = [
] # This will keep all data from query, self.source may display a subset
self.clear_source_selection_button = Button(label='Clear Selection',
button_type='primary',
width=150)
self.clear_source_selection_button.on_click(
self.clear_source_selection)
self.protocol_select = Select(value='All Data',
options=['All Data', 'None'],
title='Protocol:')
self.protocol_select.on_change('value', self.protocol_ticker)
self.update_protocol_options()
self.display_by = RadioGroup(labels=[
'Display by Institutional ROI', 'Display by Physician ROI'
],
active=0)
self.display_by.on_change('active', self.display_by_ticker)
self.physician = Select(value='',
options=[''],
title='Physician:',
width=150)
self.physician.on_change('value', self.physician_ticker)
self.roi = Select(value='', options=[''], title='Institutional ROI:')
self.roi.on_change('value', self.roi_ticker)
self.mrn_input_count = 0
self.toxicity_grade_input_count = 0
self.mrn_input = TextAreaInput(value='',
title="MRN Input:",
rows=30,
cols=25,
max_length=2000)
self.mrn_input.on_change('value', self.mrn_input_ticker)
self.toxicity_grade_input = TextAreaInput(
value='',
title="Toxicity Grade Input:",
rows=30,
cols=5,
max_length=500)
self.toxicity_grade_input.on_change('value',
self.toxicity_input_ticker)
self.update_button = Button(label='Update',
button_type='primary',
width=425)
self.update_button.on_click(self.update_toxicity_grades)
self.update_update_button_status()
self.columns = ['mrn', 'roi_name', 'toxicity_grade']
relative_widths = [1, 1, 1, 1]
column_widths = [int(250. * rw) for rw in relative_widths]
table_columns = [
TableColumn(field=c, title=c, width=column_widths[i])
for i, c in enumerate(self.columns)
]
table_columns.insert(
1,
TableColumn(field='protocol',
title='protocol',
width=column_widths[0]))
table_columns.insert(
1,
TableColumn(field='physician',
title='physician',
width=column_widths[0] / 3))
self.table = DataTable(source=self.source,
columns=table_columns,
width=800,
editable=True,
height=600)
self.update_physicians()
note = Div(
text=
'<b>NOTE</b>: MRNs input below that are not in the table to the left will be '
'ignored on update.')
self.layout = column(
self.protocol_select, row(self.display_by, self.physician,
self.roi),
row(
self.table, Spacer(width=50),
column(note, self.update_button,
self.clear_source_selection_button,
row(self.mrn_input, self.toxicity_grade_input))))
def source_listener(self, attr, old, new):
new.sort()
mrns = [self.source.data['mrn'][x] for x in new]
self.mrn_input.value = '\n'.join(mrns)
toxicities = [str(self.source.data['toxicity_grade'][x]) for x in new]
toxicities = [['NULL', t][t.isdigit()] for t in toxicities]
self.toxicity_grade_input.value = '\n'.join(toxicities)
def update_source(self):
cnx = DVH_SQL()
if self.display_by.active == 1: # Display by Physician ROI
uids_physician = cnx.get_unique_values(
'Plans', 'study_instance_uid',
"physician = '%s'" % self.physician.value)
condition = ["physician_roi = '%s'" % self.roi.value]
if uids_physician:
condition.append("study_instance_uid in ('%s')" %
"', '".join(uids_physician))
else: # Display by Institutional ROI
condition = ["institutional_roi = '%s'" % self.roi.value]
if self.physician.value != 'Any':
uids_physician = cnx.get_unique_values(
'Plans', 'study_instance_uid',
"physician = '%s'" % self.physician.value)
if uids_physician:
condition.append("study_instance_uid in ('%s')" %
"', '".join(uids_physician))
condition = ' AND '.join(condition)
self.data = cnx.query('DVHs',
', '.join(self.columns + ['study_instance_uid']),
condition,
bokeh_cds=True,
order_by='mrn')
cnx.close()
for col in ['protocol', 'physician']:
self.data[col] = self.get_sql_values_based_on_source(
'Plans', col, return_list=True)
self.clean_toxicity_grades()
if self.protocol_select.value == 'All Data':
self.source.data = self.data
else:
self.source.data = self.get_data_filtered_by_protocol()
def get_data_filtered_by_protocol(self):
selected_protocol = self.protocol_select.value
if selected_protocol == 'No Protocol':
selected_protocol = ''
protocols = self.get_sql_values_based_on_source('Plans', 'protocol')
if not protocols:
return self.data
new_data = {key: [] for key in list(self.data)}
for i in range(len(self.data['mrn'])):
if (selected_protocol == 'Any Protocol' and protocols[self.data['study_instance_uid'][i]]) or \
(not selected_protocol and not protocols[self.data['study_instance_uid'][i]]) or\
(selected_protocol and selected_protocol in protocols[self.data['study_instance_uid'][i]]):
for key in list(self.data):
new_data[key].append(self.data[key][i])
return new_data
def clean_toxicity_grades(self):
# Replace any toxicity grade values of -1 to None. Stored in SQL as integer, but integer columns can't have NULL
for i, value in enumerate(self.data['toxicity_grade']):
if value == -1:
self.data['toxicity_grade'][i] = None
def update_protocol_options(self):
options = ['All Data', 'Any Protocol', 'No Protocol'
] + self.get_protocols()
self.protocol_select.options = options
if self.protocol_select.value not in options:
self.protocol_select.value = options[0]
def get_sql_values_based_on_source(self,
sql_table,
sql_column,
return_list=False):
cnx = DVH_SQL()
uids = self.data['study_instance_uid']
data = cnx.query(sql_table, 'study_instance_uid, %s' % sql_column,
"study_instance_uid in ('%s')" % "', '".join(uids))
if data:
return_data = {line[0]: line[1] for line in data}
if return_list:
return [
return_data[uid] for uid in self.data['study_instance_uid']
]
else:
return return_data
return []
def update_physicians(self):
physicians = DVH_SQL().get_unique_values('Plans', 'physician')
if self.display_by.active == 0:
physicians.insert(0, 'Any')
self.physician.options = physicians
if self.physician.value not in physicians:
self.physician.value = physicians[0]
def protocol_ticker(self, attr, old, new):
self.update_source()
def physician_ticker(self, attr, old, new):
self.update_source()
self.update_rois()
def roi_ticker(self, attr, old, new):
self.update_source()
def update_rois(self):
cnx = DVH_SQL()
if self.display_by.active == 1: # Display by Physician ROI
uids_physician = cnx.get_unique_values(
'Plans', 'study_instance_uid',
"physician = '%s'" % self.physician.value)
condition = "study_instance_uid in ('%s')" % "', '".join(
uids_physician)
rois = cnx.get_unique_values('DVHs', 'physician_roi', condition)
else: # Display by Institutional ROI
rois = cnx.get_unique_values('DVHs', 'institutional_roi')
cnx.close()
self.roi.options = rois
if self.roi.value not in rois:
self.roi.value = rois[0]
def display_by_ticker(self, attr, old, new):
self.roi.title = ['Institutional ROI:', 'Physician ROI:'][new]
self.update_physicians()
self.update_rois()
@staticmethod
def get_protocols(condition=None):
return DVH_SQL().get_unique_values('Plans',
'protocol',
condition,
ignore_null=True)
def update_toxicity_grades(self):
if self.update_button.label == 'Update':
mrns = parse_text_area_input_to_list(self.mrn_input.value,
delimeter=None)
toxicities = parse_text_area_input_to_list(
self.toxicity_grade_input.value, delimeter=None)
cnx = DVH_SQL()
for i, mrn in enumerate(mrns):
if mrn in self.data['mrn']:
index = self.data['mrn'].index(mrn)
uid = self.data['study_instance_uid'][index]
roi_name = self.data['roi_name'][index]
cnx.update(
'DVHs', 'toxicity_grade', toxicities[i],
"study_instance_uid = '%s' and roi_name = '%s'" %
(uid, roi_name))
update_plan_toxicity_grades(cnx, uid)
cnx.close()
self.update_source()
self.clear_source_selection()
self.toxicity_grade_input.value = ''
self.protocol.update_source(
) # update the table in the Protocol tab since it has toxicity grades in it
def mrn_input_ticker(self, attr, old, new):
count = len(parse_text_area_input_to_list(new))
self.mrn_input.title = "MRN Input%s:" % (
['', ' (count = %d)' % count][count > 0])
self.mrn_input_count = count
self.update_update_button_status()
def toxicity_input_ticker(self, attr, old, new):
toxicity_grades = parse_text_area_input_to_list(new, delimeter=None)
count = len(toxicity_grades)
self.toxicity_grade_input.title = "Toxicity Grade Input%s:" % (
['', ' (count = %d)' % count][count > 0])
self.toxicity_grade_input_count = count
self.update_update_button_status()
self.validate_toxicity_grade_input(toxicity_grades)
def update_update_button_status(self):
if not self.mrn_input_count and not self.toxicity_grade_input_count:
self.update_button.label = "Need data to update"
self.update_button.button_type = 'default'
elif self.mrn_input_count != self.toxicity_grade_input_count:
self.update_button.label = 'Input data row count mismatch'
self.update_button.button_type = 'default'
else:
self.update_button.label = 'Update'
self.update_button.button_type = 'primary'
def validate_toxicity_grade_input(self, toxicity_grades):
validated_data = [['NULL', grade][grade.isdigit() and grade > -1]
for grade in toxicity_grades] # remove non-int > -1
for i, x in enumerate(validated_data):
if x.isdigit():
validated_data[i] = str(
int(x)) # clean, convert to string (removes leading zeros)
self.toxicity_grade_input.value = '\n'.join(validated_data)
# if 'NULL' in validated_data:
# label = self.update_button.label
# button_type = self.update_button.button_type
# self.update_button.label = 'Invalid grade detected. Setting to None.'
# self.update_button.button_type = 'danger'
# time.sleep(1)
# self.update_button.label = label
# self.update_button.button_type = button_type
def clear_source_selection(self):
self.source.selected.indices = []
menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"),
("Item 3", "item_3_value")]
dropdown = Dropdown(label="Dropdown button",
button_type="warning",
menu=menu,
default_value="item_1_value")
split_menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"), None,
("Item 3", "item_3_value")]
split = Dropdown(label="Split button", button_type="danger", menu=split_menu)
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"],
active=[0, 1])
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
checkbox_button_group = CheckboxButtonGroup(
labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
radio_button_group = RadioButtonGroup(
labels=["Option 1", "Option 2", "Option 3"], active=0)
text_input = TextInput(placeholder="Enter value ...")
autocomplete_input = AutocompleteInput()
select = Select(options=["Option 1", "Option 2", "Option 3"])
multi_select = MultiSelect(options=["Option %d" % (i + 1) for i in range(16)],
size=6)
dropdown_split.js_on_click(
CustomJS(code="console.log('dropdown(split): click ' + this.toString())"))
dropdown_split.js_on_event(
"menu_item_click",
CustomJS(
code="console.log('dropdown(split): ' + this.item, this.toString())"))
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"],
active=[0, 1])
checkbox_group.js_on_click(
CustomJS(
code=
"console.log('checkbox_group: active=' + this.active, this.toString())"
))
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_group.js_on_click(
CustomJS(
code=
"console.log('radio_group: active=' + this.active, this.toString())"))
checkbox_button_group = CheckboxButtonGroup(
labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_button_group.js_on_click(
CustomJS(
code=
"console.log('checkbox_button_group: active=' + this.active, this.toString())"
))
radio_button_group = RadioButtonGroup(
labels=["Option 1", "Option 2", "Option 3"], active=0)
class Interface:
def __init__(self):
self.grepolis = Grepolis()
imgRessource = []
for v in ["Bois", "Pierre", "Argent"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgRessource.append(Image(d))
colRess = column(*[img.figure for img in imgRessource])
self.inputRess = [
TextInput(value="", title=el + " :", width=150)
for el in ["Bois", "Pierre", "Argent"]
]
colinputRess = column(*self.inputRess)
imgDieu = []
for v in ["Athena", "Artemis", "Hades", "Zeus", "Poseidon", "Hera"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgDieu.append(Image(d, multiplier=3))
rowDieu = [HFill(5)]
for img in imgDieu:
rowDieu.append(HFill(5))
rowDieu.append(img.figure)
rowDieu = row(*rowDieu)
imgAtt = []
for v in ["Att_hack", "Att_sharp", "Att_distance"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgAtt.append(Image(d))
colAtt = column(*[img.figure for img in imgAtt])
self.inputAtt = [
TextInput(value="", title=el + " :", width=150)
for el in ["Contondantes", "Blanches", "De Jet"]
]
colinputAtt = column(*self.inputAtt)
imgDef = []
for v in ["Def_hack", "Def_sharp", "Def_distance"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgDef.append(Image(d))
colDef = column(*[img.figure for img in imgDef])
self.inputDef = [
TextInput(value="", title=el + " :", width=150)
for el in ["Contondantes", "Blanches", "De Jet"]
]
rowinputDef = column(*self.inputDef)
imgOther = []
for v in ["Vitesse", "Butin", "Faveur"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgOther.append(Image(d))
colOther = column(*[img.figure for img in imgOther])
self.inputFavBut = [
TextInput(value="", title=el + " :", width=150)
for el in ["Vitesse", "Butin", "Faveur"]
]
self.inputOther = column(*self.inputFavBut)
self.imgUnit = []
for v in [
"Combattant", "Frondeur", "Archer", "Hoplite", "Cavalier",
"Char", "Envoye", "Centaure", "Pegase"
]:
r = "static/" + v + ".jpg"
d = dict(url=[r])
self.imgUnit.append(Image(d, multiplier=2))
rowUnit = row(HFill(10), *[img.figure for img in self.imgUnit])
imgDefAtt = []
for v in ["Pop", "Attaque", "Defense"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgDefAtt.append(Image(d))
rowInputUnit = [HFill(10)]
self.unitInput = [
TextInput(value="", title=el + " :", width=80) for el in [
"Combattant", "Frondeur", "Archer", "Hoplite", "Cavalier",
"Char", "Envoye", "Centaure", "Pegase"
]
]
for inp in self.unitInput:
rowInputUnit.append(inp)
rowInputUnit.append(HFill(30))
rowInputUnit = row(HFill(10), *rowInputUnit)
self.selectUnit = CheckboxButtonGroup(labels=[
"Combattant", "Frondeur", "Archer", "Hoplite", "Cavalier", "Char",
"Envoye", "Centaure", "Pegase"
],
active=[i for i in range(9)])
self.selectUnit.on_change("active", self.updateSelectUnit)
self.Dieu = RadioButtonGroup(
labels=["Athena", "Artemis", "Hades", "Zeus", "Poseidon", "Hera"],
active=0,
width=1110)
self.Dieu.on_change('active', self.updateUnit)
self.attdef = RadioButtonGroup(labels=["Attaque", "Defense"],
active=0,
width=200)
self.attdef.on_change('active', self.switchAttDef)
self.typeAtt = RadioGroup(
labels=["Armes Contondantes", "Armes Blanches", "Armes de Jet"],
active=0,
width=150)
self.typeAtt.on_change('active', self.process2)
self.imgFaveur = Image(dict(url=["static/" + "Faveur" + ".png"]))
self.launch = Button(label="Lancer")
self.launch.on_click(self.process)
self.inputPop = TextInput(value="1500",
title="Population : ",
width=120)
self.inputPop.on_change("value", self.process2)
self.inputFav = TextInput(value="1500",
title="Faveur Max : ",
width=120)
self.inputFav.on_change("value", self.process2)
rowPop = row(HFill(10), self.typeAtt, imgDefAtt[1].figure, self.attdef,
HFill(30), imgDefAtt[2].figure, HFill(50),
imgDefAtt[0].figure, self.inputPop, HFill(50),
self.imgFaveur.figure, self.inputFav, HFill(50))
self.doc = column(
rowDieu, self.Dieu, VFill(20), rowPop, VFill(20), self.selectUnit,
rowUnit, rowInputUnit, VFill(20),
row(HFill(50), colRess, colinputRess,
HFill(40), colAtt, colinputAtt, HFill(40), colDef, rowinputDef,
HFill(40), colOther, self.inputOther))
#curdoc().add_root(column(rowDieu,self.Dieu,VFill(20),rowPop,VFill(20),self.selectUnit,rowUnit,rowInputUnit,VFill(20),row(HFill(50),colRess,colinputRess,HFill(40),colAtt,colinputAtt,HFill(40),colDef,rowinputDef,HFill(40),colOther,self.inputOther)))
self.process(None)
#curdoc().title = "Grepolis"
def updateUnit(self, attrname, old, new):
L = ["Athena", "Artemis", "Hades", "Zeus", "Poseidon", "Hera"]
print(self.selectUnit.active)
if L[new] == "Poseidon":
self.imgUnit[-1].figure.visible = False
self.unitInput[-1].visible = False
self.selectUnit.active = [1, 2, 3, 4, 5, 6, 7]
else:
self.imgUnit[-1].figure.visible = True
self.unitInput[-1].visible = True
self.selectUnit.active = [1, 2, 3, 4, 5, 6, 7, 8]
self.grepolis.setDieu(L[new])
unit = Add(L[new])
self.selectUnit.labels = [
"Combattant", "Frondeur", "Archer", "Hoplite", "Cavalier", "Char",
"Envoye"
] + unit
for i, v in enumerate(unit):
r = "static/" + v + ".jpg"
d = dict(url=[r])
self.imgUnit[-2 + i].update(d)
self.unitInput[-2 + i].title = v + " : "
self.process(None)
def process2(self, attrname, old, new):
self.process(None)
def switchAttDef(self, attrname, old, new):
if self.attdef.active == 0:
self.typeAtt.disabled = False
else:
self.typeAtt.disabled = True
self.process(None)
def updateSelectUnit(self, attrname, old, new):
N = len(self.selectUnit.labels)
active = self.selectUnit.active
zeros = [i for i in range(N) if i not in active]
for inp in [self.unitInput[i] for i in zeros]:
inp.value = str(0)
self.process(None)
def process(self, attrname):
try:
pop = int(self.inputPop.value)
favmax = int(self.inputFav.value)
active = self.selectUnit.active
type = self.typeAtt.active
if self.attdef.active == 0:
X, Att, Def, Prix, Speed, Pops, butin = self.grepolis.optimAttaque(
pop=pop, favmax=favmax, active=active, type=type)
else:
X, Att, Def, Prix, Speed, Pops, butin = self.grepolis.optimDefense(
pop=pop, favmax=favmax, active=active)
for v, inp in zip(X, [self.unitInput[i] for i in active]):
inp.value = str(v)
for v, inp in zip(Att, self.inputAtt):
inp.value = str(v) + " /u - " + str(int(v * pop))
for v, inp in zip(Def, self.inputDef):
inp.value = str(v) + " /u - " + str(int(v * pop))
for v, inp in zip(Prix, self.inputRess):
inp.value = str(v) + " /u - " + str(int(v * pop))
for i, (v, inp) in enumerate(
zip([Speed, butin, Prix[3]], self.inputFavBut)):
#add = ""
#if i > 0:
# add = + " /u - " +str(int(v*pop))
#print(v,add)
inp.value = str(v) + " /u - " + str(int(
v * pop)) if i != 0 else str(v)
except:
pass
button_type="success",
width=300)
solve_system_button.on_click(solve_system)
##################################### (2) #####################################
mass_input = TextInput(value="10000", title="Mass [kg]", width=300)
##################################### (3) #####################################
stiffness_input = TextInput(value="10000000",
title="Stiffness [N*m"
u"\u00B2]",
width=300)
##################################### (4) #####################################
Erdbebenzonen_text = Div(text="""<b>Earthquake Zones</b>""")
Erdbebenzonen_choices = RadioGroup(labels=["Zone 1", "Zone 2", "Zone 3"],
active=0)
Bedeutungsbeiwert_text = Div(text="""<b>Importance Coefficient</b>""")
Bedeutungsbeiwert_choices = RadioGroup(labels=[
"Residential Building", "School or Residential Complexes", "Hospital"
],
active=0)
untergrundParamter_text = Div(text="""<b>Underground Parameter</b>""")
untergrundParamter_choices = RadioGroup(
labels=["A-R", "B-R", "C-R", "B-T", "C-T", "C-S"], active=0)
def calculate_ERS():
# re-assign "Erdbebenzonen" value
a = 0
value1 = Erdbebenzonen_choices.active
if value1 == 0:
fig.xaxis.axis_label = 'Year'
fig.rect(x='year',
y='reform',
source=sources['static'],
angle=pi/2,
width=5,
height=1,
color=DARK_GRAY)
# create components --------------
title_div = Div(text='Revenue Impact of a 4% Surtax on Taxpayers with Adjusted Gross Income over $5 Million', height=30)
radio_group_text = Div(text="Include Additional Capital Gains Behavior.")
radio_group = RadioGroup(labels=["Without", "With"], active=0)
sources['radio_group'] = radio_group
elasticity_text = Div(text="Elasticity of Taxable Income")
elasticity_option = RadioButtonGroup(labels=sources['capital_gains_no'].data['labels'], active=0)
sources['elasticity_option'] = elasticity_option
# create callbacks ---------------
radio_group.callback = CustomJS(args=sources, code="""
var capitalGainsType = radio_group.active === 0 ? capital_gains_no : capital_gains_yes;
elasticity_option.set('labels', capitalGainsType.data.labels);
while (elasticity_option.active > capitalGainsType.data.source_ids.length - 1) {
elasticity_option.active = elasticity_option.active - 1;
}
