def display_file(file_content, file_name, dropdown_value, dropdown_value_2,
dropdown_value_3):
if file_content is None:
return html.Div(['Choose a file to process it.'])
data_ini = parse_file(file_content)
if ('{}'.format(dropdown_value_2) == '(sg)'):
window = golay_window.window(10.0, data_ini)
# Apply the Savintzky - Golay filter with window = 31 and polynomial parameter = 6
data = sav_golay.golay(data_ini, 31, 6)
res = data[:, 1:4] - data_ini[:, 1:4]
elif ('{}'.format(dropdown_value_2) == '(tma)'):
data = triple_moving_average.generate_filtered_data(data_ini, 3)
res = data[:, 1:4] - data_ini[:, 1:4]
elif ('{}'.format(dropdown_value_2) == '(bo)'):
data = sav_golay.golay(data_ini, 31, 6)
data = triple_moving_average.generate_filtered_data(data, 3)
res = data[:, 1:4] - data_ini[:, 1:4]
elif ('{}'.format(dropdown_value_2) == '(nf)'):
data = data_ini
res = data[:, 1:4] - data_ini[:, 1:4]
#else:
#data=data_ini
if (data.shape[0] > 0):
data_dict = [{
'No.': '{:03d}'.format(i + 1),
't (s)': data[i][0],
'x ' + '{}'.format(dropdown_value): data[i][1],
'y ' + '{}'.format(dropdown_value): data[i][2],
'z ' + '{}'.format(dropdown_value): data[i][3]
} for i in range(data.shape[0])]
if ('{}'.format(dropdown_value_3) == '(ef)'):
kep, res = e_fit.determine_kep(data[:, 1:])
elif ('{}'.format(dropdown_value_3) == '(gm)'):
# Apply gibbs method
kep_gibbs = gibbsMethod.gibbs_get_kep(data[:, 1:])
kep_final_gibbs = lamberts_kalman.kalman(kep_gibbs, 0.01**2)
kep_final_gibbs = np.transpose(kep_final_gibbs)
kep = np.resize(kep_final_gibbs, ((7, 1)))
elif ('{}'.format(dropdown_value_3) == '(in)'):
# Apply the interpolation method
kep_inter = interpolation.main(data)
# Apply Kalman filters, estimate of measurement variance R = 0.01 ** 2
kep_final_inter = lamberts_kalman.kalman(kep_inter, 0.01**2)
kep = np.transpose(kep_final_inter)
kep = np.resize(kep, ((7, 1)))
elif ('{}'.format(dropdown_value_3) == '(lk)'):
# Apply Lambert's solution for the filtered data set
kep_lamb = lamberts_kalman.create_kep(data)
# Apply Kalman filters, estimate of measurement variance R = 0.01 ** 2
kep_final_lamb = lamberts_kalman.kalman(kep_lamb, 0.01**2)
kep = np.transpose(kep_final_lamb)
kep = np.resize(kep, ((7, 1)))
# Visuals
orbit_points = data[:, 1:] + res
earth_points = gen_sphere()
xyz_org = go.Scatter3d(name='Original Data',
legendgroup='org',
showlegend=False,
x=data[:, 1],
y=data[:, 2],
z=data[:, 3],
mode='markers',
marker={
'size': 1,
'color': 'black'
})
xyz_fit = go.Scatter3d(name='Fitted Ellipse',
legendgroup='fit',
showlegend=False,
x=orbit_points[:, 0],
y=orbit_points[:, 1],
z=orbit_points[:, 2],
mode='lines',
line={
'width': 5,
'color': 'red'
})
xyz_cur = go.Scatter3d(name='Position at Epoch',
legendgroup='cur',
showlegend=False,
x=[orbit_points[0, 0]],
y=[orbit_points[0, 1]],
z=[orbit_points[0, 2]],
mode='markers',
marker={
'size': 3,
'color': 'blue'
})
earth_top = go.Mesh3d(x=earth_points[0],
y=earth_points[1],
z=earth_points[2],
color='#1f77b4',
opacity=0.5,
hoverinfo='skip',
showlegend=False)
earth_bottom = go.Mesh3d(x=earth_points[0],
y=earth_points[1],
z=-earth_points[2],
color='#1f77b4',
opacity=0.5,
hoverinfo='skip',
showlegend=False)
xy_org = go.Scatter(name='Original Data',
legendgroup='org',
showlegend=True,
x=data[:, 1],
y=data[:, 2],
mode='markers',
marker={
'size': 5,
'color': 'black'
})
xy_fit = go.Scatter(name='Fitted Ellipse',
legendgroup='fit',
showlegend=True,
x=orbit_points[:, 0],
y=orbit_points[:, 1],
mode='lines',
line={
'width': 2,
'color': 'red'
})
xy_cur = go.Scatter(name='Position at Epoch',
legendgroup='cur',
showlegend=True,
x=[orbit_points[0, 0]],
y=[orbit_points[0, 1]],
mode='markers',
marker={
'size': 10,
'color': 'blue'
})
yz_org = go.Scatter(name='Original Data',
legendgroup='org',
showlegend=False,
x=data[:, 2],
y=data[:, 3],
mode='markers',
marker={
'size': 5,
'color': 'black'
})
yz_fit = go.Scatter(name='Fitted Ellipse',
legendgroup='fit',
showlegend=False,
x=orbit_points[:, 1],
y=orbit_points[:, 2],
mode='lines',
line={
'width': 2,
'color': 'red'
})
yz_cur = go.Scatter(name='Position at Epoch',
legendgroup='cur',
showlegend=False,
x=[orbit_points[0, 1]],
y=[orbit_points[0, 2]],
mode='markers',
marker={
'size': 10,
'color': 'blue'
})
xz_org = go.Scatter(name='Original Data',
legendgroup='org',
showlegend=False,
x=data[:, 1],
y=data[:, 3],
mode='markers',
marker={
'size': 5,
'color': 'black'
})
xz_fit = go.Scatter(name='Fitted Ellipse',
legendgroup='fit',
showlegend=False,
x=orbit_points[:, 0],
y=orbit_points[:, 2],
mode='lines',
line={
'width': 2,
'color': 'red'
})
xz_cur = go.Scatter(name='Position at Epoch',
legendgroup='cur',
showlegend=False,
x=[orbit_points[0, 0]],
y=[orbit_points[0, 2]],
mode='markers',
marker={
'size': 10,
'color': 'blue'
})
xyz_fig = tools.make_subplots(rows=2,
cols=2,
specs=[[{}, {}], [{}, {
'is_3d': True
}]])
xyz_fig.append_trace(xz_org, 1, 1)
xyz_fig.append_trace(xz_fit, 1, 1)
xyz_fig.append_trace(xz_cur, 1, 1)
xyz_fig.append_trace(yz_org, 1, 2)
xyz_fig.append_trace(yz_fit, 1, 2)
xyz_fig.append_trace(yz_cur, 1, 2)
xyz_fig.append_trace(xy_org, 2, 1)
xyz_fig.append_trace(xy_fit, 2, 1)
xyz_fig.append_trace(xy_cur, 2, 1)
xyz_fig.append_trace(xyz_org, 2, 2)
xyz_fig.append_trace(xyz_fit, 2, 2)
xyz_fig.append_trace(xyz_cur, 2, 2)
xyz_fig.append_trace(earth_top, 2, 2)
xyz_fig.append_trace(earth_bottom, 2, 2)
xyz_fig['layout']['xaxis1'].update(title='x ' +
'{}'.format(dropdown_value))
xyz_fig['layout']['yaxis1'].update(title='z ' +
'{}'.format(dropdown_value),
scaleanchor='x')
xyz_fig['layout']['xaxis2'].update(title='y ' +
'{}'.format(dropdown_value),
scaleanchor='x')
xyz_fig['layout']['yaxis2'].update(title='z ' +
'{}'.format(dropdown_value),
scaleanchor='x2')
xyz_fig['layout']['xaxis3'].update(title='x ' +
'{}'.format(dropdown_value),
scaleanchor='x')
xyz_fig['layout']['yaxis3'].update(title='y ' +
'{}'.format(dropdown_value),
scaleanchor='x3')
xyz_fig['layout']['scene1']['xaxis'].update(
showticklabels=True,
showspikes=False,
title='x ' + '{}'.format(dropdown_value))
xyz_fig['layout']['scene1']['yaxis'].update(
showticklabels=True,
showspikes=False,
title='y ' + '{}'.format(dropdown_value))
xyz_fig['layout']['scene1']['zaxis'].update(
showticklabels=True,
showspikes=False,
title='z ' + '{}'.format(dropdown_value))
xyz_fig['layout'].update(width=1050, height=700, margin={'t': 50})
xyz_fig['layout']['legend'].update(orientation='h')
rel_time = data[:, 0] - data[0, 0]
xt_org = go.Scatter(name='Original Data',
legendgroup='org',
x=rel_time,
y=data[:, 1],
mode='markers',
marker={
'size': 5,
'color': 'black'
})
xt_fit = go.Scatter(name='Fitted Ellipse',
legendgroup='fit',
x=rel_time,
y=orbit_points[:, 0],
mode='lines',
line={
'width': 2,
'color': 'red'
})
xt_cur = go.Scatter(name='Position at Epoch',
legendgroup='cur',
x=[rel_time[0]],
y=[orbit_points[0, 0]],
mode='markers',
marker={
'size': 10,
'color': 'blue'
})
yt_org = go.Scatter(name='Original Data',
legendgroup='org',
showlegend=False,
x=rel_time,
y=data[:, 2],
mode='markers',
marker={
'size': 5,
'color': 'black'
})
yt_fit = go.Scatter(name='Fitted Ellipse',
legendgroup='fit',
showlegend=False,
x=rel_time,
y=orbit_points[:, 1],
mode='lines',
line={
'width': 2,
'color': 'red'
})
yt_cur = go.Scatter(name='Position at Epoch',
legendgroup='cur',
showlegend=False,
x=[rel_time[0]],
y=[orbit_points[0, 1]],
mode='markers',
marker={
'size': 10,
'color': 'blue'
})
zt_org = go.Scatter(name='Original Data',
legendgroup='org',
showlegend=False,
x=rel_time,
y=data[:, 3],
mode='markers',
marker={
'size': 5,
'color': 'black'
})
zt_fit = go.Scatter(name='Fitted Ellipse',
legendgroup='fit',
showlegend=False,
x=rel_time,
y=orbit_points[:, 2],
mode='lines',
line={
'width': 2,
'color': 'red'
})
zt_cur = go.Scatter(name='Position at Epoch',
legendgroup='cur',
showlegend=False,
x=[rel_time[0]],
y=[orbit_points[0, 2]],
mode='markers',
marker={
'size': 10,
'color': 'blue'
})
rt_org = go.Scatter(name='Original Data',
legendgroup='org',
showlegend=False,
x=rel_time,
y=(data[:, 1]**2 + data[:, 2]**2 +
data[:, 3]**2)**0.5,
mode='markers',
marker={
'size': 5,
'color': 'black'
})
rt_fit = go.Scatter(
name='Fitted Ellipse',
legendgroup='fit',
showlegend=False,
x=rel_time,
y=((orbit_points[:, 0])**2 + (orbit_points[:, 1])**2 +
(orbit_points[:, 2])**2)**0.5,
mode='lines',
line={
'width': 2,
'color': 'red'
})
rt_cur = go.Scatter(
name='Position at Epoch',
legendgroup='cur',
showlegend=False,
x=[rel_time[0]],
y=[((orbit_points[0, 0])**2 + (orbit_points[0, 1])**2 +
(orbit_points[0, 2])**2)**0.5],
mode='markers',
marker={
'size': 10,
'color': 'blue'
})
t_fig = tools.make_subplots(rows=4, cols=1, shared_xaxes=True)
t_fig.append_trace(xt_org, 1, 1)
t_fig.append_trace(xt_fit, 1, 1)
t_fig.append_trace(xt_cur, 1, 1)
t_fig.append_trace(yt_org, 2, 1)
t_fig.append_trace(yt_fit, 2, 1)
t_fig.append_trace(yt_cur, 2, 1)
t_fig.append_trace(zt_org, 3, 1)
t_fig.append_trace(zt_fit, 3, 1)
t_fig.append_trace(zt_cur, 3, 1)
t_fig.append_trace(rt_org, 4, 1)
t_fig.append_trace(rt_fit, 4, 1)
t_fig.append_trace(rt_cur, 4, 1)
t_fig['layout']['xaxis1'].update(title='t (s)')
t_fig['layout']['yaxis1'].update(title='x ' +
'{}'.format(dropdown_value))
t_fig['layout']['yaxis2'].update(title='y ' +
'{}'.format(dropdown_value),
scaleanchor='y')
t_fig['layout']['yaxis3'].update(title='z ' +
'{}'.format(dropdown_value),
scaleanchor='y')
t_fig['layout']['yaxis4'].update(title='|r| ' +
'{}'.format(dropdown_value),
scaleanchor='y',
scaleratio=100)
t_fig['layout'].update(width=1050, height=700, margin={'t': 50})
t_fig['layout']['legend'].update(orientation='h')
res_x = go.Histogram(name='Δx', x=res[:, 0])
res_y = go.Histogram(name='Δy', x=res[:, 1])
res_z = go.Histogram(name='Δx', x=res[:, 2])
res_fig = tools.make_subplots(rows=1, cols=3, shared_yaxes=True)
res_fig.append_trace(res_x, 1, 1)
res_fig.append_trace(res_y, 1, 2)
res_fig.append_trace(res_z, 1, 3)
res_fig['layout']['yaxis1'].update(title='Frequency')
res_fig['layout']['xaxis1'].update(title='Δx ' +
'{}'.format(dropdown_value))
res_fig['layout']['xaxis2'].update(title='Δy ' +
'{}'.format(dropdown_value))
res_fig['layout']['xaxis3'].update(title='Δz ' +
'{}'.format(dropdown_value))
res_fig['layout'].update(margin={'t': 50}, showlegend=False)
coords_ecef, coord_times = ground_track(kep, data[0][0])
track = go.Scattergeo(name='Ground Trace',
lat=coords_ecef[:, 0],
lon=coords_ecef[:, 1],
text=coord_times,
mode='lines',
line={'color': 'red'})
track_cur = go.Scattergeo(name='Position at Epoch',
lat=[coords_ecef[0, 0]],
lon=[coords_ecef[0, 1]],
text=coord_times[0],
marker={
'size': 10,
'color': 'blue'
})
track_fig = go.Figure(data=[track, track_cur])
track_fig['layout'].update(height=600, width=1050, margin={'t': 50})
track_fig['layout']['geo']['lataxis'].update(showgrid=True,
dtick=30,
gridcolor='#ccc')
track_fig['layout']['geo']['lonaxis'].update(showgrid=True,
dtick=60,
gridcolor='#ccc')
track_fig['layout']['legend'].update(orientation='h')
return [
dcc.Markdown('''File Name: **''' + file_name + '''**'''),
html.Details([
html.Summary('''File Contents'''),
dt.DataTable(rows=data_dict, editable=False)
],
open=False),
html.Details([
html.Summary('''Computed Keplerian Elements'''),
dt.DataTable(rows=[
{
'Element': 'Semi-major Axis',
'Value': str(kep[0][0]) + '{}'.format(dropdown_value)
},
{
'Element': 'Eccentricity',
'Value': str(kep[1][0])
},
{
'Element': 'Inclination',
'Value': str(kep[2][0]) + ' °'
},
{
'Element': 'Argument of Periapsis',
'Value': str(kep[3][0]) + ' °'
},
{
'Element': 'Right Ascension of Ascending Node',
'Value': str(kep[4][0]) + ' °'
},
{
'Element': 'True Anomaly',
'Value': str(kep[5][0]) + ' °'
},
],
editable=False)
],
open=True),
html.Details([
html.Summary('''XYZ Plots'''),
dcc.Graph(id='xyz-plot', figure=xyz_fig)
],
open=True),
html.Details([
html.Summary('''Ground Track'''),
dcc.Graph(id='track-plot', figure=track_fig)
],
open=True),
html.Details([
html.Summary('''Time Plots'''),
dcc.Graph(id='t-plot', figure=t_fig)
],
open=True),
html.Details([
html.Summary('''Residuals'''),
dcc.Graph(id='res-plot', figure=res_fig),
dt.DataTable(rows=[{
' ':
'Maximum',
'Δx ' + '{}'.format(dropdown_value):
np.max(res[:, 0]),
'Δy ' + '{}'.format(dropdown_value):
np.max(res[:, 1]),
'Δz ' + '{}'.format(dropdown_value):
np.max(res[:, 2])
}, {
' ':
'Minimum',
'Δx ' + '{}'.format(dropdown_value):
np.min(res[:, 0]),
'Δy ' + '{}'.format(dropdown_value):
np.min(res[:, 1]),
'Δz ' + '{}'.format(dropdown_value):
np.min(res[:, 2])
}, {
' ':
'Average',
'Δx ' + '{}'.format(dropdown_value):
np.average(res[:, 0]),
'Δy ' + '{}'.format(dropdown_value):
np.average(res[:, 1]),
'Δz ' + '{}'.format(dropdown_value):
np.average(res[:, 2])
}, {
' ':
'Standard Deviation',
'Δx ' + '{}'.format(dropdown_value):
np.std(res[:, 0]),
'Δy ' + '{}'.format(dropdown_value):
np.std(res[:, 1]),
'Δz ' + '{}'.format(dropdown_value):
np.std(res[:, 2])
}],
editable=False)
],
open=True),
]
else:
return html.Div(children=[
html.Div(
'''There was an error processing this file.Try uploading another file in required format.'''
)
])
def update_figure(invar, invar_2, invar_3, outvar, invar1_log, invar2_log, invar3_log, outvar_log, param_slider,
graph_type, color_use, color_dd, error_use, error_dd, filter_active, fit_use, fit_dd, fit_num, fit_conf, add_noise_var, fit_color,
fit_opacity, fit_sampling, id_type, param_center, param_log):
for i in range(len(param_slider)):
if param_log[i] == ['log']:
param_slider[i] = [10**val for val in param_slider[i]]
param_center[i] = 10**param_center[i]
if invar is None:
return go.Figure()
sel_y = np.full((len(outdata),), True)
dds_value = []
for iteration, values in enumerate(param_slider):
dds_value.append(invars[id_type[iteration]['index']])
# filter for minimum
sel_y_min = np.array(indata[dds_value[iteration]] >= param_slider[iteration][0])
# filter for maximum
sel_y_max = np.array(indata[dds_value[iteration]] <= param_slider[iteration][1])
# print('iter ', iteration, 'filer', filter_active[iteration][0])
if filter_active != [[]]:
if filter_active[iteration] == ['act']:
sel_y = sel_y_min & sel_y_max & sel_y
if graph_type == '1D':
fig = go.Figure(
data=[go.Scatter(
x=indata[invar][sel_y],
y=outdata[outvar][sel_y],
mode='markers',
name='data',
error_y=dict(type='data', array=outdata[error_dd][sel_y], visible= error_use == ['true']),
# text=[(invar, outvar) for i in range(len(indata[invar][sel_y]))],
# hovertemplate=" %{text} <br> %{x} <br> %{y}",
)],
layout=go.Layout(xaxis=dict(title=invar, rangeslider=dict(visible=True)), yaxis=dict(title=outvar))
)
if fit_use == ['show']:
mesh_in, mesh_out, mesh_out_std, fit_dd_values = mesh_fit(param_slider, id_type, fit_dd, fit_num,
param_center, [invar], [invar1_log],
outvar, fit_sampling, add_noise_var)
for i in range(len(fit_dd_values)):
fig.add_trace(go.Scatter(
x=mesh_in[i][invars.index(invar)],
y=mesh_out[i],
mode='lines',
name=f'fit: {fit_dd}={fit_dd_values[i]:.1e}',
line_color=colormap(indata[fit_dd].min(), indata[fit_dd].max(), fit_dd_values[i]),
marker_line=dict(coloraxis="coloraxis2"),
))
fig.add_trace(go.Scatter(
x=np.hstack((mesh_in[i][invars.index(invar)], mesh_in[i][invars.index(invar)][::-1])),
y=np.hstack((mesh_out[i] + fit_conf * mesh_out_std[i], mesh_out[i][::-1] - fit_conf * mesh_out_std[i][::-1])),
showlegend=False,
fill='toself',
line_color=colormap(indata[fit_dd].min(), indata[fit_dd].max(), fit_dd_values[i]),
marker_line=dict(coloraxis="coloraxis2"),
opacity=fit_opacity,
))
elif graph_type == '2D':
fig = go.Figure(
data=[go.Scatter3d(
x=indata[invar][sel_y],
y=indata[invar_2][sel_y],
z=outdata[outvar][sel_y],
mode='markers',
name='Data',
error_z=dict(type='data', array=outdata[error_dd][sel_y], visible=error_use == ['true'], width= 10)
)],
layout=go.Layout(scene=dict(xaxis_title=invar, yaxis_title=invar_2, zaxis_title=outvar))
)
if fit_use == ['show'] and invar != invar_2:
mesh_in, mesh_out, mesh_out_std, fit_dd_values = mesh_fit(param_slider, id_type, fit_dd, fit_num,
param_center, [invar, invar_2],
[invar1_log, invar2_log], outvar,
fit_sampling, add_noise_var)
for i in range(len(fit_dd_values)):
fig.add_trace(go.Surface(
x=mesh_in[i][invars.index(invar)].reshape((fit_sampling, fit_sampling)),
y=mesh_in[i][invars.index(invar_2)].reshape((fit_sampling, fit_sampling)),
z=mesh_out[i].reshape((fit_sampling, fit_sampling)),
name=f'fit: {fit_dd}={fit_dd_values[i]:.2f}',
surfacecolor=fit_dd_values[i] * np.ones([fit_sampling, fit_sampling])
if fit_color == 'multi-fit' else
(mesh_in[i][invars.index(color_dd)].reshape((fit_sampling, fit_sampling))
if (fit_color == 'marker-color' and color_dd in invars) else
mesh_out[i].reshape((fit_sampling, fit_sampling))),
opacity=fit_opacity,
coloraxis="coloraxis2" if (fit_color == 'multi-fit' or
(fit_color == 'output' and (color_dd != outvar and color_dd != 'OUTPUT'))) else "coloraxis",
showlegend=True if len(invars) > 2 else False,
))
if fit_conf > 0:
fig.add_trace(go.Surface(
x=mesh_in[i][invars.index(invar)].reshape((fit_sampling, fit_sampling)),
y=mesh_in[i][invars.index(invar_2)].reshape((fit_sampling, fit_sampling)),
z=mesh_out[i].reshape((fit_sampling, fit_sampling)) + fit_conf * mesh_out_std[i].reshape((fit_sampling, fit_sampling)),
showlegend=False,
name=f'fit+v: {fit_dd}={fit_dd_values[i]:.2f}',
surfacecolor=fit_dd_values[i] * np.ones([fit_sampling, fit_sampling])
if fit_color == 'multi-fit' else
(mesh_in[i][invars.index(color_dd)].reshape((fit_sampling, fit_sampling))
if (fit_color == 'marker-color' and color_dd in invars) else
mesh_out[i].reshape((fit_sampling, fit_sampling))),
opacity=fit_opacity,
coloraxis="coloraxis2" if (fit_color == 'multi-fit' or
(fit_color == 'output' and (color_dd != outvar and color_dd != 'OUTPUT')))
else "coloraxis",
))
fig.add_trace(go.Surface(
x=mesh_in[i][invars.index(invar)].reshape((fit_sampling, fit_sampling)),
y=mesh_in[i][invars.index(invar_2)].reshape((fit_sampling, fit_sampling)),
z=mesh_out[i].reshape((fit_sampling, fit_sampling)) - fit_conf * mesh_out_std[i].reshape((fit_sampling, fit_sampling)),
showlegend=False,
name=f'fit-v: {fit_dd}={fit_dd_values[i]:.2f}',
surfacecolor=fit_dd_values[i] * np.ones([fit_sampling, fit_sampling])
if fit_color == 'multi-fit' else
(mesh_in[i][invars.index(color_dd)].reshape((fit_sampling, fit_sampling))
if (fit_color == 'marker-color' and color_dd in invars) else
mesh_out[i].reshape((fit_sampling, fit_sampling))),
opacity=fit_opacity,
coloraxis="coloraxis2" if (fit_color == 'multi-fit' or
(fit_color == 'output' and (color_dd != outvar and color_dd != 'OUTPUT')))
else "coloraxis",
))
fig.update_layout(coloraxis2=dict(
colorbar=dict(title=outvar if fit_color == 'output' else fit_dd),
cmin=min(fit_dd_values) if fit_color == 'multi-fit' else None,
cmax=max(fit_dd_values) if fit_color == 'multi-fit' else None,
))
elif graph_type == '2D contour':
mesh_in, mesh_out, mesh_out_std, fit_dd_values = mesh_fit(param_slider, id_type, fit_dd, fit_num,
param_center, [invar, invar_2],
[invar1_log, invar2_log], outvar,
fit_sampling, add_noise_var)
data_x = mesh_in[0][invars.index(invar)]
data_y = mesh_in[0][invars.index(invar_2)]
fig = go.Figure()
if min(data_x) != max(data_x):
if min(data_y) != max(data_y):
fig.add_trace(go.Scatter(
x=indata[invar][sel_y],
y=indata[invar_2][sel_y],
mode='markers',
name='Data',
))
fig.add_trace(go.Contour(
x=mesh_in[0][invars.index(invar)],
y=mesh_in[0][invars.index(invar_2)],
z=mesh_out[0],
contours_coloring='heatmap',
contours_showlabels=True,
coloraxis='coloraxis2',
name='fit',
))
fig.update_xaxes(
range=[log10(min(fig.data[1]['x'])), log10(max(fig.data[1]['x']))] if invar1_log == ['log']
else [min(fig.data[1]['x']), max(fig.data[1]['x'])])
fig.update_yaxes(
range=[log10(min(fig.data[1]['y'])), log10(max(fig.data[1]['y']))] if invar2_log == ['log']
else [min(fig.data[1]['y']), max(fig.data[1]['y'])])
fig.update_layout(xaxis_title=invar,
yaxis_title=invar_2,
coloraxis2=dict(colorbar=dict(title=outvar),
colorscale='solar',
cmin=min(fig.data[1]['z']),
cmax=max(fig.data[1]['z'])))
else:
fig.update_layout(title="y-data is constant, no contour-plot possible")
else:
fig.update_layout(title="x-data is constant, no contour-plot possible")
elif graph_type == '3D':
fig = go.Figure(
data=go.Scatter3d(
x=indata[invar][sel_y],
y=indata[invar_2][sel_y],
z=indata[invar_3][sel_y],
mode='markers',
marker=dict(
color=outdata[outvar][sel_y],
coloraxis="coloraxis2",
),
name='Data',
),
layout=go.Layout(scene=dict(xaxis_title=invar, yaxis_title=invar_2, zaxis_title=invar_3)),
)
fig.update_layout(coloraxis2=dict(
colorbar=dict(title=outvar),
))
if fit_use == ['show'] and len({invar, invar_2, invar_3}) == 3:
mesh_in, mesh_out, mesh_out_std, fit_dd_values = mesh_fit(param_slider, id_type, fit_dd, fit_num,
param_center, [invar, invar_2, invar_3],
[invar1_log, invar2_log, invar3_log], outvar,
fit_sampling, add_noise_var)
for i in range(len(fit_dd_values)):
fig.add_trace(
go.Isosurface(
x=mesh_in[i][invars.index(invar)],
y=mesh_in[i][invars.index(invar_2)],
z=mesh_in[i][invars.index(invar_3)],
value=mesh_out[i],
surface_count=fit_num,
coloraxis="coloraxis2",
isomin=mesh_out[i].min() * 1.1,
isomax=mesh_out[i].max() * 0.9,
caps=dict(x_show=False, y_show=False, z_show=False),
opacity=fit_opacity,
),
)
else:
fig = go.Figure()
fig.update_layout(legend=dict(xanchor="left", x=0.01))
# log scale
log_dict = {'1D': (invar1_log, outvar_log),
'2D': (invar1_log, invar2_log, outvar_log),
'2D contour': (invar1_log, invar2_log),
'3D': (invar1_log, invar2_log, invar3_log),}
log_list = ['linear' if log is None or len(log) == 0 else log[0] for log in log_dict[graph_type]]
log_key = ['xaxis', 'yaxis', 'zaxis']
comb_dict = dict(zip(log_key, [{'type': log} for log in log_list]))
if len(log_list) < 3 :
fig.update_layout(**comb_dict)
else:
fig.update_scenes(**comb_dict)
# color
if color_use == ['true']: # TODO: trigger-detection no new fig just update
if fit_use == ['show'] and (graph_type=='2D' and (fit_color=='multi-fit' and color_dd==fit_dd)):
fig.update_traces(
marker=dict(
coloraxis="coloraxis2",
color=indata[color_dd][sel_y] if color_dd in indata.dtype.names else outdata[color_dd][sel_y],
),
selector=dict(mode='markers'),
)
elif graph_type == '3D':
fig.update_traces(
marker=dict(
coloraxis="coloraxis2",
color=outdata[outvar][sel_y],
),
selector=dict(mode='markers'),
)
elif graph_type=='1D':
fig.update_traces(
marker=dict(
coloraxis="coloraxis2",
color=outdata[outvar][sel_y] if color_dd == 'OUTPUT' else
(indata[color_dd][sel_y] if color_dd in indata.dtype.names else outdata[color_dd][sel_y]),
),
selector=dict(mode='markers'),
)
if color_dd==fit_dd:
fig.update_layout(coloraxis2=dict(colorscale='cividis', colorbar=dict(title=fit_dd)))
elif color_dd == 'OUTPUT':
fig.update_layout(coloraxis2=dict(colorscale='plasma', colorbar=dict(title=outvar)))
else:
fig.update_layout(coloraxis2=dict(colorscale='plasma', colorbar=dict(title=color_dd)))
elif graph_type =='2D contour':
fig.update_traces(
marker=dict(
coloraxis="coloraxis",
color=outdata[outvar][sel_y] if color_dd == 'OUTPUT' else
(indata[color_dd][sel_y] if color_dd in indata.dtype.names else outdata[color_dd][sel_y]),
),
selector=dict(mode='markers'),
)
if color_dd == outvar or color_dd == 'OUTPUT':
fig.update_traces(marker_coloraxis="coloraxis2", selector=dict(mode='markers'))
else:
fig.update_layout(coloraxis=dict(colorbar=dict(title=color_dd, x=1.1),
colorscale='ice'))
else:
fig.update_traces(
marker=dict(
coloraxis="coloraxis",
color=outdata[outvar][sel_y] if color_dd == 'OUTPUT' else
(indata[color_dd][sel_y] if color_dd in indata.dtype.names else outdata[color_dd][sel_y]),
),
selector=dict(mode='markers'),
)
fig.update_layout(coloraxis=dict(
colorbar=dict(title=outvar if color_dd == 'OUTPUT' else color_dd, x=1.1),
colorscale='viridis',
))
fig.update_layout(height=graph_height)
return fig
import fovea_plot as fp
import plotly.graph_objs as go
import numpy as np
x, y, z = np.random.multivariate_normal(np.array([0,0,0]), np.eye(3), 200).transpose()
trace1 = go.Scatter3d(
x=x,
y=y,
z=z,
mode='markers',
marker=dict(
size=12,
line=dict(
color='rgba(217, 217, 217, 0.14)',
width=0.5
),
opacity=0.8
)
)
x2, y2, z2 = np.random.multivariate_normal(np.array([0,0,0]), np.eye(3), 200).transpose()
trace2 = go.Scatter3d(
x=x2,
y=y2,
z=z2,
mode='markers',
marker=dict(
color='rgb(127, 127, 127)',
size=12,
symbol='circle',
def plot_lab(pix, img):
'''
Plots colors in CIELAB color space in plotly 3D Scatter plot
'''
colors = [
'rgb(' + str(r) + ',' + str(g) + ',' + str(b) + ')'
for (r, g, b) in pix
]
x, y, z = [], [], []
for item in pix:
R, G, B = item[0] / 255, item[1] / 255, item[2] / 255
if R > 0.04045:
R = math.pow(((R + 0.055) / 1.055), 2.4)
else:
R = R / 12.92
if G > 0.04045:
G = math.pow(((G + 0.055) / 1.055), 2.4)
else:
G = G / 12.92
if B > 0.04045:
B = math.pow(((B + 0.055) / 1.055), 2.4)
else:
B = B / 12.92
R *= 100
G *= 100
B *= 100
X = (R * 0.4124) + (G * 0.3576) + (B * 0.1805)
Y = (R * 0.2126) + (G * 0.7152) + (B * 0.0722)
Z = (R * 0.0193) + (G * 0.1192) + (B * 0.9505)
X = X / 95.047
Y = Y / 100
Z = Z / 108.883
if X > 0.008856:
fx = (math.pow(X, 1 / 3))
else:
fx = ((903.3 * X) + 16) / 116
if Y > 0.008856:
fy = (math.pow(Y, 1 / 3))
else:
fy = ((903.3 * Y) + 16) / 116
if Z > 0.008856:
fz = (math.pow(Z, 1 / 3))
else:
fz = ((903.3 * Z) + 16) / 116
L = (116 * fy) - 16
a = 500 * (fx - fy)
b = 200 * (fy - fz)
x.append(L)
y.append(a)
z.append(b)
trace0 = go.Scatter3d(x=x,
y=y,
z=z,
mode='markers',
marker=dict(size=4, color=colors, opacity=0.8))
data = [trace0]
layout = go.Layout(title=img,
scene=dict(
xaxis=dict(title="L*", range=[0, 100]),
yaxis=dict(title="a*", range=[-86.185, 98.254]),
zaxis=dict(title="b*", range=[-107.863, 94.482]),
),
margin=dict(l=0, r=0, b=25, t=50))
fig = go.Figure(data=data, layout=layout)
plotly.offline.plot(fig, filename=img + 'Lab')
def plot_3Dwaypoint_neighbors_center_goal_start():
X = ( -2.5, -2.5, -2.5, -2.5, -2.300000191, -2.699999809, )
Y = ( -3.900000095, -3.900000095, -4.099999905, -3.700000286, -3.900000095, -3.900000095, )
Z = ( 3.100000143, 3.499999762, 3.299999952, 3.299999952, 3.299999952, 3.299999952, )
X_A = ( -2.599999905, -2.5, -2.700000048, )
Y_A = ( -3.799999952, -4.099999905, -3.900000095, )
Z_A = ( 3, 3.299999952, 3.299999952, )
X_UNKNOWN = ( -2.5, -2.5, -2.300000191, )
Y_UNKNOWN = ( -3.900000095, -3.700000286, -3.900000095, )
Z_UNKNOWN = ( 3.499999762, 3.299999952, 3.299999952, )
trace_neighbors_unknown = go.Scatter3d(
x= X_UNKNOWN,
y= Y_UNKNOWN,
z= Z_UNKNOWN,
mode='markers',
name = "Unknown",
marker=dict(
size=12,
)
)
trace_neighbors_raw = go.Scatter3d(
x= X,
y= Y,
z= Z,
mode='markers',
name = "Raw",
marker=dict(
size=12,
)
)
trace_neighbors_centers = go.Scatter3d(
x= X_A,
y= Y_A,
z= Z_A,
mode='markers',
name = "Centers",
marker=dict(
size=12,
)
)
trace_center = go.Scatter3d(
x=(-2.5, ),
y=(-3.9, ),
z=(3.3, ) ,
mode='markers',
name = "Start center",
marker=dict(
size=12,
)
)
goal_point_coordinates = (2.0, 5.2, 1.2)
trace_end_point = go.Scatter3d(
x=(goal_point_coordinates[0], ),
y=(goal_point_coordinates[1], ),
z=(goal_point_coordinates[2], ) ,
mode='markers',
name = "End POINT",
marker=dict(
size=12,
)
)
traces = [trace_neighbors_centers, trace_neighbors_raw, trace_center, trace_neighbors_unknown, trace_end_point]
layout = go.Layout(
)
plotly.offline.plot({
"data": traces,
"layout": layout,
},
filename= 'plots/3d_neighbors.html')
means_k.fit(X)
labels = means_k.labels_
centroids = means_k.cluster_centers_
# In[125]:
#Create a 3d plot to view the data sepparation made by Kmeans
trace1 = go.Scatter3d(
x= X['Spending Score (1-100)'],
y= X['Annual Income (k$)'],
z= X['Age'],
mode='markers',
marker=dict(
color = labels,
size= 10,
line=dict(
color= labels,
),
opacity = 0.9
)
)
layout = go.Layout(
title= 'Clusters',
scene = dict(
xaxis = dict(title = 'Spending_score'),
yaxis = dict(title = 'Annual_income'),
zaxis = dict(title = 'Age')
)
)
fig = go.Figure(data=trace1, layout=layout)
import plotly.offline as offline
import pdb
X = empty((0, 3), float)
for i in range(0, 180):
phi = deg2rad(i)
theta = deg2rad(20 * i)
x = array([cos(theta), sin(theta), phi])
X = vstack([X, x])
# pdb.set_trace()
trace = go.Scatter3d(x=X[:, 0],
y=X[:, 1],
z=X[:, 2],
marker=dict(
size=2,
color='#DC143C',
colorscale='Viridis',
))
# trace2 = go.Scatter3d(
# x=wave2[:,0], y=wave2[:,1], z=wave2[:,2],
# marker=dict(
# size=2,
# color='#32CD32',
# colorscale='Viridis',
# )
# )
# data = [trace,trace2]
data = [trace]
layout = dict(
title='Iris dataset',
def draw3Dplotly(x_name, y_name, z_name, algorithm, output_type = 'div'):
tags = pickle.loads(rds.get(tags_map[algorithm]))
data = []
for i in pd.Series(tags).sort_values().unique():
ww = tags == i
ddd = df[ww]
xyz_info = ('<br>此產品'
'<br>'+ to_chinese[x_name] +': ' + ddd[x_name].astype(str) +
'<br>'+ to_chinese[y_name] +': ' + ddd[y_name].astype(str) +
'<br>'+ to_chinese[z_name] +': ' + ddd[z_name].astype(str) )
if ((algorithm == 'DBSCAN') & (i == -1))|((algorithm == 'WaveCluster') & (i == 0)):
trace = go.Scatter3d(
name = '噪音點',
x = ddd[x_name],
y = ddd[y_name],
z = ddd[z_name],
mode = 'markers',
hoverinfo = 'text',
text = ddd.index + '<br>是噪音點，總共 {} 個'.format(len(ddd)) + xyz_info,
marker=dict(
size = 5,
opacity=0.5
)
)
data.append(trace)
else:
trace = go.Scatter3d(
name = '群 {}'.format(i),
x = ddd[x_name],
y = ddd[y_name],
z = ddd[z_name],
mode = 'markers',
hoverinfo = 'text',
text = ddd.index + '<br>位於第 {} 群<br>群的大小: {}'.format(i, len(ddd)) + xyz_info,
marker=dict(
size = 5,
opacity=0.5
)
)
data.append(trace)
layout= go.Layout(
height=720,
# title= '{} 與 {} 與 {} 之分布'.format(to_chinese[x_name], to_chinese[y_name], to_chinese[z_name]),
# titlefont=dict(
# size=30
# ),
margin=dict(
l=0,
r=0,
b=0,
t=50
),
scene=dict(
xaxis=dict(
title= to_chinese[x_name],
titlefont=dict(
size=18
),
range=[0, df[x_name].max()]
),
yaxis=dict(
title= to_chinese[y_name],
titlefont=dict(
size=18
),
range=[0, df[y_name].max()]
),
zaxis=dict(
title= to_chinese[z_name],
titlefont=dict(
size=18
),
range=[0, df[z_name].max()]
)
)
)
fig= {'data':data,'layout':layout}
div = plot(fig, output_type = output_type, config=conf)
return(div)
def generate_comparison_plot(plot_data, data_keys, field_names=None):
print(field_names)
if field_names is None:
field_names = data_keys
ptitle = 'MegaQC Comparison Plot'
plot_x = []
plot_y = []
plot_z = []
plot_col = []
plot_size = []
plot_names = []
annotations = go.Annotations([])
for s_name in plot_data:
plot_names.append(s_name)
try:
plot_x.append(plot_data[s_name][data_keys['x']])
plot_y.append(plot_data[s_name][data_keys['y']])
except KeyError:
print("Couldn't find key {} (available: {})".format(plot_data[s_name].keys(), data_keys))
try:
plot_z.append(plot_data[s_name][data_keys['z']])
except KeyError:
plot_z.append(None)
try:
plot_col.append(plot_data[s_name][data_keys['col']])
except KeyError:
plot_col.append(None)
try:
plot_size.append(plot_data[s_name][data_keys['size']])
except KeyError:
plot_size.append(None)
# Colour with a colour scale
markers = {}
if not all([x == None for x in plot_col]):
markers['color'] = plot_col
markers['colorscale'] = 'Viridis'
markers['showscale'] = True
annotations.append(go.Annotation(
text = field_names['col'],
x = 1.02,
y = 0.5,
textangle= - 90,
xref = 'paper',
yref = 'paper',
showarrow = False
))
# Scale the marker size according to a variable
if not all([x == None for x in plot_size]):
smax = max([x for x in plot_size if type(x) is float])
smin = min([x for x in plot_size if type(x) is float])
srange = smax - smin
if srange > 0:
norm_plot_size = []
for x in plot_size:
if type(x) is float:
norm_plot_size.append((((x - smin)/srange)*35)+2)
else:
norm_plot_size.append(2)
markers['size'] = norm_plot_size
ptitle += '<br><span style="font-size:0.7rem">Marker Size represents "{}"</span>'.format(field_names['size'])
plot_height = 600
if all([x == None for x in plot_z]):
fig = go.Scatter(
x = plot_x,
y = plot_y,
mode = 'markers',
marker = markers,
text = plot_names
)
else:
markers.update({'opacity':0.8})
fig = go.Scatter3d(
x = plot_x,
y = plot_y,
z = plot_z,
mode = 'markers',
marker = markers,
text = plot_names
)
plot_height = 800
# Make the plot
layout = go.Layout(
title = ptitle,
# For 2D plots
xaxis = dict(
title = field_names['x']
),
yaxis = dict(
title = field_names['y']
),
# For 3D plots
scene = dict(
xaxis = dict(
title = field_names['x']
),
yaxis = dict(
title = field_names['y']
),
zaxis = dict(
title = field_names['z']
),
),
annotations = annotations,
height = plot_height
)
plot_div = py.plot(
go.Figure(data = [fig], layout = layout),
output_type = 'div',
show_link = False,
config = dict(
modeBarButtonsToRemove = [
'sendDataToCloud',
'resetScale2d',
'hoverClosestCartesian',
'hoverCompareCartesian',
'toggleSpikelines'
],
displaylogo = False
)
)
return plot_div
def display(m, wireframe=True, smooth=True, data=None):
""" The display function shows an interactive presentation of the Manifold, m, inside
a Jupyter Notebook. wireframe=True means that a wireframe view of the mesh is
superimposed on the 3D model. If smooth=True, the mesh is rendered with vertex
normals. Otherwise, the mesh is rendered with face normals. If data=None, the
mesh is shown in a light grey color. If data contains an array of scalar values
per vertex, these are mapped to colors used to color the mesh. Finally, note that
m can also be a Graph. In that case the display function just draws the edges as
black lines. """
mesh_data = []
if isinstance(m, hmesh.Manifold):
xyz = array([p for p in m.positions()])
m_tri = hmesh.Manifold(m)
hmesh.triangulate(m_tri)
ijk = array([[idx for idx in m_tri.circulate_face(f, 'v')]
for f in m_tri.faces()])
mesh = go.Mesh3d(x=xyz[:, 0],
y=xyz[:, 1],
z=xyz[:, 2],
i=ijk[:, 0],
j=ijk[:, 1],
k=ijk[:, 2],
color='#dddddd',
flatshading=not smooth)
if data is not None:
mesh['intensity'] = data
mesh_data += [mesh]
if wireframe:
pos = m.positions()
xyze = []
for h in m.halfedges():
if h < m.opposite_halfedge(h):
p0 = pos[m.incident_vertex(m.opposite_halfedge(h))]
p1 = pos[m.incident_vertex(h)]
xyze.append(array(p0))
xyze.append(array(p1))
xyze.append(array([None, None, None]))
xyze = array(xyze)
trace1 = go.Scatter3d(x=xyze[:, 0],
y=xyze[:, 1],
z=xyze[:, 2],
mode='lines',
line=dict(color='rgb(125,0,0)', width=1),
hoverinfo='none')
mesh_data += [trace1]
elif isinstance(m, graph.Graph):
pos = m.positions()
xyze = []
for v in m.nodes():
for w in m.neighbors(v):
if v < w:
p0 = pos[v]
p1 = pos[w]
xyze.append(array(p0))
xyze.append(array(p1))
xyze.append(array([None, None, None]))
xyze = array(xyze)
trace1 = go.Scatter3d(x=xyze[:, 0],
y=xyze[:, 1],
z=xyze[:, 2],
mode='lines',
line=dict(color='rgb(0,0,0)', width=1),
hoverinfo='none')
mesh_data += [trace1]
lyt = go.Layout(width=850, height=800)
lyt.scene.aspectmode = "data"
if EXPORT_MODE:
py.iplot(dict(data=mesh_data, layout=lyt))
else:
return go.FigureWidget(mesh_data, lyt)
from plotly.offline import init_notebook_mode
import plotly.graph_objs as go
plotly.offline.init_notebook_mode(connected=True)
# In[29]:
x, y, z = np.random.multivariate_normal(np.array([0,0,0]), np.eye(3), 200).transpose()
trace0 = go.Scatter3d(
x=np.array(t1_0),
y=np.array(t2_0),
z=np.array(t3_0),
#colors = np.array(labels),
mode='markers',
marker=dict(
size=12,
#color='rgb(255, 0, 255)',
line=dict(
color='rgba(217, 217, 217, 0.14)',
width=0.1
),
opacity=0.7
)
)
trace1 = go.Scatter3d(
x=np.array(t1_1),
y=np.array(t2_1),
z=np.array(t3_1),
mode='markers',
marker=dict(
size=12,
color='rgb(127, 127, 127)',
def plot_tria_mesh(tria, vfunc=None, plot_edges=None, plot_levels=False, tfunc=None,
edge_color='rgb(50,50,50)', tic_color='rgb(50,200,10)', html_output=False,
width=800, height=800, flatshading=False,
xrange=None, yrange=None, zrange=None,
showcaxis=False, caxis=None):
# interesting example codes:
# https://plot.ly/~empet/14749/mesh3d-with-intensities-and-flatshading/#/
#
if type(tria).__name__ != "TriaMesh":
raise ValueError('plot_tria_mesh works only on TriaMesh class')
x, y, z = zip(*tria.v)
i, j, k = zip(*tria.t)
vlines = []
if vfunc is None:
if tfunc is None:
triangles = go.Mesh3d(x=x, y=y, z=z, i=i, j=j, k=k, flatshading=flatshading)
elif tfunc.ndim == 1 or (tfunc.ndim == 2 and np.min(tfunc.shape) == 1):
# scalar tfunc
min_fcol = np.min(tfunc)
max_fcol = np.max(tfunc)
# special treatment for constant functions
if np.abs(min_fcol - max_fcol) < 0.0001:
if np.abs(max_fcol) > 0.0001:
min_fcol = -np.abs(min_fcol)
max_fcol = np.abs(max_fcol)
else: # both are zero
min_fcol = -1
max_fcol = 1
# if min_fcol >= 0 and max_fcol <= 1:
# min_fcol = 0
# max_fcol = 1
# colormap = cm.RdBu
colormap = _get_colorscale(min_fcol, max_fcol)
facecolor = [_map_z2color(zz, colormap, min_fcol, max_fcol) for zz in tfunc]
# for tria colors overwrite flatshading to be true:
triangles = go.Mesh3d(x=x, y=y, z=z, i=i, j=j, k=k,
facecolor=facecolor,
flatshading=True)
elif tfunc.ndim == 2 and np.min(tfunc.shape) == 3:
# vector tfunc
s = 0.7 * tria.avg_edge_length()
centroids = (1.0/3.0) * (tria.v[tria.t[:, 0], :] + tria.v[tria.t[:, 1], :]
+ tria.v[tria.t[:, 2], :])
xv = np.column_stack(
(centroids[:, 0], centroids[:, 0] + s * tfunc[:, 0],
np.full(tria.t.shape[0], np.nan))).reshape(-1)
yv = np.column_stack(
(centroids[:, 1], centroids[:, 1] + s * tfunc[:, 1],
np.full(tria.t.shape[0], np.nan))).reshape(-1)
zv = np.column_stack(
(centroids[:, 2], centroids[:, 2] + s * tfunc[:, 2],
np.full(tria.t.shape[0], np.nan))).reshape(-1)
vlines = go.Scatter3d(x=xv, y=yv, z=zv, mode='lines',
line=dict(color=tic_color, width=2))
triangles = go.Mesh3d(x=x, y=y, z=z, i=i, j=j, k=k, flatshading=flatshading)
else:
raise ValueError('tfunc should be scalar (face color) or 3d for each triangle')
elif vfunc.ndim == 1 or (vfunc.ndim == 2 and np.min(vfunc.shape) == 1):
# scalar vfunc
if plot_levels:
colorscale = _get_color_levels()
else:
colorscale = _get_colorscale(min(vfunc), max(vfunc))
triangles = go.Mesh3d(x=x, y=y, z=z, i=i, j=j, k=k,
intensity=vfunc,
colorscale=colorscale,
flatshading=flatshading)
elif vfunc.ndim == 2 and np.min(vfunc.shape) == 3:
# vector vfunc
s = 0.7 * tria.avg_edge_length()
xv = np.column_stack(
(tria.v[:, 0], tria.v[:, 0] + s * vfunc[:, 0],
np.full(tria.v.shape[0], np.nan))).reshape(-1)
yv = np.column_stack(
(tria.v[:, 1], tria.v[:, 1] + s * vfunc[:, 1],
np.full(tria.v.shape[0], np.nan))).reshape(-1)
zv = np.column_stack(
(tria.v[:, 2], tria.v[:, 2] + s * vfunc[:, 2],
np.full(tria.v.shape[0], np.nan))).reshape(-1)
vlines = go.Scatter3d(x=xv, y=yv, z=zv, mode='lines', line=dict(color=tic_color, width=2))
triangles = go.Mesh3d(x=x, y=y, z=z, i=i, j=j, k=k, flatshading=flatshading)
else:
raise ValueError('vfunc should be scalar or 3d for each vertex')
if plot_edges:
# 4 points = three edges for each tria, nan to separate triangles
# this plots every edge twice (except boundary edges)
xe = np.column_stack(
(tria.v[tria.t[:, 0], 0], tria.v[tria.t[:, 1], 0], tria.v[tria.t[:, 2], 0],
tria.v[tria.t[:, 0], 0], np.full(tria.t.shape[0], np.nan))).reshape(-1)
ye = np.column_stack(
(tria.v[tria.t[:, 0], 1], tria.v[tria.t[:, 1], 1], tria.v[tria.t[:, 2], 1],
tria.v[tria.t[:, 0], 1], np.full(tria.t.shape[0], np.nan))).reshape(-1)
ze = np.column_stack(
(tria.v[tria.t[:, 0], 2], tria.v[tria.t[:, 1], 2], tria.v[tria.t[:, 2], 2],
tria.v[tria.t[:, 0], 2], np.full(tria.t.shape[0], np.nan))).reshape(-1)
# define the lines to be plotted
lines = go.Scatter3d(x=xe,
y=ye,
z=ze,
mode='lines',
line=dict(color=edge_color, width=1.5)
)
data = [triangles, lines]
else:
data = [triangles]
if vlines:
data.append(vlines)
# line_marker = dict(color='#0066FF', width=2)
noaxis = dict(showbackground=False,
showline=False,
zeroline=False,
showgrid=False,
showticklabels=False,
title='')
layout = go.Layout(
width=width,
height=height,
scene=dict(
xaxis=noaxis,
yaxis=noaxis,
zaxis=noaxis
)
)
if xrange is not None:
layout.scene.xaxis.update(range=xrange)
if yrange is not None:
layout.scene.yaxis.update(range=yrange)
if zrange is not None:
layout.scene.zaxis.update(range=zrange)
data[0].update(showscale=showcaxis)
if caxis is not None:
data[0].update(cmin=caxis[0])
data[0].update(cmax=caxis[1])
fig = go.Figure(data=data, layout=layout)
if not html_output:
plotly.offline.iplot(fig)
else:
plotly.offline.plot(fig)
def plot(df, title, colorscale="blues", color_on="speed"):
"""
Args:
df and title trivial
colorscale `str`: the scale to use for coloring
color_one `str`: one of "density", "time", "speed" - select
the dimension getting colored
Upon success a plotly-JSON-encoded graph is returned.
"""
# prepare bins
try:
bin_max = int(df.Download.max()) + 2
except ValueError: # the case of only Nan
bin_max = 2
# prepare grouping by a given time unit
df["Time"] = [
ts.replace(hour=0, minute=0, second=0, microsecond=0)
for ts in df["tslocal"]
]
# append bins for Download values
df["Speed"] = pd.cut(
x=df.Download,
bins=range(bin_max),
labels=range(bin_max - 1),
right=False,
)
# append a density column to aggregate
df["Density"] = 1
# cleanup before grouping
d3 = df.drop(["Download", "Upload"], axis=1)
# GroupBy with dimensions time, speed, density
g3 = d3.groupby(by=[d3.Time, d3.Speed], as_index=False).sum()
# make the graph
fig = go.Figure()
fig.add_trace(
go.Scatter3d(
x=[0] * len(df.Density),
y=df.tslocal,
z=df.Download,
name="rug",
mode="markers",
marker=dict(size=2),
))
# default marker, accentuating speed in blues
marker = dict(size=6, opacity=0.9, color=g3.Speed)
marker["colorscale"] = colorscale
if color_on == "density":
marker["color"] = g3.Density
elif color_on == "time":
marker["color"] = g3.Time - g3.Time.min()
# else the above default is used
fig.add_trace(
go.Scatter3d(
x=g3.Density,
y=g3.Time,
z=g3.Speed,
name="density",
mode="markers",
marker=marker,
))
# TODO Graph width/ height: plotly only accepts px values so far,
# so set these with care and watch out for API improvements.
fig.layout = dict(
title_text=title,
yaxis=go.layout.YAxis(type="date"),
scene_camera_eye=dict(x=0.6, y=2, z=-0.1),
scene=dict(
xaxis_title="density (no unit)",
yaxis_title="time",
zaxis_title="speed (Mbit/s)",
),
height=768,
)
return json.dumps(fig, cls=plotly.utils.PlotlyJSONEncoder)
def create_image(
request,
numb,
): # Representación Nube de puntos.
document = Document.objects.filter(user=request.user).get(numb=numb)
filename = document.document.path
nombre = document.Nombre
pcd = read_point_cloud(filename)
pcd_array = (np.asarray(pcd.points))
x = []
y = []
z = []
for row in pcd_array:
x.append(float(row[0]))
y.append(float(row[1]))
z.append(float(row[2]))
trace1 = go.Scatter3d(
x=x,
y=y,
z=z,
mode='markers',
marker=dict(
size=0.75,
color=z,
colorscale='Earth',
symbol='circle',
),
)
data = [trace1]
layout = go.Layout(
paper_bgcolor='rgba(40,57,90,.8)',
#paper_bgcolor='rgba(40,57,90,.9)',
scene=dict(
xaxis=dict(
showline=False,
showticklabels=False,
showgrid=False,
zeroline=False,
range=[-125, 125],
),
yaxis=dict(
showline=False,
showticklabels=False,
showgrid=False,
zeroline=False,
range=[-125, 125],
),
zaxis=dict(
showline=False,
showticklabels=False,
showgrid=False,
zeroline=False,
range=[-125, 125],
),
),
width=950,
height=750,
showlegend=False)
fig = go.Figure(
data=data,
layout=layout,
)
plot_div = plot(fig, output_type='div', include_plotlyjs=False)
form = DescriptionForm(request.POST or None)
if request.method == 'POST':
message = get_object_or_404(Document, numb=numb)
form = DescriptionForm(request.POST, instance=message)
if form.is_valid():
form.save()
context = {
"form": form,
"plot": plot_div,
"filename": nombre,
"Document": document,
}
return render(request, 'Document/plot.html', context)
def user_scatter_plot(user_features):
job_groups = get_job_groups()
# Scatter latitude (x), longitude(y), and Age(z), and color code by occupation
lat = np.array(
[fhf.get_zip_data(z, 'latitude') for z in user_features.zip_code])
lon = np.array(
[fhf.get_zip_data(z, 'longitude') for z in user_features.zip_code])
x = lat / 90
y = lon / 180
z = np.array(user_features.normed_age *
130) #Age was normalized by 130, un-normalize for plot
# Generate a list of colors for plotting, one for each job group
color_list = fhf.get_N_HexCol(len(job_groups.keys()), 0.6, 0.75)
# Generate the employment bins, and for each one, generate its scatter plot data
traces = []
for ei, e in enumerate(job_groups.keys()):
# Generate the employment bins
e_idx = []
for jobs in e:
e_idx.extend(np.where(user_features[jobs] == 1)[0].tolist())
e_idx = np.array(e_idx)
# Generate the scatter data for each bin, and append it to the 'traces' list
# which we will then plot
x_i = x[e_idx]
y_i = y[e_idx]
z_i = z[e_idx]
traces.append(
go.Scatter3d(x=x_i,
y=y_i,
z=z_i,
name=job_groups[e],
mode='markers',
marker=dict(color=color_list[ei],
size=5,
line=dict(color='rgba(58, 71, 80, 1.0)',
width=0.5),
opacity=0.8)))
# Set up the 3d plot's camera position
camera = dict(
#up=dict(x=0, y=0, z=1),
#center=dict(x=0, y=0, z=0),
eye=dict(x=1.35, y=1.35, z=0.65))
# Set up the plot's layout
layout = dict(
#height = 650,
height=500,
width=780,
#width = 900,
scene=dict(camera=camera,
xaxis=dict(title='Latitude', ),
yaxis=dict(title='Longitude', ),
zaxis=dict(title='Age', )),
margin=dict(
l=30,
r=30,
t=30,
b=30,
),
)
# Get plotting traces and layout
return traces, layout
def scat3d(dfxyz=None,
xyzcols=None,
tagcol=None,
title='plot',
height=800,
width=800):
"""
plotly 3D scatter plot
ARGUMENTS:
dfxyz dataframe with x,y,z coordinates
colxyz column names for x,y,z in the dataframe
TODO: add group tags(for the legend) and neuronID tags(hoverinfo) to the dataframe
"""
tag = 'tag'
tfont = dict(family='Courier New, monospace', size=18, color='#3f3f3f')
lblX = xyzcols[0]
lblY = xyzcols[1]
lblZ = xyzcols[2]
autosize = False
opacity = 1 #0.99 # opacity=1 required for true 3d rendering! (but opacity=1 breaks hoverinfo)
lw = 2
#ad_marker=dict(size=4,color='grey',opacity=0.3)
margin = dict(l=10, r=100, b=10, t=50)
pltdata = []
if tagcol is not None:
for tag in dfxyz[tagcol].unique():
dfi = dfxyz[dfxyz[tagcol] == tag]
pltfmt = dict(line=dict(width=lw),
opacity=opacity,
mode='markers',
name=tag)
pltfmt['legendgroup'] = tag
pltfmt['hoverinfo'] = 'none'
pltfmt['marker'] = dict(size=5,
line=dict(color='rgb(110, 110, 110)',
width=1))
#pltfmt['showlegend'] = True #if i==0 else False
pltdata.append(
go.Scatter3d(x=dfi[lblX], y=dfi[lblY], z=dfi[lblZ], **pltfmt))
else:
tag = 'tag'
pltfmt = dict(line=dict(width=lw),
opacity=opacity,
mode='markers',
name=tag)
pltfmt['legendgroup'] = tag
pltfmt['hoverinfo'] = 'none'
#pltfmt['showlegend'] = True #if i==0 else False
pltdata = [
go.Scatter3d(x=dfxyz[lblX], y=dfxyz[lblY], z=dfxyz[lblZ], **pltfmt)
]
#== camera and layout
#camera_xy = dict(
#up=dict(x=0, y=0, z=1),
#center=dict(x=0, y=0, z=0),
#eye=dict(x=0.0, y=-0.0, z=2.5)
#)
xaxis = dict(title=lblX, titlefont=tfont)
yaxis = dict(title=lblY, titlefont=tfont)
zaxis = dict(title=lblZ, titlefont=tfont)
layout = go.Layout(
title=title,
scene=dict(
xaxis=xaxis,
yaxis=yaxis,
zaxis=zaxis,
aspectmode='data',
#camera=camera_xy,
),
showlegend=True,
autosize=autosize,
width=width,
height=height,
margin=margin,
#updatemenus=list([ dict( x=0.55, y=1, yanchor='top', buttons=butlst, ) ]),
)
fig3d = go.Figure(data=pltdata, layout=layout)
return fig3d
def graph():
nodes, links = get_graph_db()
N = len(nodes)
L = len(links)
Edges = [(links[k]['source'], links[k]['target']) for k in range(L)]
# Graph
G = ig.Graph(Edges, directed=True)
# Getting name and group
labels = []
group = []
for node in nodes:
labels.append(node['name'])
group.append(node['group'])
# Layout style
layt = G.layout_fruchterman_reingold(grid=True, dim=3)
# Getting coordinates
Xn = [layt[k][0] for k in range(N)] # x-coordinates of nodes
Yn = [layt[k][1] for k in range(N)] # y-coordinates
Zn = [layt[k][2] for k in range(N)] # z-coordinates
Xe = []
Ye = []
Ze = []
for e in Edges:
Xe += [layt[e[0]][0], layt[e[1]][0], None]
Ye += [layt[e[0]][1], layt[e[1]][1], None]
Ze += [layt[e[0]][2], layt[e[1]][2], None]
# Traces
trace1 = go.Scatter3d(
x=Xe,
y=Ye,
z=Ze,
mode='lines',
line=dict(color='rgb(125,125,125)', width=1),
hoverinfo='skip',
)
trace2 = go.Scatter3d(x=Xn,
y=Yn,
z=Zn,
mode='markers',
name='actors',
opacity=1,
marker=dict(symbol='circle',
size=4,
color=group,
colorscale='haline',
line=dict(color='rgb(50,50,50)',
width=0.5)),
text=labels,
hoverinfo='text')
# Layout figure
axis = dict(showbackground=False,
showline=False,
zeroline=False,
showgrid=False,
showticklabels=False,
title='')
layout = go.Layout(title="Authors",
showlegend=False,
scene=dict(
xaxis=dict(axis),
yaxis=dict(axis),
zaxis=dict(axis),
),
margin=dict(l=0, r=0, t=0, b=0),
hovermode='closest',
hoverlabel=dict(bgcolor='white'))
data = [trace1, trace2]
fig = go.Figure(data=data, layout=layout)
fig.update_layout(title={
'y': 0.9,
'x': 0.5,
'xanchor': 'center',
'yanchor': 'top'
},
autosize=True)
config = {'responsive': True, "displaylogo": False, \
'modeBarButtonsToRemove': ['pan3d', 'lasso3d', 'zoom3d', 'orbitRotation', 'tableRotation', \
'resetCameraDefault3d', 'hoverClosest3d', 'resetCameraLastSave3d']}
graph = dcc.Graph(figure=fig,
id="graph",
config=config,
style={
"height": "92vh",
"width": "100%"
})
return graph
###### Plotly Graph #######
## Making a plotly graph to show category separation from only top three features
#Top three features as shown by random forest
a = train_original["concave.points_mean"]
b = train_original["perimeter_worst"]
c = train_original["texture_worst"]
#Importing packages and setting credentials
import plotly
import plotly.plotly as py
import plotly.graph_objs as go
plotly.tools.set_credentials_file(username='******', api_key='CueWpz8W4OROnmTR9mko')
#Mapping colors onto original training data
size_mapping = {'B': "blue",'M': "red"}
train_original['color'] = train_original['diagnosis'].map(size_mapping)
#Create the 3D scatter plot
trace1 = go.Scatter3d(x=a, y=b, z=c, mode='markers', marker=dict(size=4, color=train_original["color"], opacity=0.8))
#Set the layout
data = [trace1]
layout = go.Layout(title='Plot Title', xaxis=dict(title='Growth Mean Radius'), yaxis=dict(title='Growth Mean Texture'))
#Plot the figure to my plotly account
fig = go.Figure(data=data, layout=layout)
py.iplot(fig, filename='3d-scatter-tumor')
grid_y = 2*np.sin(2*grid_ang*np.pi/16)
points = np.array(list(zip(grid_x, grid_y, grid_z)))
# プロットのためにxyzごとにリストに分解
xs = points[:,0]
ys = points[:,1]
zs = points[:,2]
data = []
# マーカー
data.append(go.Scatter3d(
x=xs,
y=ys,
z=zs,
mode='markers',
marker=dict(
color='rgb(100,100,200)',
size=2,
opacity=0.8
)
))
# 線分
for x, y, z in points:
data.append(go.Scatter3d(
x=[x, x+x/2],
y=[y, y+y/2],
z=[z, z],
mode='lines',
marker=dict(
color='rgb(100,100,200)',
size=5,
def Plot_3D(df_meta_input=None, n_comps=10, dim=3):
try:
df_QC_report = pd.read_csv('QC_report.csv', index_col=0)
# Import metadata; if not provided only QC will be used
try:
df_meta_plot = pd.read_csv(df_meta_input, index_col=0)
df_meta_plot = df_meta_plot.select_dtypes('object').merge(
df_QC_report[['recommendation', 'Outlier']],
left_index=True,
right_index=True)
df_meta_plot = df_meta_plot.astype(str)
except FileNotFoundError:
print('No metadata file found')
df_meta_plot = df_QC_report[['recommendation', 'Outlier']]
df_plot = pd.read_csv('./counts/TPM_counts.csv',
index_col=0)[df_meta_plot.index]
# Compute PCA results for plotiing
data_array = df_plot.apply(lambda x: np.log2(x + 1)).values.T
pca = PCA(n_components=min(
n_comps,
len(df_QC_report) - 1)) # PC number can not exceed sample size -1
PCA_result = pca.fit_transform(data_array)
Ratio = pca.explained_variance_ratio_
mu = PCA_result.mean(axis=0)
PCA_result = PCA_result - mu
X = [xx[0] for xx in PCA_result]
Y = [xx[1] for xx in PCA_result]
Z = [xx[2] for xx in PCA_result]
# generate PCA - QC correlation matrix heatmap here
df_PCA = pd.DataFrame(
PCA_result,
columns=[f'PC_{i+1}' for i in range(PCA_result.shape[1])],
index=df_QC_report.index)
corr_matrix = np.zeros(
[int(df_QC_report.shape[1] - 3),
int(df_PCA.shape[1])])
p_matrix = np.zeros(
[int(df_QC_report.shape[1] - 3),
int(df_PCA.shape[1])])
for i, col in enumerate(df_QC_report.columns[:-3]):
for j, PC in enumerate(df_PCA.columns):
corr_matrix[i, j] = spearmanr(df_QC_report[col].values,
df_PCA[PC].values).correlation
p_matrix[i, j] = spearmanr(df_QC_report[col].values,
df_PCA[PC].values).pvalue
_, ax = plt.subplots(figsize=(25, 6))
sns.heatmap(pd.DataFrame(
p_matrix, index=df_QC_report.columns[:-3],
columns=df_PCA.columns).apply(lambda x: -np.log10(x)).T,
cmap='GnBu')
for j in range(len(pd.DataFrame(corr_matrix).T.columns)):
for i in range(len(pd.DataFrame(corr_matrix).T.index)):
text = ax.text(j + 0.5,
i + 0.5,
pd.DataFrame(corr_matrix).T.applymap(
lambda x: '%.2f' % x).values[i, j],
ha="center",
va="center",
color="red")
plt.savefig(f'QC_plots/PCA_QC_correlation.png',
format='png',
bbox_inches='tight')
# Back to plot 3D funciton
df_PCA = pd.DataFrame({
'sample': df_meta_plot.index.values,
'X': X,
'Y': Y,
'Z': Z
}).set_index('sample')
group_factors = df_meta_plot.columns
scatter_data = []
Scatter_data_length = []
if dim == 3:
for select_factor in group_factors:
trace = []
for N in sorted(set(df_meta_plot[select_factor])):
trace.append(
go.Scatter3d(
x=df_PCA[df_meta_plot[select_factor] ==
N]['X'].values,
y=df_PCA[df_meta_plot[select_factor] ==
N]['Y'].values,
z=df_PCA[df_meta_plot[select_factor] ==
N]['Z'].values,
mode='markers',
name=N,
text=df_meta_plot[df_meta_plot[select_factor] ==
N].index.values,
hoverinfo='text',
marker=dict(size=4,
line=dict(width=0.5),
opacity=0.8)))
scatter_data += trace
Scatter_data_length.append(len(trace))
if dim == 2:
for select_factor in group_factors:
trace = []
for N in sorted(set(df_meta_plot[select_factor])):
trace.append(
go.Scatter(
x=df_PCA[df_meta_plot[select_factor] ==
N]['X'].values,
y=df_PCA[df_meta_plot[select_factor] ==
N]['Y'].values,
mode='markers',
name=N,
text=df_meta_plot[df_meta_plot[select_factor] ==
N].index.values,
hoverinfo='text',
marker=dict(size=4,
line=dict(width=0.5),
opacity=0.8)))
scatter_data += trace
Scatter_data_length.append(len(trace))
Vis_table = []
for i in np.arange(len(Scatter_data_length)):
Vis_list = []
for j, elements in enumerate(Scatter_data_length):
if j == i:
Vis_list.append([True] * elements)
else:
Vis_list.append([False] * elements)
Vis_table.append(
[item for sublist in Vis_list for item in sublist])
dict_Vis = dict(zip(group_factors, Vis_table))
updatemenus = [
dict(active=0,
buttons=list([
dict(label=Group_factor,
method='update',
args=[{
'visible': dict_Vis[Group_factor] + [True]
}, {
'title': str(Group_factor)
}]) for Group_factor in group_factors
]))
]
layout = go.Layout(
legend=dict(x=-0.15, y=0),
scene=dict(
xaxis=dict(title='PC1 ' + '%.2f' % Ratio[0],
titlefont=dict(family='Courier New, monospace',
size=18,
color='#7f7f7f')),
yaxis=dict(title='PC2 ' + '%.2f' % Ratio[1],
titlefont=dict(family='Courier New, monospace',
size=18,
color='#7f7f7f')),
zaxis=dict(title='PC3 ' + '%.2f' % Ratio[2],
titlefont=dict(family='Courier New, monospace',
size=18,
color='#7f7f7f')),
),
updatemenus=updatemenus)
fig = go.Figure(data=scatter_data, layout=layout)
py.plot(fig, filename='check_QC_PCA.html', auto_open=False)
except FileNotFoundError:
print('Please generate QC report')
def get_score_plot(
self,
ordinate,
abscissa,
applicate,
color_by_labels,
include_db_index,
label_by_labels,
encircle_by,
plot_centroid,
plot_medoid,
graph_only=False,
theme=None
) -> Union[dcc.Graph, Tuple[dcc.Graph, Union[dash_table.DataTable,
html.Div]]]:
is_3d = (applicate is not None) and (applicate != -1)
theme = theme or 'plotly_white'
color_by_labels = color_by_labels or []
encircle_by = encircle_by or []
label_by_labels = label_by_labels or []
color_label = ','.join(color_by_labels) if color_by_labels else 'All'
label_df = self._processed_label_df.reset_index()
color_labels = label_df[color_by_labels].apply(lambda x: ','.join(x.apply(str)), axis=1) if color_by_labels \
else pd.Series(['All' for _ in range(0, len(label_df))])
color_names = list(color_labels.unique())
color_indices = [
label_df.index[color_labels == color_name]
for color_name in color_names
]
label_labels = label_df[label_by_labels].apply(lambda x: ','.join(x.apply(str)), axis=1) if label_by_labels \
else None
if len(color_names) > 1 and include_db_index:
db_df = self._get_scores(color_label, color_labels, True)
style_header = {
'backgroundColor': '#303030'
} if theme == 'plotly_dark' else {}
style_cell = {
'backgroundColor': '#444444'
} if theme == 'plotly_dark' else {}
table = dash_table.DataTable(columns=[{
'name': val,
'id': val
} for val in db_df.columns],
data=db_df.to_dict('rows'),
style_as_list_view=True,
style_header=style_header,
style_cell=style_cell)
else:
table = html.Div()
graph_data = [
go.Scatter( # dummy series to use as stand-in for legend title
x=[0],
y=[0],
name=color_label,
mode='markers',
marker={
'opacity': 0,
'size': 0,
'color': 'rgba(0,0,0,0)'
}) if not is_3d else go.Scatter3d(x=[0],
y=[0],
z=[0],
name=color_label,
mode='markers',
marker={
'opacity': 0,
'size': 0,
'color': 'rgba(0,0,0,0)'
})
]
shapes = []
annotations = []
if len(color_indices) > len(
DEFAULT_PLOTLY_COLORS): # repeat default color list
colors = []
while len(colors) < len(color_indices):
colors += DEFAULT_PLOTLY_COLORS
else:
colors = DEFAULT_PLOTLY_COLORS
colors = colors[:len(color_indices)]
for inds, name, color in zip(color_indices, color_names, colors):
graph_data.append(
go.Scatter(x=self._scores[inds, abscissa],
y=self._scores[inds, ordinate],
text=[
'<br>'.join([
f'{label}: {label_df[label][ind]}'
for label in label_df.columns
]) for ind in inds
],
name=name,
mode='markers',
marker={
'size': 15,
'opacity': 0.5,
'line': {
'width': 0.5,
'color': 'white'
},
'color': color
}) if not is_3d else go.
Scatter3d(x=self._scores[inds, abscissa],
y=self._scores[inds, ordinate],
z=self._scores[inds, applicate],
text=[
'<br>'.join([
f'{label}: {label_df[label][ind]}'
for label in label_df.columns
]) for ind in inds
],
name=name,
mode='markers',
marker={
'size': 5,
'opacity': 0.5,
'line': {
'width': 0.5,
'color': 'white'
},
'color': color
}))
if plot_centroid:
graph_data.append(
go.Scatter(x=[np.mean(self._scores[inds, abscissa])],
y=[np.mean(self._scores[inds, ordinate])],
text=f'{name} centroid',
name=f'{name} centroid',
mode='markers',
marker={
'size': 20,
'opacity': 0.85,
'line': {
'width': 0.5,
'color': 'white'
},
'color': color,
'symbol': 'x'
}) if not is_3d else go.
Scatter3d(x=[np.mean(self._scores[inds, abscissa])],
y=[np.mean(self._scores[inds, ordinate])],
z=[np.mean(self._scores[inds, applicate])],
text=f'{name} centroid',
name=f'{name} centroid',
mode='markers',
marker={
'size': 5,
'opacity': 0.85,
'line': {
'width': 0.5,
'color': 'white'
},
'color': color,
'symbol': 'x'
}))
if plot_medoid:
graph_data.append(
go.Scatter(x=[np.median(self._scores[inds, abscissa])],
y=[np.median(self._scores[inds, ordinate])],
text=f'{name} medoid',
name=f'{name} medoid',
mode='markers',
marker={
'size': 20,
'opacity': 0.85,
'line': {
'width': 0.5,
'color': 'white'
},
'color': color,
'symbol': 'cross'
}) if not is_3d else go.
Scatter3d(x=[np.median(self._scores[inds, abscissa])],
y=[np.median(self._scores[inds, ordinate])],
z=[np.median(self._scores[inds, applicate])],
text=f'{name} medoid',
name=f'{name} medoid',
mode='markers',
marker={
'size': 5,
'opacity': 0.85,
'line': {
'width': 0.5,
'color': 'white'
},
'color': color,
'symbol': 'cross'
}))
if label_labels is not None:
annotations += [{
'x': self._scores[ind, abscissa],
'y': self._scores[ind, ordinate],
'xref': 'x',
'yref': 'y',
'text': label_labels[ind],
'showarrow': False
} for ind in inds] if not is_3d else [
{
'x': self._scores[ind, abscissa],
'y': self._scores[ind, ordinate],
'xref': 'x',
'yref': 'y',
'text': label_labels[ind],
'showarrow': False
} for ind in inds
]
if not is_3d:
for metric in encircle_by:
if metric.endswith('std'):
x_std = np.std(self._scores[inds, abscissa], ddof=1)
y_std = np.std(self._scores[inds, ordinate], ddof=1)
x_mean = np.mean(self._scores[inds, abscissa])
y_mean = np.mean(self._scores[inds, ordinate])
x0 = x_mean - x_std * float(metric[0])
x1 = x_mean + x_std * float(metric[0])
y0 = y_mean - y_std * float(metric[0])
y1 = y_mean + y_std * float(metric[0])
elif metric.endswith('sem'):
x_sem = stats.sem(self._scores[inds, abscissa], ddof=1)
y_sem = stats.sem(self._scores[inds, ordinate], ddof=1)
x_mean = np.mean(self._scores[inds, abscissa])
y_mean = np.mean(self._scores[inds, ordinate])
x0 = x_mean - x_sem * float(metric[0])
x1 = x_mean + x_sem * float(metric[0])
y0 = y_mean - y_sem * float(metric[0])
y1 = y_mean + y_sem * float(metric[0])
elif metric == 'range':
x0 = np.min(self._scores[inds, abscissa])
x1 = np.max(self._scores[inds, abscissa])
y0 = np.min(self._scores[inds, ordinate])
y1 = np.max(self._scores[inds, ordinate])
elif metric == '95percentile':
x_ptile = np.percentile(self._scores[inds, abscissa],
95)
y_ptile = np.percentile(self._scores[inds, ordinate],
95)
x_median = np.median(self._scores[inds, abscissa])
y_median = np.median(self._scores[inds, ordinate])
x0 = x_median - x_ptile
x1 = x_median + x_ptile
y0 = y_median - y_ptile
y1 = y_median + y_ptile
elif metric.endswith('conf'):
conf = float(metric[:2]) / 100.0
n = len(self._scores[inds, abscissa])
x_mean = np.mean(self._scores[inds, abscissa])
y_mean = np.mean(self._scores[inds, ordinate])
x_h = stats.sem(self._scores[inds, abscissa],
ddof=1) * stats.t.ppf(
(1 + conf) / 2, n - 1)
y_h = stats.sem(self._scores[inds, ordinate],
ddof=1) * stats.t.ppf(
(1 + conf) / 2, n - 1)
x0 = x_mean - x_h
x1 = x_mean + x_h
y0 = y_mean - y_h
y1 = y_mean + y_h
else:
x0 = 0
x1 = 0
y0 = 0
y1 = 0
shapes.append({
'type': 'circle',
'xref': 'x',
'yref': 'y',
'x0': x0,
'y0': y0,
'x1': x1,
'y1': y1,
'opacity': 0.25,
'fillcolor': color,
'line': {
'color': color
}
})
axis_line_style = {
'zerolinecolor': '#375A7F', # darkly primary
'gridcolor': '#444444' # darkly secondary
} if theme == 'plotly_dark' else {
'zerolinecolor': '#2C3E50', # flatly primary
'gridcolor': '#95A5A6' # flatly secondary
}
layout = go.Layout(shapes=shapes,
annotations=annotations,
height=700,
font={'size': 16},
margin={
't': 25,
'l': 25,
'b': 25,
'r': 25
},
template=theme,
plot_bgcolor='rgba(0,0,0,0)',
paper_bgcolor='rgba(0,0,0,0)',
xaxis={
'title': f'PC{abscissa + 1}',
**axis_line_style
},
yaxis={
'title': f'PC{ordinate + 1}',
**axis_line_style
}) if not is_3d else go.Layout(
annotations=annotations,
height=700,
font={'size': 14},
margin={
't': 25,
'l': 25,
'b': 25,
'r': 25
},
template=theme,
plot_bgcolor='rgba(0,0,0,0)',
paper_bgcolor='rgba(0,0,0,0)',
scene={
'xaxis': {
'title': f'PC{abscissa + 1}',
**axis_line_style
},
'yaxis': {
'title': f'PC{ordinate + 1}',
**axis_line_style
},
'zaxis': {
'title': f'PC{applicate + 1}',
**axis_line_style
}
})
graph = dcc.Graph(figure={'data': graph_data, 'layout': layout})
if graph_only:
return graph
return graph, table
def __init__(self, x, y, z, mode='lines', **kwargs):
super().__init__(data=go.Scatter3d(x=x, y=y, z=z, mode=mode, **kwargs))
def plot_pointVisualization_eurocRun1(X, Y, Z, X_A, Y_A, Z_A, prev_s_coord, current_s_coord,
start_coordinates, goal_point_coordinates, s_stream, run, open_X, open_Y, open_Z ):
s_X = []
s_Y = []
s_Z = []
for s in s_stream:
s_X.append(s[0])
s_Y.append(s[1])
s_Z.append(s[2])
trace_s_stream = go.Scatter3d(
x=s_X,
y=s_Y,
z=s_Z,
mode='markers',
name = "S stream",
marker=dict(
size=12,
)
)
trace_neighbors_raw = go.Scatter3d(
x=X,
y=Y,
z=Z,
mode='markers',
name = "Raw neighbors",
marker=dict(
size=12,
)
)
trace_neighbors_centers = go.Scatter3d(
x=X_A,
y=Y_A,
z=Z_A,
mode='markers',
name = "Voxel centers",
marker=dict(
size=12,
)
)
# trace_prev_s_neighbors_raw = go.Scatter3d(
# x=prev_s_X,
# y=prev_s_Y,
# z=prev_s_Z,
# mode='markers',
# name = "Previous s raw neighbors",
# marker=dict(
# size=12,
# )
# )
trace_open = go.Scatter3d(
x=open_X,
y=open_Y,
z=open_Z,
mode='markers',
name = "Top nodes on open ",
marker=dict(
size=12,
)
)
trace_prev_s = go.Scatter3d(
x=(prev_s_coord[0], ),
y=(prev_s_coord[1], ),
z=(prev_s_coord[2], ) ,
mode='markers',
name = "Previous s",
marker=dict(
size=12,
)
)
trace_current_s = go.Scatter3d(
x=(current_s_coord[0], ),
y=(current_s_coord[1], ),
z=(current_s_coord[2], ) ,
mode='markers',
name = "Current s",
marker=dict(
size=12,
)
)
# trace_target = go.Scatter3d(
# x=(correct_neighbor_coordinates['point'][0], correct_neighbor_coordinates['center'][0]),
# y=(correct_neighbor_coordinates['point'][1], correct_neighbor_coordinates['center'][1]),
# z=(correct_neighbor_coordinates['point'][2], correct_neighbor_coordinates['center'][2]) ,
# mode='markers',
# name = "Correct neighbor for path",
# marker=dict(
# size=12,
# )
# )
trace_start_center = go.Scatter3d(
x=(start_coordinates[0], ),
y=(start_coordinates[1], ),
z=(start_coordinates[2], ) ,
mode='markers',
name = "Start center",
marker=dict(
size=12,
)
)
#the distance takes into account the final point, not it's center
trace_end_point = go.Scatter3d(
x=(goal_point_coordinates[0], ),
y=(goal_point_coordinates[1], ),
z=(goal_point_coordinates[2], ) ,
mode='markers',
name = "End POINT",
marker=dict(
size=12,
)
)
traces = [trace_s_stream, trace_start_center, trace_end_point, trace_open, trace_neighbors_raw, trace_neighbors_centers, trace_prev_s, trace_current_s]
layout = go.Layout(
)
plotly.offline.plot({
"data": traces,
"layout": layout,
},
filename= 'plots/voxelSizeDistribution_'+run+'.html')
zs.append(z)
print(pd.DataFrame({'x': xs, 'y': ys, 'z': zs}))
xs = np.array(xs)
ys = np.array(ys)
zs = np.array(zs)
plot = go.Scatter3d(x=xs,
y=ys,
z=zs,
mode='markers',
marker=dict(size=1,
# size=np.e ** np.sqrt(xs ** 2 + ys ** 2 + zs ** 2),
color=np.sqrt(xs ** 2 + ys ** 2 + zs ** 2),
# line=dict(
# color='rgb(204, 204, 204)',
# width=1
# ),
colorscale='Viridis',
),
opacity=.7,
)
data = [plot]
layout = go.Layout(
xaxis=go.layout.XAxis(
title='x'
),
yaxis=go.layout.YAxis(
def do_plot(self):
max_lateral_distance = np.max(
[self._plot_data['z_coord'], self._plot_data['cum_disp_dist']])
true_north_seq = [x for x in range(int(max_lateral_distance))]
# Assign colors by perforations
perforation_flag = np.ndarray(shape=(self._processed_data.shape[0], ))
flag = 1
for x in range(self._processed_data.shape[0]):
flag = 0
depth = self._processed_data['MD'][x]
for y in self._perf_meta_data[['Top', 'Btm']].copy().as_matrix():
if depth >= y[0] and depth <= y[1]:
perforation_flag[x] = -1
flag = 1
continue
if flag == 0: perforation_flag[x] = depth
well_path = go.Scatter3d(x=self._plot_data['cum_disp_dist'],
y=self._plot_data['z_coord'],
z=self._plot_data['cum_tvd'],
marker=dict(color=self._plot_data['cum_tvd'],
size=6,
symbol='circle',
colorscale='Viridis',
line=dict(color='#1f77b4',
width=.1),
opacity=.2))
perforations = go.Scatter3d(
x=self._plot_data['cum_disp_dist'].iloc[np.where(
perforation_flag == -1)[0]],
y=self._plot_data['z_coord'].iloc[np.where(
perforation_flag == -1)[0]],
z=self._plot_data['cum_tvd'].iloc[np.where(
perforation_flag == -1)[0]],
mode='lines',
line=dict(color='#FF4500', width=6))
data = [well_path, perforations]
layout = dict(
title='Well Model',
showlegend=False,
margin=go.Margin(l=50, r=50, b=100, t=100, pad=4),
scene=dict(xaxis=dict(title='Distance',
gridcolor='rgb(255, 255, 255)',
zerolinecolor='rgb(255, 255, 255)',
showbackground=True,
backgroundcolor='rgb(230, 230,230)'),
yaxis=dict(title='',
gridcolor='rgb(255, 255, 255)',
zerolinecolor='rgb(255, 255, 255)',
showbackground=True,
backgroundcolor='rgb(230, 230,230)',
autorange=True,
showgrid=False,
zeroline=False,
showline=False,
ticks='',
showticklabels=False),
zaxis=dict(title='Depth',
gridcolor='rgb(255, 255, 255)',
zerolinecolor='rgb(255, 255, 255)',
showbackground=True,
backgroundcolor='rgb(230, 230,230)'),
camera=dict(up=dict(x=1, y=1, z=1),
center=dict(x=0, y=0, z=0),
eye=dict(x=3, y=5.5, z=.75))),
)
fig = go.Figure(data=data, layout=layout)
fig['layout'].update(scene=dict(aspectmode="data"))
return fig
Zn = [pos[k][2] for k in range(0, G.number_of_nodes())] # y-coordinates
# populate node edges
Edges = G.edges()
Xe = []
Ye = []
Ze = []
for e in Edges:
Xe += [pos[e[0]][0], pos[e[1]][0], None] # x-coordinates of edge ends
Ye += [pos[e[0]][1], pos[e[1]][1], None]
Ze += [pos[e[0]][2], pos[e[1]][2], None]
# add trace for edges
edge_trace = go.Scatter3d(x=Xe,
y=Ye,
z=Ze,
line=go.Line(width=0.5, color='#888'),
hoverinfo='none',
mode='lines')
# add trace for members in the house
house_trace = go.Scatter3d(
x=Xn[0:3],
y=Yn[0:3],
z=Zn[0:3],
mode='markers',
name='Member of the House',
text=[
'Name: Representative James P. McGovern',
'Name: Representative Trent Franks',
'Name: Represenatative Christopher H. Smith'
],
def plot_interest(gen_sample, subsummary, RG_info, subset_col, Names, code= {},ref_keep= [0,1,2],
gp_names_dict= {}, ID_col= 'IRIS_ID',
include= [], Sn= 400, Sm= 5000, gp_cols= {}, sample= True):
if sample:
gen_sample, subsummary, code_vec, code_lib, Nsample, Msample= geno_subset_random(gen_sample,summary, RG_info,
ID_col,subset_col, Names,code=code, include= Names_select,
Sn= Sn, Sm= Sm)
else:
Nsample= list(range(len(Names)))
PCsel= 1
Names_subsel= [Names[x] for x in Nsample]
###
gp_cols= {z:'rgb({})'.format(','.join([str(x) for x in g])) for z,g in gp_cols.items()}
ref_dict= list(RG_info['IRIS_ID'])
ref_dict= [ref_dict.index(x) for x in Names_subsel]
ref_code= [RG_info['Initial_subpop'][x] for x in ref_dict]
ref_dict= [['admx',x][int(x in code.keys())] for x in ref_code]
ref_dict= [code[x] for x in ref_dict]
keep_vec= [x for x in range(len(ref_dict)) if ref_dict[x] in ref_keep or Names_subsel[x] in Names_select]
names_kept= [Names_subsel[x] for x in keep_vec]
Names_idx= [names_kept.index(x) for x in Names_select]
ref_dict= [ref_dict[x] for x in keep_vec]
ref_dict= {z: [x for x in range(len(ref_dict)) if ref_dict[x]==z] for z in set(ref_dict)}
###
pca = PCA(n_components=3)
pca.fit(gen_sample[keep_vec])
pc_data= pca.transform(gen_sample[keep_vec])
###
fig= [go.Scatter3d(
x= pc_data[g,0],
y= pc_data[g,PCsel],
z= pc_data[g,PCsel+1],
text= [Names_subsel[x] for x in g],
mode= "markers",
name= gp_names_dict[z],
marker= dict(
size= 5,
color= gp_cols[z]
)
) for z,g in ref_dict.items()]
fig.append(go.Scatter3d(
x= pc_data[Names_idx[:5],0],
y= pc_data[Names_idx[:5],PCsel],
z= pc_data[Names_idx[:5],PCsel+1],
mode= "markers",
name= 'interest subtrop',
text= Names_select[:5],
marker= dict(
size= 5,
color= 'rgb(30,144,255)',
symbol= 'x',
line= dict(width= 1)
)
)
)
fig.append(go.Scatter3d(
x= pc_data[Names_idx[5:10],0],
y= pc_data[Names_idx[5:10],PCsel],
z= pc_data[Names_idx[5:10],PCsel+1],
mode= "markers",
name= 'control subtrop',
text= Names_select[5:10],
marker= dict(
size= 5,
color= 'rgb(255,215,0)',
symbol= 'cross',
line= dict(width= 2)
)
)
)
fig.append(go.Scatter3d(
x= pc_data[Names_idx[10:],0],
y= pc_data[Names_idx[10:],PCsel],
z= pc_data[Names_idx[10:],PCsel+1],
mode= "markers",
name= 'control temp',
text= Names_select[10:],
marker= dict(
size= 5,
color= 'rgb(173,255,47)',
symbol= 'diamond',
line= dict(width= 2)
)
))
layout= go.Layout()
Figure= go.Figure(data= fig,layout= layout)
iplot(Figure)
def _draw_streamlines(figure, sls, dimensions, color, name, cbv=None,
cbv_lims=[None, None]):
color = np.asarray(color)
plotting_shape = (sls._data.shape[0] + sls._offsets.shape[0])
# dtype object so None can be stored
x_pts = np.zeros(plotting_shape)
y_pts = np.zeros(plotting_shape)
z_pts = np.zeros(plotting_shape)
if cbv is not None:
if cbv_lims[0] is None:
cbv_lims[0] = 0
if cbv_lims[1] is None:
cbv_lims[1] = cbv.max()
customdata = np.zeros(plotting_shape)
line_color = np.zeros((plotting_shape, 3))
color_constant = (color / color.max())\
* (1.4 / (cbv_lims[1] - cbv_lims[0])) + cbv_lims[0]
else:
customdata = np.zeros(plotting_shape)
line_color = np.zeros((plotting_shape, 3))
color_constant = color
for sl_index, plotting_offset in enumerate(sls._offsets):
sl_length = sls._lengths[sl_index]
sl = sls._data[plotting_offset:plotting_offset + sl_length]
# add sl to lines
total_offset = plotting_offset + sl_index
x_pts[total_offset:total_offset + sl_length] = sl[:, 0]
# don't draw between streamlines
x_pts[total_offset + sl_length] = np.nan
y_pts[total_offset:total_offset + sl_length] = sl[:, 1]
y_pts[total_offset + sl_length] = np.nan
z_pts[total_offset:total_offset + sl_length] = sl[:, 2]
z_pts[total_offset + sl_length] = np.nan
if cbv is not None:
brightness = cbv[
sl[:, 0].astype(int),
sl[:, 1].astype(int),
sl[:, 2].astype(int)
]
line_color[total_offset:total_offset + sl_length, :] = \
np.outer(brightness, color_constant)
customdata[total_offset:total_offset + sl_length] = brightness
else:
line_color[total_offset:total_offset + sl_length, :] = \
color_constant
customdata[total_offset:total_offset + sl_length] = 1
line_color[total_offset + sl_length, :] = [0, 0, 0]
customdata[total_offset + sl_length] = 0
figure.add_trace(
go.Scatter3d(
x=dimensions[0] - x_pts,
y=y_pts,
z=z_pts,
name=name,
marker=dict(
size=0.0001,
color=_color_arr2str(color)
), # this is necessary to add color to legend
line=dict(
width=8,
color=line_color,
),
hovertext=customdata,
hoverinfo='all'
)
)
def Coincidences_3D_plot(df, data_sets, window):
# Declare max and min count
min_count = 0
max_count = np.inf
# Perform initial filters
df = df[(df.wCh != -1) & (df.gCh != -1)]
df = filter_ce_clusters(window, df)
if data_sets == 'mvmelst_039.zip':
df = df[df.Time < 1.5e12]
# Initiate 'voxel_id -> (x, y, z)'-mapping
detector_vec = get_detector_mappings()
# Initiate border lines
b_traces = initiate_detector_border_lines(detector_vec)
# Calculate 3D histogram
H, edges = np.histogramdd(df[['wCh', 'gCh', 'Bus']].values,
bins=(80, 40, 9),
range=((0, 80), (80, 120), (0, 9)))
# Insert results into an array
hist = [[], [], [], []]
loc = 0
labels = []
detector_names = ['ILL', 'ESS_CLB', 'ESS_PA']
for wCh in range(0, 80):
for gCh in range(80, 120):
for bus in range(0, 9):
detector = detector_vec[bus // 3]
over_min = H[wCh, gCh - 80, bus] > min_count
under_max = H[wCh, gCh - 80, bus] <= max_count
if over_min and under_max:
coord = detector[flip_bus(bus % 3), gCh, flip_wire(wCh)]
hist[0].append(coord['x'])
hist[1].append(coord['y'])
hist[2].append(coord['z'])
hist[3].append(H[wCh, gCh - 80, bus])
loc += 1
labels.append('Detector: ' + detector_names[(bus // 3)] +
'<br>' + 'Module: ' + str(bus) + '<br>' +
'WireChannel: ' + str(wCh) + '<br>' +
'GridChannel: ' + str(gCh) + '<br>' +
'Counts: ' + str(H[wCh, gCh - 80, bus]))
# Produce 3D histogram plot
MG_3D_trace = go.Scatter3d(
x=hist[2],
y=hist[0],
z=hist[1],
mode='markers',
marker=dict(
size=5,
color=np.log10(hist[3]),
colorscale='Jet',
opacity=1,
colorbar=dict(thickness=20, title='log10(counts)'),
#cmin=0,
#cmax=2.5
),
text=labels,
name='Multi-Grid',
scene='scene1')
# Introduce figure and put everything together
fig = py.tools.make_subplots(rows=1, cols=1, specs=[[{'is_3d': True}]])
# Insert histogram
fig.append_trace(MG_3D_trace, 1, 1)
# Insert vessel borders
for b_trace in b_traces:
fig.append_trace(b_trace, 1, 1)
# Assign layout with axis labels, title and camera angle
a = 1
camera = dict(up=dict(x=0, y=0, z=1),
center=dict(x=0, y=0, z=0),
eye=dict(x=-2 * a, y=-0.5 * a, z=1.3 * a))
fig['layout']['scene1']['xaxis'].update(title='z [m]')
fig['layout']['scene1']['yaxis'].update(title='x [m]')
fig['layout']['scene1']['zaxis'].update(title='y [m]')
fig['layout'].update(title='Coincidences (3D)<br>' + str(data_sets))
fig['layout']['scene1']['camera'].update(camera)
fig.layout.showlegend = False
# If in plot He3-tubes histogram, return traces, else save HTML and plot
if data_sets == '':
return b_traces, hist[0], hist[1], hist[2], np.log10(hist[3])
else:
py.offline.plot(fig,
filename='../Results/HTML_files/Ce3Dhistogram.html',
auto_open=True)
pio.write_image(fig, '../Results/HTML_files/Ce3Dhistogram.pdf')
plt.show() #Show the Clustering map
### isualizing'Agw'&'Region_code'&'Policy_Sales_Channel'
feature_cols4 = ['Age', 'Region_Code', 'Policy_Sales_Channel']
train4 = train[feature_cols4].values # Features
km4 = KMeans(n_clusters=5,
init='k-means++',
max_iter=300,
n_init=10,
random_state=0)
km4.fit(train4)
train['labels'] = km4.labels_
# 绘制3D图
trace1 = go.Scatter3d(x=train['Age'],
y=train['Region_Code'],
z=train['Policy_Sales_Channel'],
mode='markers',
marker=dict(color=train['labels'],
size=10,
line=dict(color=train['labels'], width=12),
opacity=0.8))
df_3dfid = [trace1]
layout = go.Layout(margin=dict(l=0, r=0, b=0, t=0),
scene=dict(xaxis=dict(title='Age'),
yaxis=dict(title='Region_Code'),
zaxis=dict(title='Policy_Sales_Channel')))
fig = go.Figure(data=df_3dfid, layout=layout)
py.offline.plot(fig)
