def _plot_bokeh(self, current_plot, show_legend=True):
from bokeh.models.tools import HoverTool
from collections import OrderedDict
from bokeh.models.ranges import FactorRange
import bokeh.plotting as bkh
value_lst = self.matrix.flatten()
min_el = min(value_lst)
vmax = float(max(value_lst) - min_el)
color_lst = [BOKEH_CMAP[int((v - min_el) / vmax * (len(BOKEH_CMAP) - 1))] \
for v in value_lst]
source = bkh.ColumnDataSource(
data=dict(
x=self.labels * self.matrix.shape[0],
y=numpy.array([[i] * self.matrix.shape[1] for i in self.labels]).flatten(),
color=color_lst,
value=value_lst,
)
)
# current_plot._below = []
current_plot.x_range = FactorRange(factors=self.labels)
current_plot.y_range = FactorRange(factors=self.labels)
# current_plot._left = []
# current_plot.extra_y_ranges = {"foo": bkh.FactorRange(factors=self.labels)}
# current_plot.add_layout(CategoricalAxis(y_range_name="foo"), place='left')
# current_plot.extra_x_ranges = {"foo": bkh.FactorRange(factors=self.labels)}
# current_plot.add_layout(CategoricalAxis(x_range_name="foo"), place='top')
current_plot.rect('x', 'y', 0.98, 0.98, source=source, color='color', line_color=None)
current_plot.grid.grid_line_color = None
current_plot.axis.axis_line_color = None
current_plot.axis.major_tick_line_color = None
hover = current_plot.select(dict(type=HoverTool))
if not hover:
hover = HoverTool(plot=current_plot)
hover.tooltips = OrderedDict([
('labels', '@x @y'),
('value', '@value')
])
current_plot.tools.append(hover)
return current_plot
au = orig_au = lx = orig_lx = p1 = orig_p1 = p2 = orig_p2 = []
lp_p1 = orig_lp_p1 = lp_p2 = orig_lp_p2 = timepts = []
raw_p1 = raw_p2 = raw_lp_p1 = raw_lp_p2 = raw_lp_decim_p1 = raw_lp_decim_p2 = []
p1_cal = p2_cal = None
width = 800
height = 200
cutoff = 50
order = 3
source = ColumnDataSource(data=dict(
x=timepts, au=au, p1=p1, raw_lp_decim_p1=p1, p2=p2, raw_lp_decim_p2=p2))
# Create the tools for the toolbar
ts_cnt = np.arange(3)
cross = [CrosshairTool() for n in ts_cnt]
hover = [
HoverTool(tooltips=[('time', '$x'), ('sample', '@x')]),
HoverTool(tooltips=[('time', '$x'), ('val',
'@p1'), ('raw', '@raw_lp_decim_p1')]),
HoverTool(tooltips=[('time', '$x'), ('val',
'@p2'), ('raw', '@raw_lp_decim_p2')])
]
xzoom = [BoxZoomTool(dimensions=['width']) for n in ts_cnt]
xwzoom = [WheelZoomTool(dimensions=['width']) for n in ts_cnt]
xsel = [BoxSelectTool(dimensions=['width']) for n in ts_cnt]
xtsel = [TapTool() for n in ts_cnt]
xpan = [PanTool(dimensions=['width']) for n in ts_cnt]
save = [SaveTool() for n in ts_cnt]
reset = [ResetTool() for n in ts_cnt]
tools = [[
cross[n], hover[n], xpan[n], xzoom[n], xwzoom[n], xsel[n], xtsel[n],
save[n], reset[n]
p = figure(
x_range=x_range,
y_range=y_range,
x_axis_type="mercator",
y_axis_type="mercator",
aspect_ratio=.9,
sizing_mode='scale_both',
align='center',
output_backend="webgl",
)
p.add_tile(tile_provider)
p.add_tools(
HoverTool(tooltips=[
('Year Sold', '@{DEED YEAR}'),
('Price', '$@{SALE PRICE}{0,0,0}'),
('Property Type', '@{PROP CLASS DESCRIPTION}'),
('Address', '@{ADDRESS}'),
], ))
# create linear color mapper and color bar
color_mapper = LinearColorMapper(palette=Viridis256, low=10000, high=200000)
formatter = NumeralTickFormatter(format='($ 0 a)')
color_bar = ColorBar(color_mapper=color_mapper,
label_standoff=12,
formatter=formatter)
p.add_layout(color_bar, 'right')
# Add Points
points = p.circle(
x='x',
y='y',
async def get(self):
"""Fetch and publish metric values asynchronously."""
for predictor_model in self.settings["model_list"]:
df = predictor_model.predicted_df
output_file('static/graph.html')
TOOLS = "pan,wheel_zoom,reset,save"
plot = figure(plot_width=800, plot_height=300, x_axis_type="datetime", title=predictor_model.model_name,
tools=TOOLS, toolbar_location="above")
plot.xaxis.axis_line_color = "rgb(173, 173, 173)"
plot.yaxis.axis_line_color = "white"
plot.yaxis.major_tick_line_color = "white"
plot.xaxis.major_tick_in = 1
metric_values = predictor_model.metric.metric_values
source_real = ColumnDataSource(data=dict(values=metric_values.values[:, 1], dates=metric_values.values[:, 0]))
source_yhat = ColumnDataSource(data=dict(values=df.yhat.values, dates=df.yhat.index.values))
source_yhat_bound = ColumnDataSource(data=dict(yhat_upper=df.yhat_upper.values, yhat_lower=df.yhat_lower.values,dates=df.yhat_upper.index.values))
band = Band(base='dates', lower='yhat_lower', upper='yhat_upper', source=source_yhat_bound,
level='overlay', fill_alpha=0.7, fill_color="rgb(200, 200, 200)", line_width=0)
plot.add_layout(band)
plot.line(x='dates', y='values', source=source_yhat, color="black")
plot.line(x='dates', y='values', source=source_real, color="red")
plot.xgrid.visible = False
plot.title.text_color = "rgb(173, 173, 173)"
plot.yaxis.minor_tick_line_color = None
plot.add_tools(HoverTool(
tooltips=[
('date', '@dates{|%F %T|}'),
('value', '$y'),
],
formatters={
'@dates': 'datetime'
},
mode='vline'
))
script_bokeh, div_bokeh = components(plot)
resources_bokeh = CDN.render()
template = Template(
'''<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Overview</title>
{{ resources }}
{{ script }}
<style>
.embed-wrapper {
display: flex;
justify-content: space-evenly;
}
.bk-logo {
display:none !important;
}
.bk-tool-icon-hover {
display:none !important;
}
</style>
</head>
<body style="background-color:rgb(246, 246, 246);>
<div class="embed-wrapper">
{{ div }}
</div>
</body>
</html>
''')
html = template.render(resources=resources_bokeh,
script=script_bokeh,
div=div_bokeh)
out_file_path = "static/graph.html"
with io.open(out_file_path, mode='w') as f:
f.write(html)
self.render("static/graph.html")
part = df
source = ColumnDataSource(part)
print(source)
values_x = [1, 2, 3, 4, 5, 6, 7, 8]
values_y = [a for a in part.stock_price]
plot = figure(title="Stock price",
x_axis_label='Date',
y_axis_label='stock price',
x_axis_type='datetime')
plot.line(x=part.time, y=values_y, line_color='blue', line_width=5)
for a in range(len(values_y)):
if part.Sentiment[a] > 10:
plot.circle(df.iloc[a]["time"],
values_y[a],
fill_color='blue',
size=50)
else:
plot.circle(df.iloc[a]["time"],
values_y[a],
fill_color='green',
size=50)
hover = HoverTool()
hover.tooltips = [('Average sentiment', '@time')]
plot.add_tools(hover)
output_file('index.html')
show(plot)
p12.annulus(x=c1,
y=d1,
inner_radius=0.1,
outer_radius=0.25,
color=color2,
alpha=0.8)
p12.segment(c1, -1000, c1, d1, line_width=3, line_color=color2, alpha=0.8)
p12.y_range.start = -200
p12.xgrid.visible = False
p12.ygrid.visible = False
p12.axis.minor_tick_line_color = None
p12.title.align = "center"
p12.title.text_font_size = "20px"
p12.xaxis.major_label_orientation = math.pi / 2
p12.xaxis.major_label_text_font_size = "8px"
hover = HoverTool(tooltips=([('Date_Month_Year', '@x'), ('New_Cases', '@y')]),
renderers=[a])
p12.add_tools(hover)
"""c2 = list(df['Date'].values)
d2=df['Total_Cases'].tolist()
l=len(c2)
color3=linear_palette(Viridis256,l)
p13 = figure(x_range=c2, plot_height=350, title="Total Cases in India - Till date on daily basis",
toolbar_location='right', tools="zoom_in,zoom_out,reset,save,pan,box_select,box_zoom",plot_width=650,y_axis_label='No.of.cases')
p13.segment(c2,-5000, c2,d2, line_width=3, line_color=color3, alpha=0.8 )
a=p13.circle(x=c2,y= d2, size=8, fill_color=color3, line_color="black", line_width=2,alpha=0.65 )
p13.xgrid.visible = False
p13.ygrid.visible = False
p13.axis.minor_tick_line_color = None
hover=HoverTool(tooltips=([('Date','@x'),('Cases','@y')]),renderers=[a])
p13.add_tools(hover)
top_weapon_kills_wide.sum(axis=1), axis=0)
from bokeh.models.tools import HoverTool
from bokeh.palettes import brewer
from bokeh.plotting import figure, show, output_notebook
from bokeh.models.sources import ColumnDataSource
def stacked(df):
df_top = df.cumsum(axis=1)
df_bottom = df_top.shift(axis=1).fillna(0)[::-1]
df_stack = pd.concat([df_bottom, df_top], ignore_index=True)
return df_stack
hover = HoverTool(tooltips=[("index", "$index"), ("weapon", "@weapon"),
("(x,y)", "($x, $y)")],
point_policy='follow_mouse')
areas = stacked(top_weapon_kills_wide)
colors = brewer['Spectral'][areas.shape[1]]
x2 = np.hstack(
(top_weapon_kills_wide.index[::-1], top_weapon_kills_wide.index)) / 0.095
TOOLS = "pan,wheel_zoom,box_zoom,reset,previewsave"
output_notebook()
p = figure(x_range=(1, 800),
y_range=(0, 1),
tools=[TOOLS, hover],
plot_width=800)
p.grid.minor_grid_line_color = '#eeeeee'
def add_gaia_figure_elements(tpf, fig, magnitude_limit=18):
"""Make the Gaia Figure Elements"""
# Get the positions of the Gaia sources
c1 = SkyCoord(tpf.ra, tpf.dec, frame='icrs', unit='deg')
# Use pixel scale for query size
pix_scale = 4.0 # arcseconds / pixel for Kepler, default
if tpf.mission == 'TESS':
pix_scale = 21.0
# We are querying with a diameter as the radius, overfilling by 2x.
from astroquery.vizier import Vizier
Vizier.ROW_LIMIT = -1
result = Vizier.query_region(c1,
catalog=["I/345/gaia2"],
radius=Angle(
np.max(tpf.shape[1:]) * pix_scale,
"arcsec"))
no_targets_found_message = ValueError(
'Either no sources were found in the query region '
'or Vizier is unavailable')
too_few_found_message = ValueError(
'No sources found brighter than {:0.1f}'.format(magnitude_limit))
if result is None:
raise no_targets_found_message
elif len(result) == 0:
raise too_few_found_message
result = result["I/345/gaia2"].to_pandas()
result = result[result.Gmag < magnitude_limit]
if len(result) == 0:
raise no_targets_found_message
radecs = np.vstack([result['RA_ICRS'], result['DE_ICRS']]).T
coords = tpf.wcs.all_world2pix(
radecs, 1) ## TODO, is origin supposed to be zero or one?
year = ((tpf.astropy_time[0].jd - 2457206.375) * u.day).to(u.year)
pmra = (
(np.nan_to_num(np.asarray(result.pmRA)) * u.milliarcsecond / u.year) *
year).to(u.arcsec).value
pmdec = (
(np.nan_to_num(np.asarray(result.pmDE)) * u.milliarcsecond / u.year) *
year).to(u.arcsec).value
result.RA_ICRS += pmra
result.DE_ICRS += pmdec
# Gently size the points by their Gaia magnitude
sizes = 64.0 / 2**(result['Gmag'] / 5.0)
one_over_parallax = 1.0 / (result['Plx'] / 1000.)
source = ColumnDataSource(data=dict(ra=result['RA_ICRS'],
dec=result['DE_ICRS'],
source=result['Source'].astype(str),
Gmag=result['Gmag'],
plx=result['Plx'],
one_over_plx=one_over_parallax,
x=coords[:, 0] + tpf.column,
y=coords[:, 1] + tpf.row,
size=sizes))
r = fig.circle('x',
'y',
source=source,
fill_alpha=0.3,
size='size',
line_color=None,
selection_color="firebrick",
nonselection_fill_alpha=0.0,
nonselection_line_color=None,
nonselection_line_alpha=0.0,
fill_color="firebrick",
hover_fill_color="firebrick",
hover_alpha=0.9,
hover_line_color="white")
fig.add_tools(
HoverTool(tooltips=[("Gaia source", "@source"), ("G", "@Gmag"),
("Parallax (mas)",
"@plx (~@one_over_plx{0,0} pc)"),
("RA", "@ra{0,0.00000000}"),
("DEC", "@dec{0,0.00000000}"), ("x", "@x"),
("y", "@y")],
renderers=[r],
mode='mouse',
point_policy="snap_to_data"))
return fig, r
def plot_weekly_stats(plot_df, stat, save_filepath=None, plot_team=TEAM_NAME):
"""
"""
plot_df = plot_df.rename(columns={'FG%': 'FG_PCT', 'FT%': 'FT_PCT'})
runtime = datetime.datetime.now()
p = figure(
title=
f'{stat} (last updated: {get_weekday(runtime.weekday())} {runtime.strftime("%m/%d %H:%M")})',
x_axis_label='Week',
y_axis_label=stat,
width=600,
height=400)
xs = [plot_df.week.unique()] * 12
ys = [plot_df[plot_df.team_name == plot_team][stat].values]
for team in plot_df[plot_df.team_name != plot_team].team_name.unique():
ys.append(plot_df[plot_df.team_name == team][stat].values)
opps = plot_df[plot_df.team_name ==
plot_team]['opponent_team_name'].to_numpy()
opp_vals = plot_df[(plot_df.team_name.isin(opps)) &
(plot_df.opponent_team_name == plot_team)][stat].values
r = p.multi_line(xs,
ys,
line_color=['blue'] + ['grey'] * 11,
alpha=[1] + [0.5] * 11,
line_width=2)
r2 = p.line('week',
f'{stat}',
source=plot_df[plot_df.team_name == opps[-1]],
color='red',
alpha=1,
line_width=2)
p.circle('week',
f'{stat}',
source=plot_df[(plot_df.team_name == plot_team)],
color='blue',
fill_color='white',
size=12)
p.circle('week',
f'{stat}',
source=plot_df[(plot_df.team_name.isin(opps))
& (plot_df.opponent_team_name == plot_team)],
color='red',
fill_color='white',
size=12)
legend = Legend(items=[
LegendItem(label=plot_team, renderers=[r], index=0),
LegendItem(label=opps[-1], renderers=[r2], index=1)
])
p.add_tools(
HoverTool(tooltips=[('Team', '@team_name'), (f'{stat}', f'@{stat}')]))
p.add_layout(legend)
p.xaxis.ticker = plot_df.week.unique()
if save_filepath:
print('Saving to', save_filepath)
bokeh.plotting.output_file(save_filepath)
show(p)
else:
show(p)
return p
def plot_with_pca():
labels = []
tokens = []
for word in model.wv.vocab:
if (word.startswith("rex")):
continue
tokens.append(model[word])
labels.append(word)
tsne_model = TSNE(perplexity=40,
n_components=2,
init='pca',
n_iter=2500,
random_state=23)
new_values = tsne_model.fit_transform(tokens)
x = []
y = []
for value in new_values:
x.append(value[0])
y.append(value[1])
vector = [
'valign', 'vp', 'vblend', 'vbroadcast', 'vcompress', 'vcvt', 'vdbs',
'vexpand', 'vextract', 'vfixup', 'vfmadd', 'vfmsub', 'vfnmadd',
'vfnmsub', 'vfpclass', 'vgather', 'vget', 'vinsert', 'vmask', 'vmov',
'vpblend', 'vpbroadcast', 'vpcmp', 'vpcompress', 'vpconflict', 'vperm',
'vpexpand', 'vpgather', 'vplzcnt', 'vpmadd', 'vpmask', 'vpmov',
'vmult', 'vpro', 'vpscatter', 'vps', 'vpt', 'vran', 'vrcp', 'vred',
'vrnd', 'vrsq', 'vsca', 'vshuf', 'vtest', 'vzero', 'vector'
]
read = ['rdpid', 'rdpkru', 'rdpmc', 'rdrand', 'rdseed', 'rdtsc']
mask = [
'kadd', 'kand', 'kor', 'kmov', 'knot', 'kshift', 'ktest', 'kunpck',
'kxnor', 'kxor'
]
bound = ['bndcl', 'bndcn', 'bndcu', 'bndldx', 'bndmk', 'bndmov', 'bndstx']
string = [
'cmps', 'cmpsb', 'cmpsq', 'cmpsw', 'lods', 'movs', 'rep', 'scas',
'stos'
]
flag = [
'clac', 'clc', 'cld', 'cli', 'clts', 'cmc', 'lahf', 'popf', 'pushf',
'sahf', 'stac', 'stc', 'std'
]
segment_reg = [
'lds', 'les', 'lfs', 'lgs', 'lss', 'rdfs', 'rdgs', 'rdmsr', 'swapgs',
'verr', 'verw', 'wrfs', 'wrgs', 'xgetbv', 'xsetbv'
]
misc = ['cpuid', 'lea', 'nop', 'xlat']
floating_control = [
'fclex', 'fcmov', 'fdecstp', 'ffree', 'fincstp', 'finit', 'fldcw',
'fldenv', 'fnclex', 'fninit', 'fnop', 'fnsave', 'fnstcw', 'fnstenv',
'fnstsw', 'frstor', 'fsave', 'fstcw', 'fstenv', 'fstsw', 'fwait',
'fxrstor', 'fxsave'
]
floating_data = ['fbld', 'fbstp', 'fild', 'fist', 'fld', 'fst', 'fxch']
floating_arith = [
'fabs', 'fadd', 'faddp', 'fchs', 'fdiv', 'fiadd', 'fidiv', 'fimul',
'fisub', 'fmul', 'frndint', 'fscale', 'fsub'
]
floating_comparison = ['fcom', 'ficom', 'ftst', 'fucom', 'fxam']
floating_transcendental = [
'f2xmi', 'fcos', 'fpatan', 'fprem', 'fptan', 'fsin', 'fsqrt',
'fxtract', 'fyl2x'
]
simd_state = ['fxrstor', 'fxsave']
mmx = [
'packssdw', 'packsswb', 'packusdw', 'packuswb', 'pabs', 'padd',
'palignr', 'pblend', 'pclmulqdql', 'phadd', 'phmin', 'phsub', 'pmadd',
'psadbw', 'psign', 'package', 'pcmp', 'pand', 'por', 'ptest', 'pxor',
'psra', 'psrl', 'emms', 'xabort', 'xacquire', 'xbegin', 'xrelease',
'xrstor', 'xsave', 'xtest', 'xend'
]
sse = [
'extractps', 'movaps', 'movups', 'addps', 'addss', 'addsubps',
'blendps', 'blendvps', 'divps', 'divss', 'dpps', 'haddps', 'hsubps',
'maxps', 'maxss', 'minps', 'minss', 'mulps', 'mulss', 'sqrtps',
'sqrtss', 'subps', 'subss', 'cmpps', 'cmpss', 'comiss', 'rcpps',
'rcpss', 'ucomiss', 'andnps', 'andps', 'orps', 'xorps', 'shufps',
'unpckhps', 'unpckhlps', 'cvtdq2ps', 'cvtdpd2ps', 'cvtpi2ps',
'cvtps2dq', 'cvtps2pd', 'cvtps2pi', 'cvtss2sd', 'cvtss2si',
'cvttps2dq', 'cvttps2pi', 'movhlps', 'movhps', 'movlhps', 'movlps',
'movmskps', 'rsqrt', 'maskmovq', 'movntps', 'movntq', 'pause',
'prefetch', 'sfence'
]
sse2 = [
'movapd', 'movddup', 'movupd', 'addpd', 'addsd', 'addsubpd', 'blendpd',
'blendvpd', 'divpd', 'divsd', 'dppd', 'haddpd', 'hsubpd', 'maxpd',
'maxsd', 'minpd', 'minsd', 'mpsadbw', 'mulpd', 'mulsd', 'sqrtpd',
'sqrtsd', 'subpd', 'subsd', 'cmppd', 'cmpsd', 'comisd', 'ucomisd',
'andnpd', 'andpd', 'orpd', 'xorpd', 'shufpd', 'unpckhpd', 'unpckhlpd',
'cvtdq2pd', 'cvtdpd2dq', 'cvtdpd2pi', 'cvtpi2pd', 'cvtsd2si',
'cvtsd2ss', 'cvtsi2ss', 'cvtsi2sd', 'cvttpd2dq', 'cvttpd2pi',
'cvttsd2si', 'cvttss2si', 'movdq2q', 'movdqa', 'movdqu', 'movhpd',
'movlpd', 'movmskpd', 'movq2dq', 'pavg', 'pextr', 'pinsr', 'pmax',
'pmin', 'pmov', 'pmul', 'pshuf', 'psll', 'psub', 'punpck', 'roundpd',
'roundps', 'roundsd', 'roundss', 'clflush', 'clflushopt', 'clwb',
'lfence', 'maskmovdqu', 'mfence', 'movntdq', 'movnti', 'movntpd'
]
system = [
'hlt', 'invd', 'invlpg', 'invpcid', 'lgdt', 'lidt', 'lldt', 'lmsw',
'lock', 'lsl', 'ltr', 'rsm', 'sgdt', 'sidt', 'sldt', 'smsw', 'stmxcsr',
'str', 'wbinvd', 'wrmsr', 'wrpkru', 'ldmxcsr'
]
encryption = [
'aesdec', 'aesdeclast', 'aesenc', 'aesenclast', 'aesimc',
'aeskeygenassist', 'sha1', 'sha256'
]
mmx_data = ['movd', 'movq']
dec_arith = ['aaa', 'aad', 'aam', 'aas', 'adcx', 'daa', 'das']
binary_arith = [
'adc', 'add', 'adox', 'cmp', 'dec', 'div', 'idiv', 'imul', 'inc',
'mul', 'neg', 'sbb', 'sub', 'tzcnt'
]
logical = ['and', 'andn', 'not', 'or', 'xor']
shift = ['rcl', 'rcr', 'rol', 'ror', 'sal', 'sar', 'shl', 'shr']
bit_byte = [
'bextr', 'blsi', 'blsmsk', 'blsr', 'bsf', 'bsr', 'bt', 'btc', 'btr',
'bts', 'lzcnt', 'set', 'test'
]
control_transfer = [
'bound', 'call', 'enter', 'int', 'iret', 'jmp', 'leave', 'loop', 'ret',
'wait', 'sysret'
]
data_transfer = [
'bswap', 'bzhi', 'cbw', 'cdq', 'cdqe', 'cmov', 'cmpxchg', 'cqo',
'crc32', 'cwd', 'cwde', 'lar', 'lddqu', 'mov', 'pdep', 'pext', 'pop',
'ptwrite', 'push', 'xadd'
]
io = ['in', 'ins', 'out']
color = []
type1 = []
for i in range(len(labels)):
c = '#000000'
t = ''
if (labels[i].lower().startswith(tuple(vector)) > 0):
c = '#800000'
t = 'vector'
elif (labels[i].lower().startswith(tuple(read)) > 0):
c = '#CD853F'
t = 'read'
elif (labels[i].lower().startswith(tuple(mask)) > 0):
c = '#D2691E'
t = 'mask'
elif (labels[i].lower().startswith(tuple(bound)) > 0):
c = '#DAA520'
t = 'bound'
elif (labels[i].lower().startswith(tuple(string)) > 0):
c = '#CD5C5C'
t = 'string'
elif (labels[i].lower().startswith(tuple(flag)) > 0):
c = '#FA8072'
t = 'flag'
elif (labels[i].lower().startswith(tuple(segment_reg)) > 0):
c = '#DC143C'
t = 'segment register'
elif (labels[i].lower().startswith(tuple(misc)) > 0):
c = '#FF0000'
t = 'misc'
elif (labels[i].lower().startswith(tuple(floating_control)) > 0):
c = '#8B0000'
t = 'floating control'
elif (labels[i].lower().startswith(tuple(floating_data)) > 0):
c = '#FFC0CB'
t = 'floating data'
elif (labels[i].lower().startswith(tuple(floating_arith)) > 0):
c = '#FF69B4'
t = 'floating arith'
elif (labels[i].lower().startswith(tuple(floating_comparison)) > 0):
c = '#FF1493'
t = 'floating comparison'
elif (labels[i].lower().startswith(tuple(floating_transcendental)) >
0):
c = '#DB7093'
t = 'floating transcendental'
elif (labels[i].lower().startswith(tuple(simd_state)) > 0):
c = '#FF7F50'
t = 'simd state'
elif (labels[i].lower().startswith(tuple(mmx)) > 0):
c = '#FF4500'
t = 'mmx'
elif (labels[i].lower().startswith(tuple(sse)) > 0):
c = '#FFFF00'
t = 'sse'
elif (labels[i].lower().startswith(tuple(sse2)) > 0):
c = '#FFE4B5'
t = 'sse2'
elif (labels[i].lower().startswith(tuple(system)) > 0):
c = '#F0E68C'
t = 'system'
elif (labels[i].lower().startswith(tuple(encryption)) > 0):
c = '#E6E6FA'
t = 'encryption'
elif (labels[i].lower().startswith(tuple(mmx_data)) > 0):
c = '#DDA0DD'
t = 'mmx_data'
elif (labels[i].lower().startswith(tuple(dec_arith)) > 0):
c = '#EE82EE'
t = 'dec_arith'
elif (labels[i].lower().startswith(tuple(binary_arith)) > 0):
c = '#4B0082'
t = 'binary arith'
elif (labels[i].lower().startswith(tuple(logical)) > 0):
c = '#008000'
t = 'logical'
elif (labels[i].lower().startswith(tuple(shift)) > 0):
c = '#808000'
t = 'shift'
elif (labels[i].lower().startswith(tuple(bit_byte)) > 0):
c = '#00FFFF'
elif (labels[i].lower().startswith(tuple(control_transfer)) > 0):
c = '#00BFFF'
t = 'bit byte'
elif (labels[i].lower().startswith(tuple(data_transfer)) > 0):
c = '#0000FF'
t = 'data transfer'
elif (labels[i].lower().startswith(tuple(io)) > 0):
c = '#00FF00'
t = 'IO'
color.append(c)
type1.append(t)
output_file("Models/word2vec_some_pca.html", title="word2vec_out example")
source = ColumnDataSource(
data=dict(x=x, y=y, desc=labels, typ=type1, fill_color=color))
hover = HoverTool(tooltips=[("desc", "@desc"), ("typ", "@typ")])
p = figure(plot_width=1500,
plot_height=1000,
tools=[hover],
title="Word2Vec Plot With PCA (3 Iter)")
p.circle('x', 'y', size=10, source=source, fill_color="fill_color")
labels1 = LabelSet(x='x',
y='y',
text='desc',
level='glyph',
x_offset=5,
y_offset=5,
source=source,
render_mode='canvas')
p.add_layout(labels1)
show(p)
def make_bls_figure_elements(result, bls_source, help_source):
"""Make a line plot of a BLS result.
Parameters
----------
result : BLS.model result
BLS model result to plot
bls_source : bokeh.plotting.ColumnDataSource
Bokeh style source object for plotting BLS source
help_source : bokeh.plotting.ColumnDataSource
Bokeh style source object for rendering help button
Returns
-------
fig : bokeh.plotting.figure
Bokeh figure object
vertical_line : bokeh.models.Span
Vertical line to highlight current selected period
"""
# Build Figure
fig = figure(title='BLS Periodogram',
plot_height=340,
plot_width=450,
tools="pan,box_zoom,tap,reset",
toolbar_location="below",
border_fill_color="#FFFFFF",
x_axis_type='log',
active_drag="box_zoom")
fig.title.offset = -10
fig.yaxis.axis_label = 'Power'
fig.xaxis.axis_label = 'Period [days]'
fig.y_range = Range1d(start=result.power.min() * 0.95,
end=result.power.max() * 1.05)
fig.x_range = Range1d(start=result.period.min(), end=result.period.max())
# Add circles for the selection of new period. These are always hidden
fig.circle('period',
'power',
source=bls_source,
fill_alpha=0.,
size=6,
line_color=None,
selection_color="white",
nonselection_fill_alpha=0.0,
nonselection_fill_color='white',
nonselection_line_color=None,
nonselection_line_alpha=0.0,
fill_color=None,
hover_fill_color="white",
hover_alpha=0.,
hover_line_color="white")
# Add line for the BLS power
fig.line('period',
'power',
line_width=1,
color='#191919',
source=bls_source,
nonselection_line_color='#191919',
nonselection_line_alpha=1.0)
# Vertical line to indicate the current period
vertical_line = Span(location=0,
dimension='height',
line_color='firebrick',
line_width=3,
line_alpha=0.5)
fig.add_layout(vertical_line)
# Help button
question_mark = Text(x="period",
y="power",
text="helpme",
text_color="grey",
text_align='center',
text_baseline="middle",
text_font_size='12px',
text_font_style='bold',
text_alpha=0.6)
fig.add_glyph(help_source, question_mark)
help = fig.circle('period',
'power',
alpha=0.0,
size=15,
source=help_source,
line_width=2,
line_color='grey',
line_alpha=0.6)
tooltips = help_source.data['help'][0]
fig.add_tools(
HoverTool(tooltips=tooltips,
renderers=[help],
mode='mouse',
point_policy="snap_to_data"))
return fig, vertical_line
def make_folded_figure_elements(f, f_model_lc, f_source, f_model_lc_source,
help_source):
"""Make a scatter plot of a FoldedLightCurve.
Parameters
----------
f : lightkurve.LightCurve
Folded light curve to plot
f_model_lc : lightkurve.LightCurve
Model folded light curve to plot
f_source : bokeh.plotting.ColumnDataSource
Bokeh style source object for plotting folded light curve
f_model_lc_source : bokeh.plotting.ColumnDataSource
Bokeh style source object for plotting model folded light curve
help_source : bokeh.plotting.ColumnDataSource
Bokeh style source object for rendering help button
Returns
-------
fig : bokeh.plotting.figure
Bokeh figure object
"""
# Build Figure
fig = figure(title='Folded Light Curve',
plot_height=340,
plot_width=450,
tools="pan,box_zoom,reset",
toolbar_location="below",
border_fill_color="#FFFFFF",
active_drag="box_zoom")
fig.title.offset = -10
fig.yaxis.axis_label = 'Flux'
fig.xaxis.axis_label = 'Phase'
# Scatter point for data
fig.circle('phase',
'flux',
line_width=1,
color='#191919',
source=f_source,
nonselection_line_color='#191919',
nonselection_line_alpha=1.0,
size=0.1)
# Line plot for model
fig.step('phase',
'flux',
line_width=3,
color='firebrick',
source=f_model_lc_source,
nonselection_line_color='firebrick',
nonselection_line_alpha=1.0)
# Help button
question_mark = Text(x="phase",
y="flux",
text="helpme",
text_color="grey",
text_align='center',
text_baseline="middle",
text_font_size='12px',
text_font_style='bold',
text_alpha=0.6)
fig.add_glyph(help_source, question_mark)
help = fig.circle('phase',
'flux',
alpha=0.0,
size=15,
source=help_source,
line_width=2,
line_color='grey',
line_alpha=0.6)
tooltips = help_source.data['help'][0]
fig.add_tools(
HoverTool(tooltips=tooltips,
renderers=[help],
mode='mouse',
point_policy="snap_to_data"))
return fig
def make_lightcurve_figure_elements(lc, model_lc, lc_source, model_lc_source,
help_source):
"""Make a figure with a simple light curve scatter and model light curve line.
Parameters
----------
lc : lightkurve.LightCurve
Light curve to plot
model_lc : lightkurve.LightCurve
Model light curve to plot
lc_source : bokeh.plotting.ColumnDataSource
Bokeh style source object for plotting light curve
model_lc_source : bokeh.plotting.ColumnDataSource
Bokeh style source object for plotting model light curve
help_source : bokeh.plotting.ColumnDataSource
Bokeh style source object for rendering help button
Returns
-------
fig : bokeh.plotting.figure
Bokeh figure object
"""
# Make figure
fig = figure(title='Light Curve',
plot_height=300,
plot_width=900,
tools="pan,box_zoom,reset",
toolbar_location="below",
border_fill_color="#FFFFFF",
active_drag="box_zoom")
fig.title.offset = -10
fig.yaxis.axis_label = 'Flux (e/s)'
if lc.time_format == 'bkjd':
fig.xaxis.axis_label = 'Time - 2454833 (days)'
elif lc.time_format == 'btjd':
fig.xaxis.axis_label = 'Time - 2457000 (days)'
else:
fig.xaxis.axis_label = 'Time (days)'
ylims = [np.nanmin(lc.flux), np.nanmax(lc.flux)]
fig.y_range = Range1d(start=ylims[0], end=ylims[1])
# Add light curve
fig.circle('time',
'flux',
line_width=1,
color='#191919',
source=lc_source,
nonselection_line_color='#191919',
size=0.5,
nonselection_line_alpha=1.0)
# Add model
fig.step('time',
'flux',
line_width=1,
color='firebrick',
source=model_lc_source,
nonselection_line_color='firebrick',
nonselection_line_alpha=1.0)
# Help button
question_mark = Text(x="time",
y="flux",
text="helpme",
text_color="grey",
text_align='center',
text_baseline="middle",
text_font_size='12px',
text_font_style='bold',
text_alpha=0.6)
fig.add_glyph(help_source, question_mark)
help = fig.circle('time',
'flux',
alpha=0.0,
size=15,
source=help_source,
line_width=2,
line_color='grey',
line_alpha=0.6)
tooltips = help_source.data['help'][0]
fig.add_tools(
HoverTool(tooltips=tooltips,
renderers=[help],
mode='mouse',
point_policy="snap_to_data"))
return fig
def create_radar_plot(df):
"""Crea gráfica de radar afectando en cada tipo de calidad de agua con valores normalizados
Parameters:
df (Dataframe): Dataframe con los datos a mostrar en la visualización
Returns:
Figure: Gráfica de radar afectando en cada tipo de calidad de agua con valores normalizados
"""
def unit_poly_verts(theta, r=0.5, center=0.5):
"""Return vertices of polygon for subplot axes.
This polygon is circumscribed by a unit circle centered at center(def:(0.5, 0.5))
"""
x0, y0 = [center] * 2
verts = [(r*np.cos(t) + x0, r*np.sin(t) + y0) for t in theta]
return verts
def radar_patch(r, theta, center):
yt = (r + 0.01) * np.sin(theta) + center
xt = (r + 0.01) * np.cos(theta) + center
return xt, yt
NUM_VARS = df.Indicador.nunique() # Extraer numero de indicadores
CENTER = 0.5 # Centro del gráfico de araña
GRID_STEPS = 5 # Grid Subdivisions
theta = np.linspace(0, 2*np.pi, NUM_VARS, endpoint=False)
# rotate theta such that the first axis is at the top
theta += np.pi/2
x = [] # x-vertices
y = [] # y-vertices
# x_var_label = [] # x-vertices for variable labels
x_ticks = [0.5]*(GRID_STEPS-1) # x-vertices for circular grid ticks
y_ticks = [] # y-vertices for circular grid tick
text = list(df.Indicador.unique()) # List with variable names
#Tooltip creation
TOOLTIPS = [('Indicador', '@Indicador'),
('Valor', '@valor'),
('Valor(esc)', '@valor_map')]
hover = HoverTool(names=['radar_plt'], tooltips=TOOLTIPS)
# Create radar figure
nor_rad_pl = figure(plot_height=340, toolbar_location=None, x_range=(-0.2,1.4),
y_range=(-0.1,1.1), tools=[hover,], sizing_mode='stretch_width')
for i in range(GRID_STEPS):
verts=unit_poly_verts(theta, (GRID_STEPS-i)*0.5/GRID_STEPS, CENTER)
x.append([v[0] for v in verts])
y.append([v[1] for v in verts])
if i==0:
source = ColumnDataSource({'x':x[i]+ [CENTER],'y':y[i]+ [(GRID_STEPS-i)*0.5/GRID_STEPS+CENTER],'text':text+ ['']})
# source_test = ColumnDataSource({'x':x_var_label + [CENTER],'y':y[i]+ [(GRID_STEPS-i)*0.5/GRID_STEPS+CENTER],'text':text+ ['']})
var_labels = LabelSet(x="x",y="y",text="text",source=source, text_color=bokeh_utils.LABEL_FONT_COLOR, text_font_size='15px') # Position variable labels
nor_rad_pl.add_layout(var_labels) # Add variable labels
color='black'
else:
source = ColumnDataSource({'x':x[i]+ [CENTER],'y':y[i]+ [(GRID_STEPS-i)*0.5/GRID_STEPS+CENTER]}) #radius*i/GRID_STEPS+CENTER
color='gainsboro'
nor_rad_pl.line(x="x", y="y", source=source, line_color=color) # Create poligons
y_ticks.append(y[i][0]) # Store y-vertices grid ticks positions
for i in range(NUM_VARS):
nor_rad_pl.line(x=[CENTER,x[0][i]], y=[CENTER,y[0][i]], line_color='gainsboro') # Create grid lines from center to vertix
y_ticks.reverse()
text_labels_ticks = np.around(list(np.linspace(0, 1, GRID_STEPS, endpoint=False)), decimals=2) # Create text for grid ticks
source_labels_ticks = ColumnDataSource({'x':x_ticks,'y':y_ticks[:-1],'text':text_labels_ticks[1:]})
tick_labels = LabelSet(x="x",y="y",text="text",source=source_labels_ticks, text_color=bokeh_utils.LABEL_FONT_COLOR, text_font_size='14px') # Position grid tick labels
nor_rad_pl.add_layout(tick_labels) # Add grid tick labels
clist = [] # Cluster data list for spider pl patches
colors = bokeh_utils.LINE_COLORS_PALETTE
DATA_MIN = -2
DATA_MAX = 3
for i, cluster in enumerate(df.cluster.unique()):
clist.append(df[df['cluster'] == cluster])
xt, yt = radar_patch((clist[i].valor-DATA_MIN)/(DATA_MAX-DATA_MIN) * 0.5, theta, CENTER)
clist[i]=clist[i].assign(**{'xt':xt, 'yt':yt, 'valor_map':(clist[i].valor-DATA_MIN)/(DATA_MAX-DATA_MIN)})
nor_rad_pl.patch(x='xt', y='yt', fill_alpha=0.15, fill_color=colors[i], line_color=colors[i], legend_label=f'Cluster {i}', source=ColumnDataSource(clist[i]))
nor_rad_pl.circle(x='xt', y='yt', size=15, fill_color=None, line_color=None ,source=ColumnDataSource(clist[i]), name='radar_plt')
nor_rad_pl.legend.location = 'bottom_left'
nor_rad_pl.legend.orientation = 'vertical'
nor_rad_pl.legend.click_policy = 'hide'
nor_rad_pl.legend.background_fill_alpha = 0
nor_rad_pl.legend.border_line_alpha = 0
nor_rad_pl.xgrid.visible = False
nor_rad_pl.ygrid.visible = False
nor_rad_pl.xaxis.visible = False
nor_rad_pl.yaxis.visible = False
nor_rad_pl.min_border = 0
nor_rad_pl.outline_line_color = None
nor_rad_pl.border_fill_color = bokeh_utils.BACKGROUND_COLOR
nor_rad_pl.background_fill_color = bokeh_utils.BACKGROUND_COLOR
return nor_rad_pl
click_policy='hide',
title="Click on States to Switch ON/OFF",
title_text_font_style="bold")
legend2 = Legend(items=legend_it[17:33],
location=(10, 0),
click_policy='hide',
title="Click on States to Switch ON/OFF",
title_text_font_style="bold")
p.add_layout(legend1, 'right')
p.add_layout(legend2, 'right')
cases_summary['day'] = cases_summary['day'].astype('str')
source = ColumnDataSource(cases_summary)
hover = HoverTool(line_policy='next')
hover.tooltips = [
('Date', '@x{%F}'),
('Cases', '@y{0000}') # @$name gives the value corresponding to the legend
]
hover.formatters = {'@x': 'datetime'}
p.add_tools(hover)
citation = Label(x=0,
y=0,
x_units='screen',
y_units='screen',
text='Last Updated : {}'.format(latest_date),
render_mode='css',
text_font_size='12px')
p.add_layout(citation, 'above')
def make_lightcurve_figure_elements(lc, lc_source, ylim_func=None):
"""Make the lightcurve figure elements.
Parameters
----------
lc : LightCurve
Lightcurve to be shown.
lc_source : bokeh.plotting.ColumnDataSource
Bokeh object that enables the visualization.
Returns
----------
fig : `bokeh.plotting.figure` instance
step_renderer : GlyphRenderer
vertical_line : Span
"""
if lc.mission == 'K2':
title = "Lightcurve for {} (K2 C{})".format(lc.label, lc.campaign)
elif lc.mission == 'Kepler':
title = "Lightcurve for {} (Kepler Q{})".format(lc.label, lc.quarter)
elif lc.mission == 'TESS':
title = "Lightcurve for {} (TESS Sec. {})".format(lc.label, lc.sector)
else:
title = "Lightcurve for target {}".format(lc.label)
fig = figure(title=title,
plot_height=340,
plot_width=600,
tools="pan,wheel_zoom,box_zoom,tap,reset",
toolbar_location="below",
border_fill_color="whitesmoke")
fig.title.offset = -10
fig.yaxis.axis_label = 'Flux (e/s)'
fig.xaxis.axis_label = 'Time (days)'
try:
if (lc.mission == 'K2') or (lc.mission == 'Kepler'):
fig.xaxis.axis_label = 'Time - 2454833 (days)'
elif lc.mission == 'TESS':
fig.xaxis.axis_label = 'Time - 2457000 (days)'
except AttributeError: # no mission keyword available
pass
if ylim_func is None:
ylims = get_lightcurve_y_limits(lc_source)
else:
ylims = ylim_func(lc)
fig.y_range = Range1d(start=ylims[0], end=ylims[1])
# Add step lines, circles, and hover-over tooltips
fig.step('time',
'flux',
line_width=1,
color='gray',
source=lc_source,
nonselection_line_color='gray',
nonselection_line_alpha=1.0)
circ = fig.circle('time',
'flux',
source=lc_source,
fill_alpha=0.3,
size=8,
line_color=None,
selection_color="firebrick",
nonselection_fill_alpha=0.0,
nonselection_fill_color="grey",
nonselection_line_color=None,
nonselection_line_alpha=0.0,
fill_color=None,
hover_fill_color="firebrick",
hover_alpha=0.9,
hover_line_color="white")
tooltips = [("Cadence", "@cadence"),
("Time ({})".format(lc.time_format.upper()), "@time{0,0.000}"),
("Time (ISO)", "@time_iso"), ("Flux", "@flux"),
("Quality Code", "@quality_code"),
("Quality Flag", "@quality")]
fig.add_tools(
HoverTool(tooltips=tooltips,
renderers=[circ],
mode='mouse',
point_policy="snap_to_data"))
# Vertical line to indicate the cadence
vertical_line = Span(location=lc.time[0],
dimension='height',
line_color='firebrick',
line_width=4,
line_alpha=0.5)
fig.add_layout(vertical_line)
return fig, vertical_line
def distribution_bokeh(critere_correction,
mode_correction,
prob,
k_erreurs,
nbre_sommets_GR,
rep_,
bool_data_revue):
"""
visualiser les distributions de moy_dc, moy_dh, correl_dc_dh, cumul_dh.
"""
rep, rep_dist = "", "";
df_kerrs = None;
if not bool_data_revue:
rep = rep_ + "/" \
+ critere_correction +"_sommets_GR_" + str(nbre_sommets_GR) + "/" \
+ mode_correction + "/" \
+ DATA_P_REP + str(prob);
rep_dist = rep + "/" + "distribution" + "/";
df_kerrs = create_dataframe(rep_dist, k_erreurs);
else:
rep = rep_ + "/" \
+ mode_correction + "/" \
+ critere_correction + "/" \
+ DATA_P_REP + str(prob);
rep_dist = rep + "/" + "distribution" + "/";
df_kerrs = create_dataframe_data_revue(rep_dist, k_erreurs);
# configuration figure
output_file(rep_dist+"../../visualisation/"+"distribution_dashboard.html");
TOOLS = "pan,wheel_zoom,box_zoom,reset,save,box_select,lasso_select";
p_cols = []
for ind, k_erreur in enumerate(k_erreurs):
p_cols_k = [];
###### moy_dc
mu = df_kerrs["moy_dc_"+str(k_erreur)].mean();
sigma = df_kerrs["moy_dc_"+str(k_erreur)].std();
title, xlabel, ylabel = title_xlabel_ylabel_figure("moy_dc", k_erreur,
mu, sigma)
arr_hist, edges = np.histogram(df_kerrs['moy_dc_'+str(k_erreur)],
bins=int(max(df_kerrs['moy_dc_'+str(k_erreur)]) / 2),
range=[min(df_kerrs['moy_dc_'+str(k_erreur)]),
max(df_kerrs['moy_dc_'+str(k_erreur)])]
)
df_dc_k = pd.DataFrame({"moy_dc":arr_hist,
'left':edges[:-1],
'right':edges[1:]})
# Create the blank plot
p_dc = figure(plot_height = HEIGHT, plot_width = WIDTH,
title = title,
x_axis_label = xlabel,
y_axis_label = ylabel,
tools = TOOLS
)
# Add a quad glyph
src = ColumnDataSource(df_dc_k)
p_dc.quad(source = src, bottom=0, top='moy_dc',
left='left', right='right',
fill_color='red', line_color='black')
# Add a hover tool referring to the formatted columns
hover = HoverTool(tooltips = [('correction distance', '@moy_dc'),
('(min_dc, max_dc)', '($x, $y)') ])
# Style the plot
# p_dc = style(p_dc)
# TODO comment remplacer le nombre par un pourcentage
# tickers = np.around(arr_hist * 100 / df_kerrs['moy_dc_'+str(k_erreur))
# p_dc.yaxis.ticker = ['{:3.2f}%'.format(
# x*100/df_kerrs["moy_dc_"+str(k_erreur)].count()) \
# for x in p_dc.yaxis.get_yticks()]
# p_dc.yaxis[0].formatter = NumeralTickFormatter(format="0.0%")
# def ticker():
# return '{:3.2f}%'.format(tick * 100/df_kerrs["moy_dc_"+str(k_erreur)].count())
# p_dc.yaxis.formatter = FuncTickFormatter(
# code="""
# return tick * 100/df_kerrs["moy_dc_"+str(k_erreur)].count()
# """)
# Add the hover tool to the graph
p_dc.add_tools(hover)
p_cols_k.append(p_dc)
###### moy_dh
mu = df_kerrs["moy_dh_"+str(k_erreur)].mean();
sigma = df_kerrs["moy_dh_"+str(k_erreur)].std();
title, xlabel, ylabel = title_xlabel_ylabel_figure("moy_dh", k_erreur,
mu, sigma)
arr_hist, edges = np.histogram(df_kerrs['moy_dh_'+str(k_erreur)],
bins=int(max(df_kerrs['moy_dh_'+str(k_erreur)]) / 2),
range=[min(df_kerrs['moy_dh_'+str(k_erreur)]),
max(df_kerrs['moy_dh_'+str(k_erreur)])]
)
df_dh_k = pd.DataFrame({"moy_dh":arr_hist,
'left':edges[:-1],
'right':edges[1:]})
# Create the blank plot
p_dh = figure(plot_height = HEIGHT, plot_width = WIDTH,
title = title,
x_axis_label = xlabel,
y_axis_label = ylabel,
tools = TOOLS)
# Add a quad glyph
src = ColumnDataSource(df_dh_k)
p_dh.quad(source = src, bottom=0, top='moy_dh',
left='left', right='right',
fill_color='red', line_color='black')
# Add a hover tool referring to the formatted columns
hover = HoverTool(tooltips = [('correction distance', '@moy_dh'),
('(min_dc, max_dh)', '($x, $y)') ])
# Style the plot
# p_dh = style(p_dh)
# Add the hover tool to the graph
p_dh.add_tools(hover)
p_cols_k.append(p_dh)
#### correl_dc_dh
df_corr_k = df_kerrs[['moy_dh_'+str(k_erreur), 'moy_dc_'+str(k_erreur),
'correl_dc_dh_'+str(k_erreur)]];
df_corr_k_sorted = df_corr_k.sort_values(
by='correl_dc_dh_'+str(k_erreur),
axis=0, ascending=True);
df_corr_k_sorted['cumsum_k'] = df_corr_k_sorted['correl_dc_dh_'+str(k_erreur)].cumsum(axis=0);
src = ColumnDataSource(df_corr_k_sorted)
title = "fonction de repartition de \n" \
+"correlation entre moy_dc et moy_dh \n pour " \
+str(k_erreur)+" cases modifiees."
title, xlabel, ylabel = title_xlabel_ylabel_figure("correl", k_erreur,
0, 0)
p_corr_k = figure(plot_height = HEIGHT, plot_width = WIDTH,
title = title,
x_axis_label = xlabel,
y_axis_label = ylabel,
tools = TOOLS)
p_corr_k.line(source=src,
x='correl_dc_dh_'+str(k_erreur),
y='cumsum_k')
p_cols_k.append(p_corr_k)
#### cumul_correl_dc_dh
df_corr_k_sorted = df_corr_k.sort_values(
by='correl_dc_dh_'+str(k_erreur),
axis=0, ascending=True);
df_corr_k_sorted["nb_graphe_correl<x"] = \
df_corr_k_sorted["moy_dh_"+str(k_erreur)]\
.apply( lambda x: \
df_corr_k_sorted["correl_dc_dh_"\
+str(k_erreur)][df_corr_k_sorted["correl_dc_dh_"\
+str(k_erreur)] < x].count()/\
df_corr_k_sorted["correl_dc_dh_"\
+str(k_erreur)].count())
src = ColumnDataSource(df_corr_k_sorted)
title = "cumulative moy_dh pour \n"+str(k_erreur)+" cases modifiees";
title, xlabel, ylabel = title_xlabel_ylabel_figure("cumul_correl",
k_erreur, 0, 0)
p_corr_sup_x_k = figure(plot_height = HEIGHT, plot_width = WIDTH,
title = title,
x_axis_label = xlabel,
y_axis_label = ylabel,
tools = TOOLS)
p_corr_sup_x_k.line(source=src,
x="correl_dc_dh_"+str(k_erreur),
y="nb_graphe_correl<x")
p_cols_k.append(p_corr_sup_x_k)
p_cols.append(p_cols_k);
p = gridplot(p_cols)
show(p)
return df_kerrs
x_start=initial_votes + max(pokemon_votes)*0.05, x_end=initial_votes,
y_start=y_coord, y_end=y_coord)
p_overall.add_layout(arrow_overall)
legend = Legend(items=[
LegendItem(label='1', renderers=[r_overall], index=6),
LegendItem(label='2', renderers=[r_overall], index=37),
LegendItem(label='3', renderers=[r_overall], index=1),
LegendItem(label='4', renderers=[r_overall], index=10),
LegendItem(label='5', renderers=[r_overall], index=2),
LegendItem(label='6', renderers=[r_overall], index=14),
LegendItem(label='7', renderers=[r_overall], index=8),
], title='Generation', location='bottom_right')
p_overall.add_layout(legend)
hover_overall = HoverTool(mode='hline')
hover_overall.tooltips = """
<table style="width:175px">
<tr>
<th>@name</th>
<td rowspan=4><image src=@sprite_source alt="" width="75"/></td>
</tr>
<tr>
<td><strong>Generation: </strong>@generation</td>
</tr>
<tr>
<td><strong>Votes: </strong>@votes</td>
</tr>
<tr>
<td><strong>Ranking: </strong>@ranking_overall</td>
</tr>
MARKERS = [
"o", "v", "^", "<", ">", "1", "2", "3", "4", "8", "s", "p", "P", "*", "h",
"H", "+", "x", "X", "D", "d"
]
COLORS = Category20[
19] #["red", "yellow", "blue", "green", "rosybrown","darkorange", "fuchsia", "grey", ]
TOOLS = [
PanTool(),
BoxZoomTool(),
WheelZoomTool(),
UndoTool(),
RedoTool(),
ResetTool(),
SaveTool(),
HoverTool(tooltips=[("Price", "$y"), ("Time", "$x")])
]
NAME_RESULT_SHOW_VARS = "resultat_show_variables_pi_plus_{}_pi_minus_{}.html"
#------------------------------------------------------------------------------
# definitions of functions
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
# definitions of functions
#------------------------------------------------------------------------------
# _____________________________________________________________________________
#
# get local variables and turn them into dataframe --> debut
* When a circle is clicked, the corresponding month is displayed in the right-hand-side plot.
Interesting points to note:
* The primary immediately tells us that the period between June-September is the busiest time of the year for the preserve. Sensors get
triggered with high frequency, and the traffic consists mostly of motorcycles(type 1) and light cars(type 2). Heavier vehicles are relatively
sparse in comparison.
* In the off-seasons, most of the traffic consists of ranger vehicles(type 2P).
* Traffic generally drops during the middle of the week, and is higher during the weekends.
""",
width=1200, height=420)
curdoc().add_root(pre_intro)
##### PLOT FOR EACH MONTH #####################################################
monthView = figure(x_range=[0,13], tools=['wheel_zoom', 'pan', 'tap', 'reset'], title="Monthly Plot of Traffic by Car Type")
monthHover = HoverTool(tooltips=[('Car Type', '@cartype'), ('Count', '$y{00000}'), ('Month', '@month')])
monthView.add_tools(monthHover)
monthLines = monthView.multi_line(xs="x", ys="y", line_color="colors", line_width=3, alpha="alpha", legend="cartype", source=monthLineCDS)
monthCircles = monthView.circle(x="x", y="y", size=10, fill_color="colors", line_color="colors", alpha="alpha", source=monthCircleCDS)
monthView.xaxis.axis_label = "Month"
monthView.yaxis.axis_label = "Traffic activity"
monthView.xaxis.ticker = []
monthView.min_border_bottom=100;
monthCircles.selection_glyph = Circle(fill_alpha=0.8, line_alpha=0.8)
monthCircles.nonselection_glyph = Circle(fill_alpha=0.3, line_alpha=0.3)
monthLines.data_source.on_change('selected', line_callback)
monthCircles.data_source.on_change('selected', circle_callback)
##### PLOT FOR A WEEK #########################################################
def plot_bar_Perf_t_all_algos(df_ra_pri, rate, price, t):
"""
plot the Perf_t at each learning step for all states
considering all scenarios and all algorithms.
each figure is for one state, one scenario, one prob_Ci, one learning_rate
and one price.
Perf_t = \sum\limits_{1\leq i \leq N} ben_i-cst_i
x-axis : one time t
y-axis : Perf_t
"""
algos = df_ra_pri["algo"].unique()
nb_instances = df_ra_pri.num_instance.unique().tolist()
num_pl_is = df_ra_pri.pl_i.unique().tolist()
tup_legends = []
dico_algo_instance = dict()
dico_algo_instance["pl_i"] = []
dico_algo_instance["k"] = []
dico_algo_instance["ben"] = []
dico_algo_instance["cst"] = []
dico_algo_instance["num_instance"] = []
dico_algo_instance["algo"] = []
for algo in algos:
mask_algo = (df_ra_pri.algo == algo)
df_ra_pr_al = df_ra_pri[mask_algo]
# delete rows with nan values of columns = [ben, cst]
df_ra_pr_al = df_ra_pr_al[df_ra_pr_al['ben'].notna()
& df_ra_pr_al['cst'].notna()]
# for each instance, select the k_stop and put it to a new dataframe.
num_instances = df_ra_pr_al.num_instance.unique().tolist()
for num_instance in num_instances:
for num_pl_i in num_pl_is:
mask_inst_pl_i = (df_ra_pr_al.pl_i==num_pl_i) \
& (df_ra_pr_al.num_instance==num_instance)
k_max = df_ra_pr_al[mask_inst_pl_i].k.max()
mask_inst_pl_i_k_max = (df_ra_pr_al.pl_i==num_pl_i) \
& (df_ra_pr_al.num_instance==num_instance) \
& (df_ra_pr_al.k==k_max)
index = df_ra_pr_al[mask_inst_pl_i_k_max].index[0]
ben = df_ra_pr_al[mask_inst_pl_i].loc[index, 'ben']
cst = df_ra_pr_al[mask_inst_pl_i].loc[index, 'cst']
dico_algo_instance["pl_i"].append(num_pl_i)
dico_algo_instance["k"].append(k_max)
dico_algo_instance["ben"].append(ben)
dico_algo_instance["cst"].append(cst)
dico_algo_instance["num_instance"].append(num_instance)
dico_algo_instance["algo"].append(algo)
df = pd.DataFrame.from_dict(dico_algo_instance)
df["Vi"] = df["ben"] - df["cst"]
df_res = df.groupby(['algo'])['Vi'].aggregate([np.sum, np.mean, np.std])\
.reset_index()
TOOLS[7] = HoverTool(
tooltips=[("algo", "@algo"), ("mean",
"@mean"), ("sum", "@sum"), ("std",
"@std")])
idx = df_res.algo.unique().tolist()
cols = ["algo", "mean", "std", "sum"]
px = figure(x_range=idx,
y_range=(df_res[cols[1]].values.min(),
df_res[cols[1]].values.max()),
plot_height=int(HEIGHT * MULT_HEIGHT),
plot_width=int(WIDTH * MULT_WIDTH),
tools=TOOLS,
toolbar_location="above")
title = "Average of Vi over 50 executions (rate:{}, price={})".format(
rate, price)
px.title.text = title
source = ColumnDataSource(data=df_res)
width = 0.1 #0.5
px.vbar(x=dodge('algo', -0.0, range=px.x_range),
top=cols[1],
width=width,
source=source,
color="#2E8B57",
legend_label=cols[1])
# px.vbar(x=dodge('algo', -0.3+1*width, range=px.x_range), top=cols[2],
# width=width, source=source,
# color="#718dbf", legend_label=cols[2])
# px.vbar(x=dodge('t', -0.3+2*width, range=px.x_range), top=cols[3],
# width=width, source=source,
# color="#e84d60", legend_label=cols[3])
px.x_range.range_padding = width
px.xgrid.grid_line_color = None
px.legend.location = "top_left"
px.legend.orientation = "horizontal"
px.xaxis.axis_label = "t_periods"
px.yaxis.axis_label = "values"
return px
ax_limits['x'][1], #bounds=ax_limits['x']
)
# #p_state_covid.xaxis[0].ticker.desired_num_ticks =round(np.busday_count(np.datetime64(source.data['date'].min(),'D'),np.datetime64(source.data['date'].max(),'D'))/3); # prefer number of labels (divide by 7 for week)
p_state_covid.xaxis.major_label_orientation = -np.pi / 3 # slant the labels
dtformat = "%b-%d"
p_state_covid.xaxis.formatter = formatter = DatetimeTickFormatter( # Always show the same date formatting regardless of zoom
days=dtformat,
months=dtformat,
hours=dtformat,
minutes=dtformat)
# Add legend
p_state_covid.legend.location = "top_left"
# Add a hover tool
hover = HoverTool()
hover.tooltips = [
#('Type', "$name"),
('', '$name: @$name{0,0.} on @date{%a-%b-%d}'),
]
# hover.mode = 'vline'
hover.formatters = {
'@date': 'datetime', # use 'datetime' formatter for '@date' field
'$name': 'printf' # use 'printf' formatter for the name of the column
}
hover.renderers = glyphs
p_state_covid.add_tools(hover)
# # Extra formatting
# for ax in p_state_covid.yaxis:
# ax.axis_label_text_font_style = 'bold'
def plot_bar_moyVi_4_one_algo_many_state_instance(df_algo, algo):
"""
bar plot Vi mean for one algo knowing states and instances
plot is the bar plot with key is (instance, stateX) (X={1,2,3})
on x-axis, there are instance and state
on y-axis, there is Vi mean (moyVi)
"""
# order df_algo by num_instance
cols = ["num_instance", "state_i"]
x = list(map(tuple, list(df_algo[cols].values)))
moy_Vi = list(df_algo["moy_Vi"])
TOOLS[7] = HoverTool(tooltips=[
("nb_players", "@nb_players"),
("id_players", "@id_players"),
("state_i", "@state_i"),
("moy_Vi", "@moy_Vi"),
("instance", "@num_instance"),
("algo", "@algo"),
])
print("HEIGHT={},MULT_HEIGHT{},WIDTH={},MULT_WIDTH={}".format(
HEIGHT, MULT_HEIGHT, WIDTH, MULT_WIDTH))
px = figure(x_range=FactorRange(*x),
plot_height=int(HEIGHT * MULT_HEIGHT),
plot_width=int(WIDTH * MULT_WIDTH),
title="mean of Vi by instances for {}".format(algo),
toolbar_location="above",
tools=TOOLS)
# px= figure(x_range=FactorRange(*x),
# plot_height=int(500),
# plot_width = int(1500),
# title="mean of Vi by instances for {}".format(algo),
# toolbar_location="above", tools=TOOLS)
data = dict(x=x,
moy_Vi=moy_Vi,
nb_players=df_algo.nb_players.tolist(),
id_players=df_algo.id_players.tolist(),
state_i=df_algo.state_i.tolist(),
num_instance=df_algo.num_instance.tolist(),
algo=df_algo.algo.tolist())
source = ColumnDataSource(data=data)
px.vbar(x='x',
top='moy_Vi',
width=0.9,
source=source,
fill_color=factor_cmap('x',
palette=Category20[20],
factors=list(df_algo.state_i.unique()),
start=1,
end=2))
px.y_range.start = df_algo.moy_Vi.min() # 0
px.x_range.range_padding = 0.1
px.xaxis.major_label_orientation = 1
px.xgrid.grid_line_color = None
px.xaxis.axis_label = 'instances'
px.yaxis.axis_label = 'moy_Vi'
return px
def create_plot(df, title, energy_unit, ylimit=None):
"""
:param df:
:param title: string, plot title
:param energy_unit: string, the unit of energy used in the database/model
:param ylimit: float/int, upper limit of heatmap colorbar; optional
:return:
"""
if df.empty:
return figure()
# Round hours and convert to string (required for x-axis)
# TODO: figure out a way to handle subhourly data properly!
df["hour_of_day"] = df["hour_of_day"].map(int).map(str)
# Get list of hours and months (used in xrange/yrange)
hours = list(df["hour_of_day"].unique())
months = list(reversed(df["month"].unique()))
# Set up color mapper
# colors = ["#75968f", "#a5bab7", "#c9d9d3", "#e2e2e2", "#dfccce",
# "#ddb7b1", "#cc7878", "#933b41", "#550b1d"]
colors = list(reversed(Reds[9]))
high = ylimit if ylimit is not None else df.scheduled_curtailment_mwh.max()
mapper = LinearColorMapper(palette=colors,
low=df.scheduled_curtailment_mwh.min(),
high=high)
# Set up the figure
plot = figure(
plot_width=800,
plot_height=500,
tools=["pan", "reset", "zoom_in", "zoom_out", "save", "help"],
toolbar_location="below",
x_axis_location="above",
title=title,
x_range=hours,
y_range=months,
)
# Plot heatmap rectangles
hm = plot.rect(x="hour_of_day",
y="month",
width=1,
height=1,
source=df,
fill_color={
'field': 'scheduled_curtailment_mwh',
'transform': mapper
},
line_color="white")
# Add color bar legend
color_bar = ColorBar(color_mapper=mapper,
major_label_text_font_size="7pt",
ticker=BasicTicker(desired_num_ticks=len(colors)),
formatter=NumeralTickFormatter(format="0,0"),
label_standoff=12,
border_line_color=None,
location=(0, 0))
plot.add_layout(color_bar, 'right')
# Format Axes (labels, number formatting, range, etc.)
plot.xaxis.axis_label = "Hour Ending"
plot.yaxis.axis_label = "Month"
plot.grid.grid_line_color = None
plot.axis.axis_line_color = None
plot.axis.major_tick_line_color = None
plot.axis.major_label_standoff = 0
# Add HoverTool
hover = HoverTool(tooltips=[
("Month", "@month"), ("Hour", "@hour_of_day"),
("Curtailment", "@scheduled_curtailment_mwh{0,0} %s" % energy_unit)
],
renderers=[hm],
toggleable=True)
plot.add_tools(hover)
return plot
def plot_bar_moyVi_4_algo_state(df_algo_instance_state_moyVi):
"""
for each row of plot, draw a bar plot of Vi mean for all algos.
the bar plot has algo and state on x-axis ie key = (algo, stateX) (X={1,2,3})
and moyVi on y-axis
Parameters
----------
df_algo_instance_state_moyVi : TYPE
DESCRIPTION.
Returns
-------
None.
"""
dico_pxs = dict()
cols = ["algo", "state_i"]
df_groupby_algo_state_i = df_algo_instance_state_moyVi\
.groupby(cols)["moy_Vi"]\
.aggregate([np.sum, np.mean, np.std])\
.reset_index()
df_groupby_algo_state_i.rename(columns={
"mean": "moy_Vi",
"sum": "sum_Vi",
"std": "std_Vi"
},
inplace=True)
x = list(map(tuple, list(df_groupby_algo_state_i[cols].values)))
moy_Vi = list(df_groupby_algo_state_i["moy_Vi"])
TOOLS[7] = HoverTool(tooltips=[
("state_i", "@state_i"),
("moy_Vi", "@moy_Vi"),
("sum_Vi", "@sum_Vi"),
("std_Vi", "@std_Vi"),
("algo", "@algo"),
])
px = figure(x_range=FactorRange(*x),
plot_height=int(HEIGHT * MULT_HEIGHT),
plot_width=int(WIDTH * MULT_WIDTH),
title="mean of Vi by algorithm and states",
toolbar_location="above",
tools=TOOLS)
data = dict(x=x,
moy_Vi=moy_Vi,
sum_Vi=df_groupby_algo_state_i.sum_Vi.tolist(),
std_Vi=df_groupby_algo_state_i.std_Vi.tolist(),
state_i=df_groupby_algo_state_i.state_i.tolist(),
algo=df_groupby_algo_state_i.algo.tolist())
source = ColumnDataSource(data=data)
px.vbar(x='x', top='moy_Vi', width=0.9, source=source,
fill_color=factor_cmap('x',
palette=Category20[20],
factors=list(df_groupby_algo_state_i\
.state_i.unique()),
start=1, end=2))
px.y_range.start = df_groupby_algo_state_i.moy_Vi.min() # 0
px.x_range.range_padding = 0.1
px.xaxis.major_label_orientation = 1
px.xgrid.grid_line_color = None
px.xaxis.axis_label = 'algorithms'
px.yaxis.axis_label = 'moy_Vi'
col_px = column(px)
col_px = column(children=[col_px], sizing_mode='stretch_both')
return col_px
def setup_plot(
self,
x_axis_type="linear",
y_axis_type="linear",
x_flip=False,
y_flip=False,
):
# Set up the plot
self.plot = figure(
plot_height=620,
min_width=600,
title="",
x_axis_type=x_axis_type,
y_axis_type=y_axis_type,
tools="",
sizing_mode="stretch_both",
)
# Enable Bokeh tools
self.plot.add_tools(PanTool(), TapTool(), ResetTool())
# Axes orientation and labels
self.plot.x_range.flipped = x_flip
self.plot.y_range.flipped = y_flip
self.plot.xaxis.axis_label = self.xaxis.value
self.plot.yaxis.axis_label = self.yaxis.value
# Plot the data
self.plot.circle(
x="x",
y="y",
source=self.source,
size="size",
color=linear_cmap(field_name="color",
palette=Viridis256,
low=0,
high=1),
line_color=None,
)
# -- HACKZ --
# Update the plot element in the HTML layout
if hasattr(self.parent, "layout"):
self.parent.layout.children[0].children[-1] = self.plot
# Make the cursor a grabber when panning
code_pan_start = """
Bokeh.grabbing = true
var elm = document.getElementsByClassName('bk-canvas-events')[0]
elm.style.cursor = 'grabbing'
"""
code_pan_end = """
if(Bokeh.grabbing) {
Bokeh.grabbing = false
var elm = document.getElementsByClassName('bk-canvas-events')[0]
elm.style.cursor = 'grab'
}
"""
self.plot.js_on_event("panstart", CustomJS(code=code_pan_start))
self.plot.js_on_event("panend", CustomJS(code=code_pan_end))
# Add a hover tool w/ a pointer cursor
code_hover = """
if((Bokeh.grabbing == 'undefined') || !Bokeh.grabbing) {
var elm = document.getElementsByClassName('bk-canvas-events')[0]
if (cb_data.index.indices.length > 0) {
elm.style.cursor = 'pointer'
Bokeh.pointing = true
} else {
if((Bokeh.pointing == 'undefined') || !Bokeh.pointing)
elm.style.cursor = 'grab'
else
Bokeh.pointing = false
}
}
"""
self.plot.add_tools(
HoverTool(
callback=CustomJS(code=code_hover),
tooltips=[("TIC ID", "@ticid")],
))
# source = ColumnDataSource(sample)
# source = ColumnDataSource(sample)
d = dict(
one=sample['one'],
two=sample['two'],
color=colors,
Label=sample['Label'],
Metadata_Plate=sample['Metadata_Plate'],
Metadata_Well=sample['Metadata_Well'],
Metadata_FieldID=sample['Metadata_FieldID'],
# actual_image_number=sample['actual_image_number'],
ObjectNumber=sample['ObjectNumber'])
source = ColumnDataSource(data=d)
hover = HoverTool()
hover.tooltips = [
('Label', '@Label'),
('Metadata_Plate', '@Metadata_Plate'),
('Metadata_Well', '@Metadata_Well'),
('Metadata_FieldID', '@Metadata_FieldID'),
('ObjectNumber', '@ObjectNumber'),
]
p = figure(tools="tap,reset", tooltips=hover.tooltips)
p.circle(x='one', y='two', source=source, size=2, color='color')
p.title.text = 'TSNE - Applied on Mito features of single cells'
p.xaxis.axis_label = 'one'
p.yaxis.axis_label = 'two'
plot_width=800,
plot_height=600,
title='Car with Top HorsePower',
x_axis_label='Horse Power')
# Render glyph
p.hbar(
y='Car',
right='Horsepower',
left=0,
height=0.4,
color='blue',
fill_alpha=0.5,
source=source,
)
# hover tools
hover = HoverTool()
hover.tooltips = """
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0/css/materialize.min.css">
<div class="">
<h3>@Car</h3>
<div><strong>Price:</strong>@Price</div>
<div><strong>HP:</strong>@Horsepower</div>
<div><img src="@Image" class="circle" alt = "" width="200"/></div>
</div>
"""
p.add_tools(hover)
# show result
# show(p)
# save file
def __init__(self, log_level=logutil.logging.NOTSET, **figure_dict):
# set logging level to user-specified level
log.setLevel(log_level)
# Set the location for the figure tools
fig_tool_loc = figure_dict.get('toolbar_location', 'right')
# Set up the actual figure tools for use
# If hover tooltips are to be used, they are appended below
self.fig = figure(tools=FIGURE_TOOLS_BASE,
toolbar_location=fig_tool_loc)
# Basic figure attributes
self.fig.xaxis.axis_label = figure_dict.get('x_label', '')
self.fig.yaxis.axis_label = figure_dict.get('y_label', '')
self.fig.title.text = figure_dict.get('title', '')
self.fig.background_fill_color = figure_dict.get(
'background_fill_color', 'gainsboro')
self.fig.background_fill_alpha = figure_dict.get(
'background_fill_alpha', 0.5)
# Determine if the hover tooltips should be turned off
use_hover_tips = figure_dict.get('use_hover_tips', True)
# If hover tooltips are desired, set up the tips and add the hover tool
# to the figure tools
if use_hover_tips:
# Append any user requested tooltips to the base set
user_tips = figure_dict.get('hover_tips', [])
hover_fig = HoverTool()
hover_fig.tooltips = HOVER_BASIC_TIPS + user_tips
self.fig.add_tools(hover_fig)
# Do not set up defaults for these at this time
if 'x_range' in figure_dict:
self.fig.x_range = figure_dict.get('x_range')
if 'y_range' in figure_dict:
self.fig.y_range = figure_dict.get('y_range')
if 'xstart' in figure_dict:
self.fig.x_range.start = figure_dict.get('xstart')
if 'ystart' in figure_dict:
self.fig.y_range.start = figure_dict.get('ystart')
self.fig.grid.grid_line_color = figure_dict.get(
'grid_line_color', 'white')
# These attributes are not for the figure, but are styling attributes
# used for the "shape" glyphs. They may be set to non-default values when
# the build_glyph() routine is invoked.
self.glyph_color = 'blue'
self.color = 'blue'
self.size = 10
self.legend_group = ''
self.legend_label = ''
self.fill_alpha = 0.5
self.line_alpha = 0.5
self.line_width = 1
self.fig.legend.location = 'top-right'
self.fill_color = 'gainsboro'
self.angle = 0.0
self.text_size = '10px'
# This value is set so the functionality is always active - this allows
# the user click on an item in the legend and turn on/off the display of
# that particular dataset. NOTE: This functionality does not work for
# 'legend_group' (yet) according to Bokeh documentation.
self.fig.legend.click_policy = 'hide'
def __init__(self, dataset, parameters):
self.dataset = dataset
# Set up the controls
self.specials = Selector(
name="Specials",
kind="specials",
css_classes=["specials"],
entries={
"Color-magnitude diagram": "cmd",
"Period vs. radius": "pr",
"Period vs. transit duration": "pdt",
},
default="Color-magnitude diagram",
)
self.data = Selector(
name="Datasets",
kind="datasets",
css_classes=["data"],
entries={"TOI Catalog": "toi", "Confirmed Planets": "confirmed"},
default="Confirmed Planets",
)
self.xaxis = Selector(
name="Build-Your-Own",
kind="parameters",
css_classes=["build-your-own"],
entries=parameters,
default="ra",
title="X Axis",
)
self.yaxis = Selector(
kind="parameters",
css_classes=["build-your-own"],
entries=parameters,
default="dec",
title="Y Axis",
)
self.size = Selector(
name="Sides",
kind="parameters",
css_classes=["sides"],
entries=parameters,
default="dist",
title="Marker Size",
none_allowed=True,
)
self.color = Selector(
kind="parameters",
css_classes=["sides"],
entries=parameters,
default="dist",
title="Marker Color",
none_allowed=True,
)
# Set up the plot
self.source = ColumnDataSource(
data=dict(x=[], y=[], size=[], color=[])
)
self.plot = figure(
plot_height=600,
plot_width=700,
title="",
tooltips=[("TIC ID", "@ticid")],
sizing_mode="scale_both",
)
self.plot.circle(
x="x",
y="y",
source=self.source,
size="size",
color=linear_cmap(
field_name="color", palette=Viridis256, low=0, high=1
),
line_color=None,
)
self.plot.add_tools(
BoxSelectTool(),
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
PolySelectTool(),
TapTool(),
WheelZoomTool(),
WheelPanTool(),
ZoomInTool(),
ZoomOutTool(),
HoverTool(),
CrosshairTool(),
)
# Register the callback
for control in [
self.specials,
self.data,
self.xaxis,
self.yaxis,
self.size,
self.color,
]:
control.widget.on_change("value", self.callback)
# ___Panel 1_______________________________________________________________________________________
p1 = figure(
x_axis_type="datetime",
title="Bouy 45183 Temperature Measurements",
# tooltips=TOOLTIPS,
background_fill_color="white",
width=1000,
)
p1.add_tools(
HoverTool(
tooltips=[
("index", "$index"),
("datetime", "@x{%F}"), # use @{ } for field names with spaces
("Temperature", "@y{0.0}"),
],
formatters={
"@x": "datetime",
}, # use 'datetime' formatter for '@date' field
# display a tooltip whenever the cursor is vertically in line with a glyph
# mode='vline'
))
p1.line(
data.index,
c_to_f(data.ATMP),
color="green",
line_alpha=0.5,
legend_label=data.ATMP.name,
)
p1.line(
data.index,
