def radarplots(self):
fig1 = go.Figure()
features = self.data.columns[:3]
groupings = self.data.groupby('label').mean()
names = ['group{}'.format(i+1) for i in range(self.num_clusters)]
for f in features:
fig1.add_trace(go.Scatterpolar(
r=groupings[f],
theta=names,
fill='toself',
name=f
))
fig1.show()
fig2 = go.Figure()
groupings_t = groupings.T
for g in range(self.num_clusters):
fig2.add_trace(go.Scatterpolar(
r=groupings_t.iloc[:, g],
theta=features,
fill='toself',
name='group{}'.format(g)
))
fig2.show()
def update_output(club1, club2):
skills = [
'General', 'Mental', 'Mobility', 'Power', 'Shooting', 'Passing',
'Defending', 'Goalkeeping', 'Rating'
]
return go.Figure(
data=[
go.Scatterpolar(r=df[(df["Club"] == club1)].loc[:, [
'General', 'Mental', 'Mobility', 'Power', 'Shooting',
'Passing', 'Defending', 'Goalkeeping', 'Rating'
]].median(),
theta=skills,
fill='toself',
name=club1),
go.Scatterpolar(r=df[(df["Club"] == club2)].loc[:, [
'General', 'Mental', 'Mobility', 'Power', 'Shooting',
'Passing', 'Defending', 'Goalkeeping', 'Rating'
]].median(),
theta=skills,
fill='toself',
name=club2)
],
layout=go.Layout(
polar=dict(radialaxis=dict(visible=True, range=[0, 100])),
showlegend=True,
title={
'text': 'Skills Radar',
'y': 0.95,
'x': 0.5,
'xanchor': 'center',
'yanchor': 'top'
},
height=550,
colorway=['#2BB3B0', '#B277A7']),
)
def chart_radar(app, status_update):
MA_status_5, Earth3Dailystatus_2, Earth3Weeklystatus_2, Pice_MA20_above, Pice_MA200_above, MA_status_0, Earth3Dailystatus_0, Earth3Weeklystatus_0, Pice_MA20_below, Pice_MA200_below = get_data.radar_data(
status_update)
categories = [
'MA Status', 'Earth 3 daily', 'Earth3 Weekly', 'MA 20', 'MA 200'
]
fig = go.Figure(data=[
go.Scatterpolar(r=[
MA_status_5, Earth3Dailystatus_2, Earth3Weeklystatus_2,
Pice_MA20_above, Pice_MA200_above
],
theta=categories,
fill='toself',
name='Strong stock'),
go.Scatterpolar(r=[
MA_status_0, Earth3Dailystatus_0, Earth3Weeklystatus_0,
Pice_MA20_below, Pice_MA200_below
],
theta=categories,
fill='toself',
name='Weak stock')
],
layout=go.Layout(margin=dict(l=10, r=10, t=30, b=20),
height=180,
autosize=True))
#fig.update_layout(style{'height':'200px'})
fig.update_layout(title_text='Radar overview')
fig.update_layout(showlegend=False)
return fig
def radar_capability_comparison(feature_list, player1_value, player2_value,
playername_list):
player1_value = list(player1_value)
player1_value.append(player1_value[0])
player2_value = list(player2_value)
player2_value.append(player2_value[0])
feature_list.append(feature_list[0])
fig = go.Figure()
fig.add_trace(
go.Scatterpolar(r=player1_value,
theta=feature_list,
fill='toself',
name=playername_list[0]))
fig.add_trace(
go.Scatterpolar(r=player2_value,
theta=feature_list,
fill='toself',
name=playername_list[1]))
fig.update_layout(template="plotly_dark",
polar=dict(radialaxis=dict(
range=[-0.1, 1.1], showticklabels=False, ticks='')),
font_size=20)
return fig
def radar_gauge(val,pos,placeholder):
fig = go.Figure()
pos = int(int(pos)/2)
r[pos] = val
fig.add_trace(go.Scatterpolar(
r=r,
theta=theta
))
r2 = [0]*180
r2[pos] = 1500
fig.add_trace(go.Scatterpolar(
r=r2,
theta=theta
))
fig.update_layout(
polar=dict(
radialaxis=dict(
visible=True,
range=[0, 1500]
),
),
showlegend=False
)
placeholder.write(fig)
def show_results(scores, estimators_names, metric_names):
mean_accuracy = scores[0].mean(1)
mean_precision = scores[1].mean(1)
mean_recall = scores[2].mean(1)
mean_f1 = scores[3].mean(1)
mean_roc = scores[4].mean(1)
plot_tree_results = [estimators_names[0], mean_accuracy[0], mean_precision[0], mean_recall[0], mean_f1[0],
mean_roc[0]]
plot_svm = [estimators_names[1], mean_accuracy[1], mean_precision[1], mean_recall[1], mean_f1[1], mean_roc[1]]
plot_knn = [estimators_names[2], mean_accuracy[2], mean_precision[2], mean_recall[2], mean_f1[2], mean_roc[2]]
plot_nb = [estimators_names[3], mean_accuracy[3], mean_precision[3], mean_recall[3], mean_f1[3], mean_roc[3]]
plot_lr = [estimators_names[4], mean_accuracy[4], mean_precision[4], mean_recall[4], mean_f1[4], mean_roc[4]]
plots = [plot_tree_results, plot_svm, plot_knn, plot_nb, plot_lr]
print(tabulate(plots, metric_names))
# -----------------------------------------------------------------------------------------------------------------
# Wyświetlanie wykresu
plot_names = [*metric_names, metric_names[0]]
fig = go.Figure(data=[go.Scatterpolar(r=plot_tree_results, theta=plot_names, name='Drzewo decyzyjne'),
go.Scatterpolar(r=plot_svm, theta=plot_names, name='SVM'),
go.Scatterpolar(r=plot_knn, theta=plot_names, name='kNN'),
go.Scatterpolar(r=plot_nb, theta=plot_names, name='Naiwny Bayes'),
go.Scatterpolar(r=plot_lr, theta=plot_names, name='Regresja Logistyczna')],
layout=go.Layout(title=go.layout.Title(text='Wyniki'),
polar={'radialaxis': {'visible': True}},
showlegend=True))
pyo.plot(fig)
def plot_radar(champ_list, result_1, result_2):
# plot the radar plot for the given data
categories = [
'Hp', 'Mp', 'Move Speed', 'Armor', 'Attack Range', 'Attack Damage',
'Attack Speed'
]
fig = go.Figure()
fig.add_trace(
go.Scatterpolar(r=[
result_1[4], result_1[5], result_1[6], result_1[7], result_1[8],
result_1[9], result_1[10]
],
theta=categories,
fill='toself',
name=champ_list[0]))
fig.add_trace(
go.Scatterpolar(r=[
result_2[4], result_2[5], result_2[6], result_2[7], result_2[8],
result_2[9], result_2[10]
],
theta=categories,
fill='toself',
name=champ_list[1]))
fig.update_layout(
polar=dict(radialaxis=dict(visible=True, range=[0, 700])),
showlegend=False)
fig.show()
def _add_trace(self, fig, mode, group, color, imag=False):
"""
Adds adequate trace to figure
:param fig: [go.Figure]
:param mode: [int] mode (1, 2, ...)
:param comp: [str] 'real' or 'imag'
:param group: [int] group (1, 2, )
:param color: [str] line color in css standards
"""
r_r = self.df.loc[(self.df['mode'] == mode) & (self.df['group'] == group)].strength_real.to_list()[0]
r_i = self.df.loc[(self.df['mode'] == mode) & (self.df['group'] == group)].strength_imag.to_list()[0]
verbalise = 'Mode {}'.format(mode) + ' Group {}'.format(group) if not self.analysis else ''
fig.add_trace(go.Scatterpolar(
r=self._close(r_r), theta=self._close(self.networks), mode="lines",
legendgroup=verbalise, showlegend=True, name=verbalise, subplot="polar1",
line=dict(color=color, dash='dash' if group != 1 else None)
), row=1, col=1)
if imag:
fig.add_trace(go.Scatterpolar(
r=self._close(r_i), theta=self._close(self.networks), mode="lines",
legendgroup=verbalise, showlegend=False, name=verbalise, subplot="polar2",
line=dict(color=color, dash='dash' if group != 1 else None),
), row=1, col=2)
def exibirGraficoCopiado():
categories = [
'processing cost', 'mechanical properties', 'chemical stability',
'thermal stability', 'device integration'
]
fig = go.Figure()
fig.add_trace(
go.Scatterpolar(
r=[8, 6, 5, 3, 4],
theta=categories,
fill='toself', # tonext
name='Atividades 2017'))
fig.add_trace(
go.Scatterpolar(r=[1, 5, 2, 2, 3],
theta=categories,
fill='toself',
name='Atividades 2018'))
fig.add_trace(
go.Scatterpolar(
r=[4, 3, 2.5, 1, 2],
theta=categories,
fill='toself', #tonext
name='Atividades 2019'))
fig.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 5])),
showlegend=True)
fig.show()
def get_radar(playername):
x = df[(df['PLAYER NAME'] == playername) & (df['SEASON'] == 2019)]
y = df[(df['PLAYER NAME'] == playername) & (df['SEASON'] == 2018)]
cy = x[['sg_ott_pctle', 'sg_app_pctle', 'sg_atg_pctle',
'sg_putt_pctle']].values.tolist()[0]
py = y[['sg_ott_pctle', 'sg_app_pctle', 'sg_atg_pctle',
'sg_putt_pctle']].values.tolist()[0]
categories = ['Off The Tee', 'Approach', 'ATG', 'Putting']
fig = go.Figure()
fig.add_trace(
go.Scatterpolar(r=cy, theta=categories, fill='toself', name='2019'))
fig.add_trace(
go.Scatterpolar(r=py, theta=categories, fill='toself', name='2018'))
fig.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0,
100]), ),
showlegend=True)
fig.update_layout(
title='<b>2019 Strokes Gained Data</b><br> Percentile Rank </br>',
title_x=0.5,
width=500,
margin={
"t": 30,
"b": 0,
"l": 30,
"r": 0
})
return dcc.Graph(figure=fig, style={"height": "100%", "width": "100%"})
def plot_combine():
goodput_harm_by_localVideo = pd.read_csv('/Users/rukshani/Documents/DATASET/draft/data-processed/harm/goodput-harm-iperf-localVideo.csv',sep=',',
names=["cca_combo", "harm", "percent", "cca_1", "cca_2", "network"])
goodput_harm_by_youtube = pd.read_csv('/Users/rukshani/Documents/DATASET/draft/data-processed/harm/goodput-harm-iperf-webVideo.csv',sep=',',
names=["cca_combo", "harm", "percent", "cca_1", "cca_2", "network"])
iperf_local_youtube_combi = [goodput_harm_by_localVideo, goodput_harm_by_youtube]
new_df = pd.concat(iperf_local_youtube_combi)
new_df = new_df.reset_index()
three_g = new_df.query("network == '3G'")
homelink = new_df.query("network == 'Homelink'")
fig = go.Figure()
fig.add_trace(go.Scatterpolar(
r = three_g['harm'],
theta = three_g['cca_combo'],
mode = 'lines',
connectgaps=True,
name = '3G',
fill='toself'
))
fig.add_trace(go.Scatterpolar(
r = homelink['harm'],
theta = homelink['cca_combo'],
mode = 'lines',
connectgaps=True,
name = 'Homelink',
fill='toself'
))
fig.update_layout(
polar=dict(
radialaxis=dict(
visible=True
),
),
showlegend=True,
font=dict(
# family="Courier New, monospace",
# size=11,
color="black"
)
)
fig.update_layout(legend=dict(
orientation="h",
yanchor="bottom",
# y=1.07,
xanchor="right",
x=0.1,
font_color="black"
))
fig.show()
def features_radarchart(features, clusters=None, htmlfile=None):
"""Show radar chart for the provided features.
Arg:
features (dframe): neuron features
clusterinfo (dframe):
Returns:
heatmap showing the features
Note: should call on non-pca features but should restrict to most important features.
"""
fig = go.Figure()
if clusters is None:
categories = list(features.columns)
for index, row in features.iterrows():
fig.add_trace(go.Scatterpolar(
r=row.values,
theta=categories,
fill='toself',
text=index,
name=index
))
else:
clusters = clusters.set_index('bodyid')
featuresx = pd.concat([features, clusters], axis=1)
featuresx = featuresx.sort_values(by=['type'])
categories = list(featuresx.columns)
categories.remove('type')
for index, row in featuresx.iterrows():
fig.add_trace(go.Scatterpolar(
r=row.values,
theta=categories,
fill='toself',
text=index,
name=row['type']
))
fig.update_traces(
hoverinfo='text')
fig.update_layout(
width = 900,
height = 800,
polar=dict(
radialaxis=dict(visible=True)
),
showlegend=True
)
if htmlfile is not None:
plotly.offline.plot(fig, filename=htmlfile)
fig.show()
def execute_player_comparison(player_a, player_b, gw_id):
if not player_a:
msg = html.P("Please select first player")
return msg
if not player_b:
msg = html.P("Please select second player")
return msg
if not gw_id:
msg = html.P("Please select gameweek in left layout")
return msg
#
df_leads = load_leads(gw_id)
# normalization
pot_div = 12
point_div = 6
retrun_div = 0.8
df_leads["LGBM Potential"] = df_leads["LGBM Potential"] / pot_div
df_leads["Fast Potential"] = df_leads["Fast Potential"] / pot_div
df_leads["LGBM Point"] = df_leads["LGBM Point"] / point_div
df_leads["Fast Point"] = df_leads["Fast Point"] / point_div
df_leads["LGBM Return"] = df_leads["LGBM Return"] / 0.8
df_leads["Fast Return"] = df_leads["Fast Return"] / 0.4
df_leads["Net"] = df_leads["Net"] / 0.4
df_leads["Cost"] = df_leads["cost"] / 10.0
df_a = df_leads[df_leads["name"] == player_a].copy()
df_b = df_leads[df_leads["name"] == player_b].copy()
keep_cols = [
"LGBM Point", "LGBM Potential", "LGBM Return", "Fast Point",
"Fast Potential", "Fast Return", "Cost"
]
df_a = df_a[keep_cols].copy().T.reset_index()
df_a.columns = ["theta", "r"]
df_b = df_b[keep_cols].copy().T.reset_index()
df_b.columns = ["theta", "r"]
# pdb.set_trace()
fig = go.Figure()
fig.add_trace(
go.Scatterpolar(r=df_a['r'].values,
theta=df_a["theta"].values,
fill='toself',
name=player_a))
fig.add_trace(
go.Scatterpolar(r=df_b['r'].values,
theta=df_b["theta"].values,
fill='toself',
name=player_b))
fig.update_layout(polar=dict(radialaxis=dict(visible=False)),
showlegend=True)
# fig = px.line_polar(df_a, r='r', theta='theta', line_close=True)
graph = dcc.Graph(figure=fig)
return graph
def rader_fig(company_type_name_m , company_type_name_f):
if company_type_name_m == "Pvt Ltd":
the_range = [0,2500]
else:
the_range = [0,250]
# education names
rader_measure = df_copy["education_level"].value_counts().index.tolist()
rader_measure.append(rader_measure[0])
#male
rader_values_m = df_copy[(df_copy["target"] == 1.0)&(df_copy["gender"] == "Male")&(df_copy["company_type"] == company_type_name_m)]\
["education_level"].value_counts().values.tolist()
rader_values_m.append(rader_values_m[0])
#female
rader_values_f = df_copy[(df_copy["target"] == 1.0)&(df_copy["gender"] == "Female")&(df_copy["company_type"] == company_type_name_f)]\
["education_level"].value_counts().values.tolist()
rader_values_f.append(rader_values_f[0])
fig = go.Figure()
fig.add_trace(go.Scatterpolar(
r=rader_values_m,
theta=rader_measure,
fill='toself',
name= f"Male "+company_type_name_m,
marker_color=["#125d98"],
))
fig.add_trace(go.Scatterpolar(
r=rader_values_f,
theta=rader_measure,
fill='toself',
name= f"Female "+company_type_name_f,
marker_color=["#f5a962"]
))
return fig.update_layout(
polar=dict(
radialaxis=dict(
visible=True,
range= the_range,
color=colors['text'],
)),
showlegend= True,
plot_bgcolor=colors['background'],
paper_bgcolor=colors['background'],
font_color=colors['text']
)
def visualize_as_radar():
data_org=explore.dice_exp.org_instance
data_cf=explore.dice_exp.final_cfs_df_sparse
outcome_name=explore.outcome_name
vertical_stack = pd.concat([data_org, data_cf], axis=0)
#have output be 0/1
new_output=[]
for i in vertical_stack[outcome_name].values:
new_output.append(round(i))
vertical_stack[outcome_name]=new_output
labelencoder = LabelEncoder()
vertical_stack1 = vertical_stack.copy()
columns=list(vertical_stack1.columns)
for i in columns:
if i not in explore.cont_feat:
vertical_stack1[i]=labelencoder.fit_transform(vertical_stack1[i])
normalized_vertical_stack1=(vertical_stack1-vertical_stack1.min())/(vertical_stack1.max()-vertical_stack1.min())
visualize_as_radar.normalized_data=normalized_vertical_stack1
columns_touse=[]
for i in columns:
columns_touse.append(i)
columns_touse.append(columns[0])
#print(columns_touse)
fig = make_subplots(rows=2, cols=3, specs=[[{'type': 'polar'}]*3]*2)
col=[2,3,1,2,3]
row=[1,1,2,2,2]
fig.add_trace(go.Scatterpolar(
name = "original instance",
r = list(normalized_vertical_stack1.iloc[0]),
theta = columns_touse,
), 1, 1)
for i in range(normalized_vertical_stack1.shape[0]-1):
fig.add_trace(go.Scatterpolar(
name = "counterfactual",
r = list(normalized_vertical_stack1.iloc[i+1]),
theta = columns_touse,
), row[i], col[i])
fig.update_traces(fill='toself')
fig.show()
def properties_radar():
source_subreddit = request.args.get('source-subreddit')
target_subreddit = request.args.get('target-subreddit')
data = BodyModel.get_instance().get_properties_radar(source_subreddit, target_subreddit)
data_avg = BodyModel.get_instance().get_properties_radar_average()
data_close_line = data.append(data.head(1))
data_avg_close_line = data_avg.append(data_avg.head(1))
fig = go.Figure(layout=go.Layout(height=PLOT_HEIGHT, width=PLOT_WIDTH))
fig.add_trace(go.Scatterpolar(
r=data_close_line.values,
theta=data_close_line.index,
line_color=PRIMARY_COLOR,
showlegend=False,
name="Selection"
))
fig.add_trace(go.Scatterpolar(
r=data_avg_close_line.values,
theta=data_avg_close_line.index,
line_color=SECONDARY_COLOR,
name='Avg. of all subreddits'
))
fig.update_layout(
polar =
{"radialaxis": {
"visible":True,
"range":[0, 0.25]
}
},
dragmode=False,
showlegend=True,
legend={
"orientation":"h",
"yanchor":"bottom",
"y":-0.2,
"xanchor":"right",
"x":1.2
},
font={"size": 8},
margin={"b": 0, "l": 20, "r": 0, "t": 0},
paper_bgcolor=PLOT_BACKGROUND_COLOR,
template=TEMPLATE
)
fig.update_polars(radialaxis_tickformat="0.1%", radialaxis_tickvals=[0, 0.05, 0.10, 0.15, 0.20])
return json.dumps(fig, cls=utils.PlotlyJSONEncoder)
def update_graph(country_drop):
#country_color = [{
# country_drop: '#002366'
# } ]
fig = go.Figure()
for country in countries:
#color = country_color.get(country, 'lightslategrey')
col = ["purple", "red", "rosybrown",
"royalblue", "rebeccapurple", "saddlebrown", "salmon"]
color = random.choice(col) if country in country_drop else 'lightslategrey'
highlight = color != 'lightslategrey'
data_filtered = final[final.country == country]
plot_data = data_filtered
axis = plot_data.variable.tolist()
axis.append(axis[0])
value = plot_data.value.tolist()
value.append(value[0])
fig.add_trace(
go.Scatterpolar(
r=value,
theta=axis,
showlegend=highlight,
name=country,
hoverinfo='name+r',
mode='lines',
line_color=color,
opacity=0.8 if highlight else 0.2,
line_width=2.6 if highlight else 0.5
)
)
title = 'Comparison between countries in each indicator.' '<br><span style="font-size:10px"><i>' 'Values range from 0 to 1</span></i>'
fig.update_layout(
title_text = title,
title_font_color = '#333333',
title_font_size = 14,
polar_bgcolor='white',
polar_radialaxis_visible=True,
polar_radialaxis_showticklabels=True,
polar_radialaxis_tickfont_color='darkgrey',
polar_angularaxis_color='grey',
polar_angularaxis_showline=False,
polar_radialaxis_showline=False,
polar_radialaxis_layer='below traces',
polar_radialaxis_gridcolor='#F2F2F2',
polar_radialaxis_range=(0,1),
polar_radialaxis_tickvals=[25, 50],
polar_radialaxis_tickmode='array',
legend_font_color = 'grey', # We don't want to draw attention to the legend
legend_itemclick = 'toggleothers', # Change the default behaviour, when click select only that trace
legend_itemdoubleclick = 'toggle', # Change the default behaviour, when double click ommit that trace
width = 1000, # chart size
height = 600 # chart size
)
return fig
def compare_countries(value, data):
"""
This callback updates scatter polar graph based on filter's selected options.
:param value: selected countries
:return: Scatter polar graph
"""
if data is None:
raise PreventUpdate
df = pd.DataFrame.from_dict(data)
categories = list(df.columns)
fig = go.Figure()
filter_df = df[df.index.isin(value)]
for index, row in filter_df.iterrows():
fig.add_trace(
go.Scatterpolar(r=row.values.flatten().tolist(),
theta=categories,
fill='toself',
name=index))
fig.update_layout(
polar=dict(radialaxis=dict(visible=True, range=[0, 1])),
showlegend=True,
width=700,
height=700)
return fig
def update_figure(selected_hours):
filter_df = test[test.epoch == selected_hours]
traces = []
for channel in filter_df.Channel.unique():
Channel_df = filter_df[filter_df['Channel'] == channel]
traces.append(go.Scatterpolar(
r=Channel_df['r'],
theta=Channel_df['theta'],
text=Channel_df['Channel'],
mode='markers',
opacity=0.7,
marker={
'size': 25,
'color': Channel_df['color'],
'line': {'width': 0.5, 'color': Channel_df['color']},
},
subplot= 'polar',
name= channel,
))
return {
'data': traces,
'layout': go.Layout(
polar={'angularaxis': {'rotation': 90}},
margin=dict(t=20, r=0, b=100, l=70))
}
def get_test_radar_chart(self):
exp_results = self.read_file()
min_loss = np.inf
best_run = None
for min_r in range(len(exp_results)):
if 'loss' in exp_results[
min_r] and exp_results[min_r]['loss'] < min_loss:
min_loss = exp_results[min_r]['loss']
best_run = min_r
test_fair = exp_results[best_run]['test_fair']
test_acc = exp_results[best_run]['test_acc']
test_robust = exp_results[best_run]['test_robust']
test_number_features = exp_results[best_run]['cv_number_features']
categories = ['Accuracy', 'Fairness', 'Simplicity', 'Safety']
fig = go.Figure()
fig.add_trace(
go.Scatterpolar(r=[
test_acc, test_fair, 1.0 - test_number_features, test_robust
],
theta=categories,
fill='toself',
name='Best Result on Test'))
fig.update_layout(
title='Best Result on Test',
polar=dict(radialaxis=dict(visible=True, range=[0, 1])),
showlegend=False)
return fig
def plot_pattern(incident_angles, pattern, fig=None, log_scale_min=-50):
"""
Plots the radiation pattern on a polar plot using the plotly library
Parameters:
----------
:param pattern : Radiation pattern to plot. The first column should be the incident angles while the second
should be the directivity values in dBi
:param fig : Plotly compatible figure object, if not specified a new object will be created [default:None]
:param log_scale_min : Radiation pattern values that are less than this threshold will be truncated
:type pattern : 2D numpy array
:type fig : Plotly compatible figure object
:type log_scale_min: float
Return values:
-----------------
:return fig : Figure object
:rype fig : Plotly compatible figure object
""" # Remove extreme low values
pattern = [
log_scale_min if pattern_i < log_scale_min else pattern_i
for pattern_i in pattern
]
if fig is None:
fig = go.Figure()
fig.add_trace(go.Scatterpolar(r=pattern, theta=incident_angles))
fig.update_layout(title_text="Radiation pattern")
plot(fig)
return fig
def create_advanced_star_plot(pokemon_name):
# gets the pokemon's row
data_sample = dataset.loc[dataset['Name'] == pokemon_name]
stats = ['HP', 'Attack', 'Defense', 'SP Attack', 'SP Defense', 'Speed']
stat_vals = [
data_sample['HP'].values[0], data_sample['Attack'].values[0],
data_sample['Sp_Atk'].values[0], data_sample['Sp_Def'].values[0],
data_sample['Speed'].values[0]
]
# creates the actual figure with the pokemon's stats
star_fig = go.Figure(data=go.Scatterpolar(
r=stat_vals, theta=stats, fill='toself', name='Pokemon Stats'))
star_plot_title = str(pokemon_name) + '\'s Stats Star Plot'
star_fig.update_layout(polar=dict(radialaxis=dict(visible=True,
range=[0, 255]), ),
showlegend=False,
title={
'text': star_plot_title,
'y': 0.95,
'x': 0.5,
'xanchor': 'center',
'yanchor': 'top'
},
margin=dict(l=55, r=55, t=55, b=55))
return star_fig
def draw_polar(vis, exclude=None):
telescope, names, ids, xpos, ypos, stations = getPlotantsAntennaInfo(
vis, False, exclude, False)
# code from pipeline summary.py
# PlotAntsChart draw_polarlog_ant_map_in_subplot
if 'VLA' in telescope:
# For (E)VLA, set a fixed local center position that has been
# tuned to work well for its array configurations (CAS-7479).
xcenter, ycenter = -32, 0
# rmin_min, rmin_max = 12.5, 350
else:
# For non-(E)VLA, take the median of antenna offsets as the
# center for the plot.
xcenter = np.median(xpos)
ycenter = np.median(ypos)
# rmin_min, rmin_max = 3, 350
r = ((xpos - xcenter)**2 + (ypos - ycenter)**2)**0.5
theta = np.arctan2(xpos - xcenter, ypos - ycenter) * 180.0 / 3.14
data = go.Scatterpolar(r=r, theta=theta)
fig = go.Figure(data)
# Set options common to all traces with fig.update_traces
fig.update_traces(mode='markers', marker_line_width=2, marker_size=10)
fig.update_layout(title=telescope,
xaxis=dict(title_text="X (m)"),
yaxis=dict(title_text="Y (m)"),
yaxis_zeroline=False,
xaxis_zeroline=False,
autosize=False,
width=500,
height=500)
return fig
def update_golden_angles(max_angle_value, total_number_of_angles):
fig = go.Figure()
list_angles = retrieve_list_of_golden_angles(total_number_of_angles,
max_angle=max_angle_value)
data = pd.DataFrame(list_angles, columns=['angles'])
fig.add_trace(go.Scatterpolar(theta=data['angles'], mode='markers+lines'))
fig.layout.xaxis.title = "Iteration number"
fig.layout.paper_bgcolor = '#E5ECF6'
table = dt.DataTable(
columns=([{
'id': 'angles',
'name': 'Angles (degrees)',
'type': 'numeric',
'editable': False
}]),
data=data.to_dict('records'),
export_format='csv',
style_header={
'backgroundColor': 'rgb(30, 30, 30)',
'color': 'white'
},
style_cell={'textAlign': 'left'},
style_table={'maxWidth': '30%'},
)
return fig, table
def country_radar():
categories = [
'Neuroticism', 'Openness', 'Extraversion', 'Agreeableness',
'Conscientiousness', 'Neuroticism'
]
fig = go.Figure()
for i in user_select:
fig.add_trace(
go.Scatterpolar(r=[
df[df.Country == i].groupby('Country')
['neu'].mean().to_list()[0], df[df.Country == i].groupby(
'Country')['ope'].mean().to_list()[0],
df[df.Country == i].groupby('Country')
['ext'].mean().to_list()[0], df[df.Country == i].groupby(
'Country')['agr'].mean().to_list()[0],
df[df.Country == i].groupby('Country')
['con'].mean().to_list()[0], df[df.Country == i].groupby(
'Country')['neu'].mean().to_list()[0]
],
theta=categories,
fill='toself',
name=i))
fig.update_layout(
polar=dict(radialaxis=dict(visible=True, range=[0, 6])),
showlegend=True)
# fig.show()
return fig
def update_graph(playlists):
"""
callback function for radar graph for playlists
:param playlists: list of playlists
:type playlists: String or List of Strings
:return: Figure containing radar graph for audio features in playlists
:rtype: plotly.graph_objs
"""
if isinstance(playlists, str):
playlists = [playlists]
df = pd.read_csv(f'.csv_caches/{get_my_id()}/audio_feature_kmean.csv').drop(['Unnamed: 0'], axis=1)
fig = go.Figure()
for playlist in playlists:
playlist_df = df[df['playlist_name'] == playlist]
categories = ['danceability', 'energy', 'key', 'loudness', 'mode',
'speechiness', 'acousticness', 'instrumentalness', 'liveness',
'valence', 'tempo']
for col in playlist_df.columns:
if col in categories:
scaler.fit(playlist_df.loc[:, [col]])
playlist_df.loc[:, col] = scaler.transform(playlist_df.loc[:, col].values.reshape(-1, 1)).ravel()
feature_val_playlist = playlist_df[categories].mean(0)
legend_str = '<br>'.join(textwrap.wrap(playlist, width=12))
fig.add_trace(go.Scatterpolar(
r=feature_val_playlist,
theta=categories,
fill='toself',
name=f'{legend_str}'
))
return fig
def radarChart(id, name, screen_name, location, df, df2):
ls = [0] * len(df.columns)
ind = 0
for i in df.columns:
if id in df[i].values:
print(f"This ID:{id} is present in {i}")
ls[ind] += 1
ind += 1
print(ls)
fig = go.Figure(data=go.Scatterpolar(
r=ls,
theta=df2.iloc[0].values,
fill='toself',
name=name,
))
fig.update_layout(
polar=dict(radialaxis=dict(visible=True), ),
showlegend=False,
title=go.layout.Title(
text=
f"Tagging for {name}(@{screen_name}) - ID: {id} - Location:{location}"
))
fig.show()
def draw(self):
"""
Generate Radar Chart visualization
"""
label_name, numerical_column = self._check_requirements()
if label_name is not None and numerical_column is not None:
categories = numerical_column
data_label = self.dataframe[label_name]
data_numeric = self.dataframe[numerical_column]
list_number = []
fig = go.Figure()
for i in range(len(data_numeric)):
idx_data_numeric = (list(data_numeric.iloc[i]))
fig.add_trace(
go.Scatterpolar(r=idx_data_numeric,
theta=categories,
fill='toself',
name=data_label[i]))
list_number.append(idx_data_numeric)
fig.update_layout(polar=dict(
radialaxis=dict(visible=True, range=[0, max(list_number)])),
showlegend=False)
fig.show()
def updateRadarGraph(names):
categories = ['Attack', 'Defense', 'Sp_Atk', 'Sp_Def', 'Speed']
fig = go.Figure()
'''
with open('names.csv') as csvfile:
readCSV = csv.reader(csvfile, delimiter=',')
for row in readCSV:
names = row
'''
num = len(names)
for i in range(num):
option_df = df[(df.Name == names[i])]
option_value = []
for j in range(5):
option_value.append(int(option_df.iloc[0][categories[j]]))
fig.add_trace(
go.Scatterpolar(r=option_value,
theta=categories,
fill='toself',
name=names[i]))
fig.update_layout(
polar=dict(radialaxis=dict(visible=True, range=[0, 200])),
showlegend=True,
paper_bgcolor='#ffffff',
plot_bgcolor='#ffffff')
return fig
def make_radar_chart(norm_df, n_clusters):
fig = go.Figure()
cmap = cm.get_cmap('tab20b')
angles = list(norm_df.columns[5:])
angles.append(angles[0])
layoutdict = dict(radialaxis=dict(visible=True, range=[0, 1]))
maxes = dict()
for i in range(n_clusters):
subset = norm_df[norm_df['cluster'] == i]
data = [np.mean(subset[col]) for col in angles[:-1]]
maxes[i] = data.index(max(data))
data.append(data[0])
fig.add_trace(
go.Scatterpolar(
r=data,
theta=angles,
# fill='toself',
# fillcolor = 'rgba' + str(cmap(i/n_clusters)),
mode='lines',
line_color='rgba' + str(cmap(i / n_clusters)),
name="Cluster " + str(i)))
fig.update_layout(polar=layoutdict, showlegend=True)
fig.update_traces()
return fig, maxes
