def test_gaussian_pointytop(self, pd):
bins = buh.hexbin(x, y, 2)
assert list(bins.q) == [0, 0, 1, 1, 1, 2, 2]
assert list(bins.r) == [-1, 0, -2, -1, 0, -2, -1]
assert list(bins.counts) == [9, 54, 1, 313, 98, 3, 22]
assert bins.equals(buh.hexbin(x, y, 2, "pointytop"))
def test_gaussian_pointytop(self):
bins = buh.hexbin(x, y, 2)
assert list(bins.q) == [0,0,1,1,1,2,2]
assert list(bins.r) == [-1,0,-2,-1,0,-2,-1]
assert list(bins.counts) == [9,54,1,313,98,3,22]
assert bins.equals(buh.hexbin(x, y, 2, "pointytop"))
def update():
"""
update the scatter plot
"""
df = select_subset()
bins = hexbin(df.x, df.y, 0.08)
source.data = dict(x=bins["q"], y=bins["r"], counts=bins["counts"])
def hexBinPlot():
p = figure(
title="Hex Bin Plot",
sizing_mode="fixed",
plot_width=400,
plot_height=400,
tools="wheel_zoom,reset",
match_aspect=True,
background_fill_color="#440154",
)
n = 50000
x = np.random.standard_normal(n)
y = np.random.standard_normal(n)
bins = hexbin(x, y, 0.1)
p.grid.visible = False
p.hex_tile(
q="q",
r="r",
size=0.1,
line_color=None,
source=bins,
fill_color=linear_cmap("counts", "Viridis256", 0, max(bins.counts)),
)
return p
def hexmap(x,
y,
name=None,
log=False,
match_aspect=True,
kernel_size=0.1,
xlim=(None, None),
ylim=(None, None),
**kwargs):
"""Create a heatmap from two columns.
:param x: x-axis coordinates.
:param y: y-axis coordinates.
:param name: title for z-axis.
:param kwargs: kwargs for bokeh figure.
:returns: a bokeh plot.
"""
bins = hexbin(x, y, kernel_size)
defaults = {
"output_backend": "webgl",
"height": 400,
"width": 500,
"background_fill_color": "#440154"
}
defaults.update(kwargs)
p = figure(**defaults)
cmap = log_cmap if log else linear_cmap
mapper = cmap('counts', 'Viridis256', 0, max(bins.counts))
p.hex_tile(q="q",
r="r",
size=kernel_size,
line_color=None,
source=bins,
fill_color=mapper)
color_bar = ColorBar(title="observations",
color_mapper=mapper['transform'],
label_standoff=10,
location=(0, 0))
p.add_layout(color_bar, 'right')
p.grid.visible = False
x_lim = util.Limiter().accumulate(x).fix(*xlim)
y_lim = util.Limiter().accumulate(y).fix(*ylim)
# limit the display range
p.x_range = Range1d(start=x_lim.min,
end=x_lim.max,
bounds=(x_lim.min, x_lim.max))
p.y_range = Range1d(start=y_lim.min,
end=y_lim.max,
bounds=(y_lim.min, y_lim.max))
return p, bins
def update(x, y, x_hex, y_hex):
source.stream(dict(x=[x], y=[y]))
bin_size = 0.15
bins = hexbin(x_hex, y_hex, bin_size)
l_hex = p.hex_tile(
q="q",
r="r",
size=0.1,
line_color=None,
source=bins,
fill_color=linear_cmap("counts", "Viridis256", 0, max(bins.counts)),
)
def get_global_fpeak_fint_over_log_snr():
"""Get global survey data for fpeak/fint vs log(snr) plot.
This function computes bokeh.util.hex.hexbins for all galaxies in the catalog,
where the x axis is galaxies.f_peak/galaxies.f_int, and the y axis is log10(snr),
with snr=(galaxies.fpeak - 0.25)/galaxies.rms
Returns
-------
hexbins:
bins to be plotted by bokeh.
"""
# getting pickle files location
fpeak_fint_pickle = settings.MEDIA_ROOT + fpeak_fint_pickle_name
log_snr_pickle = settings.MEDIA_ROOT + log_snr_pickle_name
# checking pickle exists? if yes, loading from the file
if os.path.isfile(fpeak_fint_pickle) and os.path.isfile(log_snr_pickle):
with open(fpeak_fint_pickle, 'rb') as fpeak_fint_pickle_in:
fpeak_fint = pickle.load(fpeak_fint_pickle_in)
with open(log_snr_pickle, 'rb') as log_snr_pickle_in:
log_snr = pickle.load(log_snr_pickle_in)
else: # otherwise reading from database and saving in the pickle files
# cleaning up pickle files if exists (can only happen if one is missing)
if os.path.isfile(fpeak_fint_pickle):
os.remove(fpeak_fint_pickle)
if os.path.isfile(log_snr_pickle):
os.remove(log_snr_pickle)
galaxies = Galaxy.objects.all()
fpeak_fint = []
log_snr = []
for galaxy in galaxies:
fpeak_fint.append(galaxy.fpeak / galaxy.fint)
log_snr.append(np.log10((galaxy.fpeak - 0.25) / galaxy.rms))
with open(fpeak_fint_pickle, "wb") as fpeak_fint_pickle_out:
pickle.dump(fpeak_fint, fpeak_fint_pickle_out)
with open(log_snr_pickle, "wb") as log_snr_pickle_out:
pickle.dump(log_snr, log_snr_pickle_out)
return hexbin(np.array(log_snr), np.array(fpeak_fint), 0.1)
def sort_all_bins_freq(shots):
basic_zones = [
'Above the Break 3', 'Above the Break 3', 'Above the Break 3',
'Above the Break 3', 'Backcourt', 'In The Paint (Non-RA)',
'In The Paint (Non-RA)', 'In The Paint (Non-RA)',
'In The Paint (Non-RA)', 'Left Corner 3', 'Mid-Range', 'Mid-Range',
'Mid-Range', 'Mid-Range', 'Mid-Range', 'Mid-Range', 'Mid-Range',
'Mid-Range', 'Restricted Area', 'Right Corner 3'
]
zone_areas = [
'Back Court(BC)', 'Center(C)', 'Left Side Center(LC)',
'Right Side Center(RC)', 'Back Court(BC)', 'Center(C)', 'Center(C)',
'Left Side(L)', 'Right Side(R)', 'Left Side(L)', 'Center(C)',
'Center(C)', 'Left Side Center(LC)', 'Left Side(L)', 'Left Side(L)',
'Right Side Center(RC)', 'Right Side(R)', 'Right Side(R)', 'Center(C)',
'Right Side(R)'
]
ranges = [
'Back Court Shot', '24+ ft.', '24+ ft.', '24+ ft.', 'Back Court Shot',
'8-16 ft.', 'Less Than 8 ft.', '8-16 ft.', '8-16 ft.', '24+ ft.',
'8-16 ft.', '16-24 ft.', '16-24 ft.', '16-24 ft.', '8-16 ft.',
'16-24 ft.', '16-24 ft.', '8-16 ft.', 'Less Than 8 ft.', '24+ ft.'
]
list_of_bins = []
for i in range(len(ranges)):
if i == 0 or i == 4:
pass
else:
xs, ys, freq = sort_hex_bin_freq(shots, zone_areas[i], ranges[i],
basic_zones[i])
bin = hexbin(np.array(xs), np.array(ys), 7.5)
if len(bin) == 0:
bin['counts'] = 0
else:
bin['counts'] = freq.iloc[0]
list_of_bins.append(bin)
all_bins = pd.concat(list_of_bins, ignore_index=True)
return all_bins
def hexbin_viz(
df: pd.DataFrame,
x: str,
y: str,
plot_width: int,
plot_height: int,
tile_size: Optional[float] = None,
) -> Panel:
"""
Render a hexbin plot
"""
# pylint: disable=too-many-arguments,too-many-locals
xmin, xmax = df[x].min(), df[x].max()
ymin, ymax = df[y].min(), df[y].max()
if tile_size is None:
tile_size = (xmax - xmin) / 25
title = f"{y} by {x}"
aspect_scale = (ymax - ymin) / (xmax - xmin)
bins = hexbin(
x=df[x],
y=df[y],
size=tile_size,
orientation="flattop",
aspect_scale=aspect_scale,
)
fig = figure(
title=title,
tools=[],
match_aspect=False,
background_fill_color="#f5f5f5",
toolbar_location=None,
plot_width=plot_width,
plot_height=plot_height,
)
palette = list(reversed(viridis(256)))
rend = fig.hex_tile(
q="q",
r="r",
size=tile_size,
line_color=None,
source=bins,
orientation="flattop",
fill_color=linear_cmap(
field_name="counts",
palette=palette,
low=min(bins.counts),
high=max(bins.counts),
),
aspect_scale=aspect_scale,
)
fig.add_tools(
HoverTool(
tooltips=[("Count", "@counts")],
renderers=[rend],
))
mapper = LinearColorMapper(palette=palette,
low=min(bins.counts),
high=max(bins.counts))
color_bar = ColorBar(color_mapper=mapper, width=8, location=(0, 0))
color_bar.label_standoff = 8
fig.add_layout(color_bar, "right")
tweak_figure(fig, "hex")
fig.xaxis.ticker = list(np.linspace(xmin, xmax, 10))
fig.yaxis.ticker = list(np.linspace(ymin, ymax, 10))
fig.xaxis.axis_label = x
fig.yaxis.axis_label = y
return Panel(child=fig, title="hexbin plot")
from bokeh.io import output_file, show
from bokeh.models import ColumnDataSource
from bokeh.palettes import Viridis256
from bokeh.plotting import figure
from bokeh.transform import linear_cmap
from bokeh.util.hex import hexbin
orientation = "flattop"
size = 0.1
n = 50000
x = 2 + np.random.standard_normal(n)
y = 2 + 5 * np.random.standard_normal(n)
# import
bins = hexbin(x, y, size, orientation, 5)
p = figure(title="Manual hex bin for 50000 points",
match_aspect=True,
aspect_scale=5,
tools="wheel_zoom,reset",
background_fill_color='#440154')
p.grid.visible = False
source = ColumnDataSource(data=dict(q=bins.q, r=bins.r, c=bins.counts))
p.hex_tile(q="q",
r="r",
size=size,
fill_color=linear_cmap('c', Viridis256, 0, max(bins.counts)),
line_color=None,
def test_gaussian_flattop(self, pd):
bins = buh.hexbin(x, y, 2, "flattop")
assert list(bins.q) == [0, 0, 1, 1, 1, 2]
assert list(bins.r) == [-1, 0, -2, -1, 0, -2]
assert list(bins.counts) == [95, 57, 14, 324, 8, 2]
xdiff = xupp-xlow
ydiff = ylow-yupp
aspect = ydiff/xdiff
# Initialize Light Curve Plot
fig_cmd = figure(plot_height=280, plot_width=800, sizing_mode='scale_both',
x_range=[xlow,xupp], y_range=[ylow,yupp],
tools="pan,wheel_zoom,box_zoom,reset",
title=None,
min_border=10, min_border_left=50, min_border_right=50,
toolbar_location="above", border_fill_color="whitesmoke")
fig_cmd.toolbar.logo = None
fig_cmd.xaxis.axis_label = 'Color (BP-RP)'
fig_cmd.yaxis.axis_label = 'Absolute Magnitude (G)'
# Generate Hexbin CMD for full Gaia Sample
bins = hexbin(bprp, mag, 0.05, aspect_scale=aspect)
palette = Greys256[::-1]
fill_color = log_cmap('c', palette, 1, max(bins.counts))
source = ColumnDataSource(data=dict(q=bins.q, r=bins.r, c=bins.counts))
r = fig_cmd.hex_tile(q="q", r="r", size=0.05, aspect_scale=aspect,
source=source, line_color=None, fill_color=fill_color)
# Remove Grid Lines
fig_cmd.xgrid.grid_line_color = None
fig_cmd.ygrid.grid_line_color = None
# Add a simple hover tool
fig_cmd.add_tools(HoverTool(
tooltips=[("count", "@c"), ("(q,r)", "(@q, @r)")],
mode="mouse", point_policy="follow_mouse", renderers=[r]))
scat = fig_cmd.scatter(X, Y, size=10, color="#3A5785", alpha=0.8) #, xlabel="G-R",ylabel="R")
import numpy as np
from bokeh.io import output_file, show
from bokeh.plotting import figure
from bokeh.transform import linear_cmap
from bokeh.util.hex import hexbin
n = 50000
x = np.random.standard_normal(n)
y = np.random.standard_normal(n)
bins = hexbin(x, y, 0.1)
p = figure(title="Manual hex bin for 50000 points", tools="wheel_zoom,pan,reset",
match_aspect=True, background_fill_color='#440154')
p.grid.visible = False
p.hex_tile(q="q", r="r", size=0.1, line_color=None, source=bins,
fill_color=linear_cmap('counts', 'Viridis256', 0, max(bins.counts)))
output_file("hex_tile.html")
show(p)
#n = 50000
#x = np.random.standard_normal(n)
#y = np.random.standard_normal(n)
#
df = pd.read_csv("location.csv")
source = ColumnDataSource(df)
print(type(source))
print(df.columns)
print(df.describe())
print(type(df.Latitude))
for i in df.Latitude:
print(i)
bins = hexbin(x, y, 0.05)
p = figure(title="DC locations",
tools="wheel_zoom,pan,reset",
match_aspect=True,
background_fill_color='#440154')
p.grid.visible = False
p.hex_tile(q="q",
r="r",
size=0.1,
line_color=None,
source=bins,
fill_color=linear_cmap('counts', 'Viridis256', 0, max(bins.counts)))
output_file("hex_tile.html")
source.stream(dict(x=[x], y=[y]))
bin_size = 0.15
bins = hexbin(x_hex, y_hex, bin_size)
l_hex = p.hex_tile(
q="q",
r="r",
size=0.1,
line_color=None,
source=bins,
fill_color=linear_cmap("counts", "Viridis256", 0, max(bins.counts)),
)
x_vec = [1.5, 1.5]
y_vec = [1.5, 1.5]
bins = hexbin(np.array(x_vec), np.array(y_vec), 0.1)
def blocking_task():
while True:
try:
# try:
with open(fname) as fn:
data = fn.readline()
X = np.array(eval(data))
# do some blocking computation
time.sleep(0.01)
# for loop -----------
# make a loop to plot all the data in the data-array.txt and not random selection of data
x, y = choice(X[:, 0]), choice(X[:, 1]) # input a list here to plot <<-------
print("x:", x, "y:", y)
"""
update the scatter plot
"""
df = select_subset()
bins = hexbin(df.x, df.y, 0.08)
source.data = dict(x=bins["q"], y=bins["r"], counts=bins["counts"])
year = Slider(title="Min", start=1940, end=2020, value=1950, step=1)
source = ColumnDataSource(data=dict(x=[], y=[], counts=[]))
df = pd.read_csv(
'Z:/github_packages/csd_visualisation/csd-visualisations/chemical_space/data/merge.csv'
)
df = df.loc[df['subset'] == 'drug']
bins = hexbin(df.x, df.y, 0.08)
#print bins
# Initialise boundaries
left = min(set(df.x)) - 1
right = max(set(df.x)) + 1
top = max(set(df.y)) + 1
bottom = min(set(df.y)) - 1
TOOLTIPS = [("x", "@x"), ("y", "@y")]
p = figure(title="CSD drug subset",
tools="wheel_zoom,pan,reset",
match_aspect=True,
x_range=(left, right),
y_range=(bottom, top),
background_fill_color='#440154',
# ### Bokeh figures
# Bokeh is a better plotting utility that allows scalable interactive plots
# +
from bokeh.plotting import figure
from bokeh.transform import linear_cmap
from bokeh.util.hex import hexbin
from bokeh.embed import file_html
import bokeh
n = 50000
x = np.random.standard_normal(n)
y = np.random.standard_normal(n)
bins = hexbin(x, y, 0.1)
p = figure(title="Manual hex bin for 50000 points",
tools="wheel_zoom,pan,reset",
match_aspect=True,
sizing_mode='stretch_both',
plot_width=300,
plot_height=300,
background_fill_color='#440154')
p.grid.visible = False
p.hex_tile(q="q",
r="r",
size=0.1,
line_color=None,
source=bins,
def test_gaussian_flattop(self):
bins = buh.hexbin(x, y, 2, "flattop")
assert list(bins.q) == [0, 0, 1, 1, 1, 2]
assert list(bins.r) == [-1, 0, -2, -1, 0, -2]
assert list(bins.counts) == [95, 57, 14, 324, 8, 2]
def plot_ratio(x1, y1, names1, x2, y2, names2, term1, term2, lb):
'''
This function recieves the (repeated) x,y coördinates, names of the chemicals, and the terms of two different searches.
Counts are determined for the hexagons. After normalisation for total counts, a log(ratio) is calculated for every hexagon.
Then, a blur is applied to the log(ratio), but the original log(ratio) is shown in the tooltip.
The hexagon figure is saved in a html file.
'''
length = len(x1) + len(x2)
title = 'Hexbin plot for ' + str(
length) + ' annotated chemicals with ratios of counts from ' + str(
term1) + '/' + str(term2)
x_min = min(min(x1), min(x2))
x_max = max(max(x1), max(x2))
y_min = min(min(y1), min(y2))
y_max = max(max(y1), max(y2))
# hexagon properties
orientation = 'flattop'
size = 20
ratio = (y_max - y_min) / (x_max - x_min)
if orientation == 'flattop':
size = size / ratio
h = (sqrt(3) * size) * ratio
w = (2 * size)
# boundaries plot / grid
x_grid, y_grid = make_grid(x_min, x_max, y_min, y_max, w, h)
# make figure
p = figure(title=title,
x_range=[x_min - 0.5, x_max + 0.5],
y_range=[0 - (h / 2), y_max + 100 - h],
tools="wheel_zoom,reset",
background_fill_color='#FFFFFF')
#'#D3D3D3'
p.grid.visible = False
x1 = np.append(x1, x_grid)
y1 = np.append(y1, y_grid)
x2 = np.append(x2, x_grid)
y2 = np.append(y2, y_grid)
df1 = hexbin(x1, y1, size, orientation, ratio)
df2 = hexbin(x2, y2, size, orientation, ratio)
df1, df2 = normalise_df_test(df1, df2, len(x_grid))
df3 = calculate_ratio_test(df1, df2)
df3['log'] = np.log(df3['ratio'])
print(df3['log'].sum())
# df3['blur'] = df3['log']
df3 = add_gaussian_blur(df3)
print(df3['log'].sum())
highest_abs_value = max(max(df3.blur), abs(min(df3.blur)))
df_low = df3[df3['blur'] < 0]
df_high = df3[df3['blur'] > 0]
df_eq = df3[df3['blur'] == 0]
red.reverse()
pbr = blue + ['#FFFFFF'] + red
p.hex_tile(q="q",
r="r",
size=size,
line_color=None,
source=df_low,
aspect_scale=ratio,
orientation=orientation,
hover_color="#39FF14",
fill_color=linear_cmap('blur', blue, -highest_abs_value, 0))
p.hex_tile(q="q",
r="r",
size=size,
line_color=None,
source=df_high,
aspect_scale=ratio,
orientation=orientation,
hover_color="#39FF14",
fill_color=linear_cmap('blur', red, 0, highest_abs_value))
p.hex_tile(q="q",
r="r",
size=size,
line_color=None,
source=df_eq,
aspect_scale=ratio,
orientation=orientation,
hover_color="#39FF14",
fill_color='#FFFFFF')
#hover tool
hover = HoverTool(tooltips=[('blur', '@blur')])
# hover = HoverTool(tooltips=[("log(ratio)", "@log"),("#1", "@names1"),("#2", "@names2"),("#3", "@names3"),("#4", "@names4"),("#5", "@names5")],callback=callback_hover, show_arrow=False)
p.add_tools(hover)
#output
file_name = "plots/compare_ratios_" + str(term1) + "_" + str(
term2) + ".html"
output_file(file_name)
# r = row(p,dummy)
show(p)
# p.hex_tile(q="q", r="r", size=size, line_color=None, source=df3, aspect_scale=ratio, orientation=orientation, hover_color='#39FF14',
# fill_color=linear_cmap('ratio', 'Viridis256', 0, max(df3.ratio) ))
#
# print(len(df_low))
# print(len(df_high))
# print(len(df_eq))
# print(df_low['log'].sum())
# print(df_high['log'].sum())
# get coordinates for every x,y point
# df1 = hexbin(x3, y3, size, orientation, ratio)
# df1 = hex_to_bin(x1, y1, size, ratio, orientation)
# df2 = hex_to_bin(x2, y2, size, ratio, orientation)
#
# # add the names to the dataframe
# df1['names'] = names1.append(['']*len(x3))
# df2['names'] = names2.append(['']*len(x3))
#
# # group by coordinates for hexagons
# df1 = df1.groupby(['q', 'r'])['names'].apply(list).reset_index(name='names')
# df2 = df2.groupby(['q', 'r'])['names'].apply(list).reset_index(name='names')
#
# # count chemicals per hexagon, also add column with a list of counts of individual chemicals # (SHOULD THESE BE NORMALISED?)
# df1 = transform_df(df1)
# df2 = transform_df(df2)
# #
# # print(len(df1))
# # print(len(df2))
# #
# # normalize counts against total counts
# df1_normalized = normalize_df(df1)
# df2_normalized = normalize_df(df2)
#
# # print(df1_normalized['counts'].sum())
# # print(df2_normalized['counts'].sum())
# #
# # # calculate ratio's and find most discriminating chemicals (+ difference? in counts)
# df_ratio = calculate_ratio_test(df1_normalized, df2_normalized)
#
# df_ratio_low = df_ratio[df_ratio['ratio'] < 1]
# df_ratio_eq = df_ratio[df_ratio['ratio'] == 1]
# df_ratio_high = df_ratio[df_ratio['ratio'] > 1]
#
# df_ratio_low['log'] = np.log(df_ratio_low['ratio'])
# df_ratio_high['log'] = np.log(df_ratio_high['ratio'])
# print(len(df_ratio_low))
# print(len(df_ratio_high))
# print(df_ratio_high['log'].sum())
# print(df_ratio_low['log'].sum())
# print(df_ratio[0:10])
#
# # log transformation
# df_ratio['log'] = np.log(df_ratio['ratio'])
# df_ratio['blur'] = np.log(df_ratio['ratio'])
# # finding most discriminating chemicals per hexagon
# # df_ratio = find_discriminating_chemicals(df_ratio)
# # df_ratio = df_ratio.drop(columns="dif")
#
# print(df_ratio.columns)
# # add blur to log ratio's
# df_ratio = add_gaussian_blur(df_ratio)
# print(df_ratio.columns)
#
# # make two dataframes to create two glyphs
# df_ratio_low = df_ratio[df_ratio['log'] < 0]
# df_ratio_zero = df_ratio[df_ratio['log'] == 0]
# df_ratio_high = df_ratio[df_ratio['log'] > 0]
#
# print(len(df_ratio_low))
# print(len(df_ratio_high ))
# print(len(df_ratio_zero))
# # blue.append('#FFFFFF')
# # red.append('#FFFFFF')
# # color bar
# color_mapper = LinearColorMapper(palette=pbr, low=-5, high=5)
#
# color_bar = ColorBar(color_mapper=color_mapper, ticker=BasicTicker(),major_label_overrides={4: 'More '+str(term1)+' counts',-4:"More "+str(term2)+" counts"},major_label_text_align='left',
# label_standoff=6, border_line_color=None, location=(0,0))
#
# # color bar is added to a dummy figure, to prevent the shrinking of the original plot
# dummy = figure(
# toolbar_location=None,
# min_border=0,
# outline_line_color=None)
# dummy.add_layout(color_bar, 'left')
# dummy.title.align = 'center'
# dummy.title.text_font_size = '10pt'
#hover position
callback_hover = CustomJS(code="""
var tooltips = document.getElementsByClassName("bk-tooltip");
for (var i = 0, len = tooltips.length; i < len; i ++) {
tooltips[i].style.top = ""; // unset what bokeh.js sets
tooltips[i].style.left = "";
tooltips[i].style.bottom = "280px";
tooltips[i].style.left = "700px";
tooltips[i].style.width = "300px";
}
""")
def create_figure():
df_loc = df
if not df.empty:
# applying cut on data
cut_cmd = ""
if (str(cut_1.value) in cut_1.options) and (str(cut_1_op.value) in cut_1_op.options) and \
str(cut_1.value) is not 'None' and cut_1_input.value != "":
cut_cmd += "(df[\"" + str(cut_1.value) + "\"]" + str(cut_1_op.value) + \
"%d" % float(cut_1_input.value) + ")"
if (str(cut_2.value) in cut_2.options) and (str(cut_2_op.value) in cut_2_op.options) and \
str(cut_2.value) is not 'None' and cut_2_input.value != "":
if cut_cmd != "":
cut_cmd += " & "
cut_cmd += "(df[\"" + str(cut_2.value) + "\"]" + str(cut_2_op.value) + \
"%d" % float(cut_2_input.value) + ")"
if (str(cut_3.value) in cut_3.options) and (str(cut_3_op.value) in cut_3_op.options) and \
str(cut_3.value) is not 'None' and cut_3_input.value != "":
if cut_cmd != "":
cut_cmd += " & "
cut_cmd += "(df[\"" + str(cut_3.value) + "\"]" + str(cut_3_op.value) + \
"%d" % float(cut_3_input.value) + ")"
if (str(cut_4.value) in cut_4.options) and (str(cut_4_op.value) in cut_4_op.options) and \
str(cut_4.value) is not 'None' and cut_4_input.value != "":
if cut_cmd != "":
cut_cmd += " & "
cut_cmd += "(df[\"" + str(cut_4.value) + "\"]" + str(cut_4_op.value) + \
"%d" % float(cut_4_input.value) + ")"
if cut_cmd != "":
cut_cmd += " & (df[\"event_id\"]>" + str(range_select.value) + ") & " + \
"(df[\"event_id\"]<" + str(int(range_select.value) + int(num_event.value)) + ")"
else:
cut_cmd += "(df[\"event_id\"]>" + str(range_select.value) + ") & " + \
"(df[\"event_id\"]<" + str(int(range_select.value) + int(num_event.value)) + ")"
cut_cmd += ", ["
for i, v in enumerate(columns):
if i == 0:
cut_cmd += "\"" + v + "\""
else:
cut_cmd += ",\"" + v + "\""
cut_cmd += "]"
df_loc = df.loc[eval(cut_cmd)]
x_title = x.value.title()
y_title = y.value.title()
sz = 6
if size.value != 'None':
groups = pd.qcut(df_loc[size.value].values, len(SIZES))
sz = [SIZES[xx] for xx in groups.codes]
c = "#31AADE"
if color.value != 'None':
groups = pd.qcut(df_loc[color.value].values, len(COLORS))
c = [COLORS[xx] for xx in groups.codes]
if type(int()) != type(sz):
df_loc['size'] = sz
if type(str()) != type(c):
df_loc['color'] = c
source = ColumnDataSource(data=df_loc)
kw = dict()
if x.value in discrete:
kw['x_range'] = sorted(set(source[x.value]))
if y.value in discrete:
kw['y_range'] = sorted(set(source[y.value]))
kw['title'] = "%s vs %s" % (x_title, y_title)
tuple_hover_var = []
for i in columns:
if i != 'None':
hover_list = "(\"" + str(i) + "\",\"@" + str(i) + "\")"
tuple_hover_var.append(eval(hover_list))
TOOLS = ["pan,box_zoom,reset,wheel_zoom, hover, save"]
if x.value == 'time' and y.value != 'time':
p = figure(plot_height=800, plot_width=800, x_axis_type="datetime", tools=TOOLS,
toolbar_location='above', toolbar_sticky=False, **kw)
p.xaxis.formatter = DatetimeTickFormatter(microseconds=["%m/%d/%y %I:%M:%S %p"],
milliseconds=["%m/%d/%y %I:%M:%S %p"],
seconds=["%m/%d/%y %I:%M:%S %p"],
minsec=["%m/%d/%y %I:%M:%S %p"],
minutes=["%m/%d/%y %I:%M:%S %p"],
hourmin=["%m/%d/%y %I:%M:%S %p"],
hours=["%m/%d/%y %I:%M:%S %p"],
days=["%m/%d/%y %I:%M:%S %p"],
months=["%m/%d/%y %I:%M:%S %p"],
years=["%m/%d/%y %I:%M:%S %p"])
elif x.value != 'time' and y.value == 'time':
p = figure(plot_height=800, plot_width=800, y_axis_type="datetime", tools=TOOLS, toolbar_location='above',
toolbar_sticky=False, **kw)
p.yaxis.formatter = DatetimeTickFormatter(microseconds=["%m/%d/%y %I:%M:%S %p"],
milliseconds=["%m/%d/%y %I:%M:%S %p"],
seconds=["%m/%d/%y %I:%M:%S %p"],
minsec=["%m/%d/%y %I:%M:%S %p"],
minutes=["%m/%d/%y %I:%M:%S %p"],
hourmin=["%m/%d/%y %I:%M:%S %p"],
hours=["%m/%d/%y %I:%M:%S %p"],
days=["%m/%d/%y %I:%M:%S %p"],
months=["%m/%d/%y %I:%M:%S %p"],
years=["%m/%d/%y %I:%M:%S %p"])
elif x.value == 'time' and y.value == 'time':
p = figure(plot_height=800, plot_width=800, x_axis_type="datetime", y_axis_type="datetime",
toolbar_location='above', toolbar_sticky=False, tools=TOOLS, **kw)
p.xaxis.formatter = DatetimeTickFormatter(microseconds=["%m/%d/%y %I:%M:%S %p"],
milliseconds=["%m/%d/%y %I:%M:%S %p"],
seconds=["%m/%d/%y %I:%M:%S %p"],
minsec=["%m/%d/%y %I:%M:%S %p"],
minutes=["%m/%d/%y %I:%M:%S %p"],
hourmin=["%m/%d/%y %I:%M:%S %p"],
hours=["%m/%d/%y %I:%M:%S %p"],
days=["%m/%d/%y %I:%M:%S %p"],
months=["%m/%d/%y %I:%M:%S %p"],
years=["%m/%d/%y %I:%M:%S %p"])
p.yaxis.formatter = DatetimeTickFormatter(microseconds=["%m/%d/%y %I:%M:%S %p"],
milliseconds=["%m/%d/%y %I:%M:%S %p"],
seconds=["%m/%d/%y %I:%M:%S %p"],
minsec=["%m/%d/%y %I:%M:%S %p"],
minutes=["%m/%d/%y %I:%M:%S %p"],
hourmin=["%m/%d/%y %I:%M:%S %p"],
hours=["%m/%d/%y %I:%M:%S %p"],
days=["%m/%d/%y %I:%M:%S %p"],
months=["%m/%d/%y %I:%M:%S %p"],
years=["%m/%d/%y %I:%M:%S %p"])
else:
p = figure(plot_height=800, plot_width=800, tools=TOOLS, toolbar_location='above',
toolbar_sticky=False, **kw)
if x.value == 'local_time' or x.value == 'time':
p.xaxis.major_label_orientation = np.pi / 4
if y.value == 'local_time' or y.value == 'time':
p.yaxis.major_label_orientation = np.pi / 4
p.xaxis.axis_label = x_title
p.yaxis.axis_label = y_title
if type(int()) == type(sz) and type(c) == type(str()):
if radio_button_group.active == 0:
p.circle(x.value, y.value, color=c, size=sz, line_color="white", alpha=0.6, hover_color="red",
source=source)
else:
nbins_x = get_nbins(df_loc[x.value])
nbins_y = get_nbins(df_loc[y.value])
if nbins_x >= nbins_y:
scale = (df_loc[x.value].max() - df_loc[x.value].min()) / float(nbins_x)
else:
scale = (df_loc[y.value].max() - df_loc[y.value].min()) / float(nbins_y)
bins = hexbin(df_loc[x.value], df_loc[y.value], scale)
mapper = LinearColorMapper(palette=Inferno256, low=0, high=max(bins.counts))
lin_mapper = linear_cmap('counts', 'Inferno256', 0, max(bins.counts))
p.hex_tile(q="q", r="r", size=scale, line_color=None, source=bins, fill_color=lin_mapper)
color_bar = ColorBar(color_mapper=mapper, ticker=BasicTicker(desired_num_ticks=10),
border_line_color=None, background_fill_color='#2F2F2F', label_standoff=12,
major_label_text_color='white', margin=0, title_text_color='white')
p.add_layout(color_bar, place='right')
elif type(int()) != type(sz) and type(c) == type(str()):
p.circle(x.value, y.value, color=c, size='size', line_color="white", alpha=0.6, hover_color="red",
source=source)
elif type(int()) == type(sz) and type(c) != type(str()):
p.circle(x.value, y.value, color='color', size=sz, line_color="white", alpha=0.6, hover_color="red",
source=source)
mapper = LinearColorMapper(palette=Inferno256, low=df_loc[color.value].min(),
high=df_loc[color.value].max())
color_bar = ColorBar(color_mapper=mapper, ticker=BasicTicker(desired_num_ticks=10), border_line_color=None,
background_fill_color='#2F2F2F', label_standoff=12, major_label_text_color='white',
margin=0, title=color.value, title_text_color='white')
p.add_layout(color_bar, place='right')
else:
p.circle(x.value, y.value, color='color', size='size', line_color="white", alpha=0.6, hover_color="red",
source=source)
mapper = LinearColorMapper(palette=Inferno256, low=df_loc[color.value].min(),
high=df_loc[color.value].max())
color_bar = ColorBar(color_mapper=mapper, ticker=BasicTicker(desired_num_ticks=10), border_line_color=None,
background_fill_color='#2F2F2F', label_standoff=12, major_label_text_color='white',
margin=0, title=color.value, title_text_color='white')
p.add_layout(color_bar, place='right')
hover = p.select_one(HoverTool)
hover.mode = "mouse"
if radio_button_group.active == 0:
hover.tooltips = tuple_hover_var
else:
hover.tooltips = [("count", "@c"), ("(q,r)", "(@q, @r)")]
# create the horizontal histogram
hhist, hedges = np.histogram(np.array(df_loc[x.value]), bins=get_nbins(np.array(df_loc[x.value])))
hmax = max(hhist) * 1.1
LINE_ARGS = dict(color="#3A5785", line_color=None)
ph = figure(toolbar_location=None, plot_width=p.plot_width, plot_height=200, x_range=p.x_range,
y_range=(0, hmax), min_border=10, min_border_left=50, y_axis_location="right")
ph.xgrid.grid_line_color = None
ph.yaxis.major_label_orientation = np.pi / 4
ph.background_fill_color = "#2F2F2F"
ph.quad(bottom=0, left=hedges[:-1], right=hedges[1:], top=hhist, line_color="#3A5785")
# create the vertical histogram
vhist, vedges = np.histogram(np.array(df_loc[y.value]), bins=get_nbins(np.array(df_loc[y.value])))
vmax = max(vhist) * 1.1
pv = figure(toolbar_location=None, plot_width=200, plot_height=p.plot_height, x_range=(0, vmax),
y_range=p.y_range, min_border=10, y_axis_location="right")
pv.ygrid.grid_line_color = None
pv.xaxis.major_label_orientation = np.pi / 4
pv.background_fill_color = "#2F2F2F"
pv.quad(left=0, bottom=vedges[:-1], top=vedges[1:], right=vhist, line_color="#3A5785")
plot_layout = column(row(p, pv), row(ph, Spacer(width=200, height=200)))
return plot_layout
else:
p = figure(plot_height=800, plot_width=800)
p.text(x=[1, 2, 3], y=[1, 2, 3], text=['SST-1M', 'SST-1M', 'SST-1M'])
return p
