def plot_correlation(df, show_fig=True):
'''
:return: None
Creates plotly correlation plot of all present cegaltools logs
'''
temp_df = df.corr().dropna(how='all', axis=0).dropna(how='all', axis=1)
fig = px.imshow(temp_df,
labels=dict(x="Well log (horizontal)", y="Well log (vertical)", color="Correlation"),
x=temp_df.columns,
y=temp_df.columns)
fig.update_xaxes(side='top')
fig.update_layout(
margin=dict(t=150, l=30, r=30, b=30),
title={'text': '<b>Well log correlation matrix</b>',
'y': 0.9,
'x': 0.1,
'yanchor': 'top'},
)
if show_fig:
fig.show()
else:
return fig
def search_video(search_query, display_heatmap=True, display_results_count=3):
# Encode and normalize the search query using CLIP
with torch.no_grad():
text_features = model.encode_text(
clip.tokenize(search_query).to(device))
text_features /= text_features.norm(dim=-1, keepdim=True)
# Compute the similarity between the search query and each frame using the Cosine similarity
similarities = (100.0 * video_features @ text_features.T)
values, best_photo_idx = similarities.topk(display_results_count, dim=0)
# Display the heatmap
if display_heatmap:
print("Search query heatmap over the frames of the video:")
fig = px.imshow(similarities.T.cpu().numpy(),
height=50,
aspect='auto',
color_continuous_scale='viridis')
fig.update_layout(coloraxis_showscale=False)
fig.update_xaxes(showticklabels=False)
fig.update_yaxes(showticklabels=False)
fig.update_layout(margin=dict(l=0, r=0, b=0, t=0))
fig.show(renderer="png")
print()
# Display the top 3 frames
for frame_id in best_photo_idx:
# display(video_frames[frame_id])
video_frames[frame_id].show()
print()
def plot_heatmap(event, figure_filename=None, figsize=[500, 2000]):
X, Y, Z = create_XYZ_data(event)
Z_xr = xr.DataArray(Z,
dims=(
"time",
"sensor_location",
),
coords={
"sensor_location": X[0, :],
"time": Y[:, 0]
})
heatmap = px.imshow(
Z_xr,
labels=dict(x="Sensor Location", y="Time (seconds)", color="Strain"),
width=figsize[0],
height=figsize[1],
aspect='auto',
color_continuous_midpoint=0,
)
heatmap.update_xaxes(side="top")
if figure_filename is not None:
if not os.path.exists("heatmap_plots"):
os.mkdir("heatmap_plots")
print('heatmap_plots folder created.')
heatmap.write_image(f'heatmap_plots/{figure_filename}.png')
print('heatmap image saved.')
return heatmap
def error_structure(data, n_clicks):
df = pd.DataFrame(data)
if n_clicks is None or n_clicks % 2 == 0:
pass
elif n_clicks % 2 == 1:
for i in range(0, len(combined_columns), 2):
df[combined_columns[i]] = df[combined_columns[i]].fillna(
df[combined_columns[i + 1]])
df[combined_columns[i]] = df[combined_columns[i]].mask(df[combined_columns[i]] == 0).fillna(
df[combined_columns[i + 1]])
for i in range(1, len(combined_columns), 2):
df[combined_columns[i]] = df[combined_columns[i]].fillna(
df[combined_columns[i - 1]])
df[combined_columns[i]] = df[combined_columns[i]].mask(df[combined_columns[i]] == 0).fillna(
df[combined_columns[i - 1]])
for i in range(len(summer_columns)):
df[error_columns[i]] = df[summer_columns[i]] != df[winter_columns[i]]
fig = px.imshow(df[error_columns].T, color_continuous_scale=px.colors.sequential.Greys,
title="Errors Structure")
fig.update_layout(title_font={'size': 27}, title_x=0.5)
return fig
def evaluate_clusters(start_from=0, mode="sawp"):
"""
Evaluates the DWT clusters and exports the image of the matrix obtained and the relative matrix in a csv file.
Parameters
----------
mode: str = {"direct","sawp"}
Select feature representation.
"""
import plotly.express as px
import numpy as np
meta = metaframe.MetaFrame(path_data=shared.DATASET_PATH,
path_meta=shared.META_PATH)
for identifier, uid in enumerate(meta.UUID):
if identifier > start_from:
X = clu.Cluster(uid)
for side in X.sides:
for sensor in X.sensors:
print("[{}] # ".format(time.ctime()) +
"Starting DTW Matrix Computation.")
dtw_matrix = X.dist_matrix(side=side,
sensor=sensor,
mode=mode)
fig = px.imshow(dtw_matrix)
image_path = f"images/DTW_matrices/DTW_{X.train}_{X.direction}_{X.avg_speed}" \
f"_{X.component}_{X.num_trip}_{X.engine_conf}_{side}_{sensor}_{uid}.png"
fig.write_image(image_path)
print("[{}] # ".format(time.ctime()) + "Image Exported.")
matrix_path = f"private/export/DTW_matrices/DTW_{X.train}_{X.direction}_{X.avg_speed}" \
f"_{X.component}_{X.num_trip}_{X.engine_conf}_{side}_{sensor}_{uid}.dat"
np.savetxt(matrix_path, dtw_matrix, delimiter=";")
print("[{}] # ".format(time.ctime()) + "File Exported.")
def plt_tab6_2():
df = pd.DataFrame([[20, 2], [2, 100]],
columns=["predict_True", "predict_False"],
index=["actual_True", "actual_False"])
fig = px.imshow(df, labels=dict(color="Num of Event"))
return fig
def exclusions_plotly(self,
cmap='Viridis',
plot_step=100,
out_path=None,
**kwargs):
"""
Plot exclusions mask as a plotly heatmap
Parameters
----------
cmap : str | px.color, optional
Continuous color scale to use, by default 'Viridis'
plot_step : int
Step between points to plot
out_path : str, optional
File path to save plot to, can be a .html or static image,
by default None
kwargs : dict
Additional kwargs for plotly.express.imshow
"""
fig = px.imshow(self.mask[::plot_step, ::plot_step],
color_continuous_scale=cmap,
**kwargs)
fig.update_layout(font=dict(family="Arial", size=18, color="black"))
if out_path is not None:
SummaryPlots._save_plotly(fig, out_path)
fig.show()
def get_uncertainty(index):
try:
im = cifar[index][0]
except Exception as e:
print(e)
return px.scatter(title="Error: " + e)
im = np.transpose(im.numpy(), (1, 2, 0))
fig = px.imshow(im)
fig.update_xaxes(showticklabels=False)
fig.update_yaxes(showticklabels=False)
distrib_fig = go.Figure(
[go.Bar(x=cifar.classes_labels, y=cifar[index][1][0].numpy())])
raw = cifar.get_raw()
raw = raw[raw.cifar10_test_test_idx == index]
raw = raw[(raw.is_attn_check != 1) & (raw.reaction_time > 0)]
boxplots = px.box(raw, x="correct_guess", y="reaction_time")
return (
distrib_fig,
fig,
boxplots,
"The true label is {}".format(
cifar.classes_labels[cifar.true_targets[index]]),
)
def layout(params):
selection = dcc.Dropdown(
id = "image-selection",
options = render_options,
value = render_options[0]['value'],
clearable = False
)
logo_path = f"{Path(__file__).parent}/assets/pystachio_logo.tif"
logo_tif = tifffile.imread(logo_path)
logo_fig = px.imshow(
logo_tif[:,:,0],
color_continuous_scale='gray',
zmin = 0,
zmax = np.max(logo_tif[:,:,:]),
)
img_pane = html.Div(id="img-pane",
children=[
selection,
dcc.Graph(id='image-graph', className='img-graph', figure=logo_fig),
html.Label('Frame 1 of 1', id='image-frame'),
dcc.Slider(id='image-slider', min=1, max=params.num_frames, value=0),
])
return img_pane
def get_operated_image(contents, image_mode, operation, filenames, dates):
if contents is not None:
imsrc = parse_contents(contents, filenames, dates)
imo = ImageOperations(image_file_src=imsrc)
if (operation == 'equalize'):
out_img = imo.equalize_this(gray_scale=True) if image_mode else imo.equalize_this()
elif (operation == 'flip'):
out_img = imo.flip_this(gray_scale=True) if image_mode else imo.flip_this()
elif (operation == 'mirror'):
out_img = imo.mirror_this(gray_scale=True) if image_mode else imo.mirror_this()
elif (operation == 'binarize'):
out_img = imo.binarize_this(gray_scale=True) if image_mode else imo.binarize_this()
elif (operation == 'invert'):
out_img = imo.invert_this(gray_scale=True) if image_mode else imo.invert_this()
elif (operation == 'solarize'):
out_img = imo.solarize_this(gray_scale=True) if image_mode else imo.solarize_this()
else:
out_img = imo.read_this(gray_scale=True) if image_mode else imo.read_this()
out_image_fig = px.imshow(out_img, color_continuous_scale='gray') if image_mode else px.imshow(out_img)
out_image_fig.update_layout(
coloraxis_showscale=False,
width=600, height=400,
margin=dict(l=0, r=0, b=0, t=0)
)
out_image_fig.update_xaxes(showticklabels=False)
out_image_fig.update_yaxes(showticklabels=False)
output_result = html.Div([
dcc.Graph(id='out-op-img', figure=out_image_fig)
], style={'paddingTop' : 50})
return output_result
def plot_image(path):
fig = go.Figure();
# plt.figure(figsize=(12, 12));
# path = image_fetcher.fetch('data/cells.tif')
# path = image_fetcher.fetch('data/cells.tif')
try:
if path != None:
path = path
except:
print(f"Default image:")
path = 'С:/Users/Admin/Documents/JN/NN/COVID_detection_picture/MRI/sick_7c7160149aec1ebf15b28166f5458c49.nii'
# print(type(path))
data = nib.load(path);
print(type(data))
data = data.get_data();
print(type(data[0]), data[0].shape)
data = data.transpose(2,1,0)
print(type(data), data.shape)
data = ndimage.zoom(data, (1, 1, 1), order = 1)
print(data.shape)
img = data[:]
fig = px.imshow(img,
animation_frame = 0,
binary_string = True,
labels = dict(animation_frame = "slice"),
width = 512,
height = 512,
# title = "NIFTI Detection scanner"
)
# fig.show()
return fig
def _generate_heatmap(self):
df = self.pp.get_numeric_df(self.settings['data']).copy()
numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64']
df = df.select_dtypes(include=numerics)
df.rename(columns=lambda x: x[:11], inplace=True)
fig = px.imshow(df)
return html.Div([
html.Div(html.H1(children='Хитмап'),
style={'text-align': 'center'}),
html.Div([
html.Div(dcc.Graph(id='heatmap', figure=fig),
style={
'width': '78%',
'display': 'inline-block',
'border-color': 'rgb(220, 220, 220)',
'border-style': 'solid',
'padding': '5px'
}),
html.Div(dcc.Markdown(children=markdown_text_heatmap),
style={
'width': '18%',
'float': 'right',
'display': 'inline-block'
})
])
],
style={'margin': '100px'})
def visualize(data):
# Histogram Plot
st.sidebar.header('Visualize Data:')
if st.sidebar.checkbox('Plot Histograms of each column:'):
column = st.selectbox('hist_column', data.columns)
color_var = st.selectbox('Color_variable_hist',
[None] + list(data.columns))
bins = st.slider('No:Of Bins',
min_value=1,
max_value=50,
value=10,
step=1)
fig = px.histogram(data, x=column, nbins=bins, color=color_var)
st.plotly_chart(fig, )
if st.sidebar.checkbox("Scatter plot:"):
column1 = st.selectbox('X-axis_scatter', data.columns)
column2 = st.selectbox('Y-axis_scatter', data.columns)
color_var = st.selectbox('Color_variable_scat',
[None] + list(data.columns))
fig = px.scatter(data, x=column1, y=column2, color=color_var)
st.plotly_chart(fig)
if st.sidebar.checkbox("Feature Correlation Plot:"):
corr = data.corr()
fig = px.imshow(corr)
st.plotly_chart(fig)
def get_plot(img, bboxes, class_names, rad_ids, box_ids, width=600):
fig = px.imshow(img, binary_string=True)
# Add image
img_height, img_width = img.shape[:2]
fig.update_layout(width=width, height=width * img_height / img_width)
for box, rad_id, class_name, box_id in zip(bboxes, rad_ids, class_names,
box_ids):
if 'No finding' in class_name:
fig.add_trace(
go.Scatter(
x=[300],
y=[300],
name=f'{rad_id}, {class_name}',
opacity=0,
))
else:
x0, y0, x1, y1 = box
fig.add_trace(
go.Scatter(
x=[x0, x1, x1, x0, x0],
y=[y0, y0, y1, y1, y0],
uid=int(box_id),
hovertemplate=
f'<b>{box_id}</b><br> {rad_id}<br>{class_name}',
text=[class_name],
name=f'{rad_id}, {class_name}',
line=dict(width=2, color=get_contrasted_color(rad_id)),
fillcolor=get_contrasted_color(rad_id),
mode="lines+text",
opacity=1,
))
return fig
def visualize(myimage):
# Converting the image ndarray into image using imshow from plotly.express package and then displaying it using streamlit.plotly_chart
wc_img = px.imshow(myimage)
wc_img.update_xaxes(showticklabels=False).update_yaxes(
showticklabels=False)
st.plotly_chart(wc_img)
return wc_img
def plot_input_layer(arr,
infos=None,
return_fig=False,
render_in_browser=True):
# x expected shape: W,H,16
fig = make_subplots(rows=4, cols=4)
x = arr
for i in range(0, 4):
for j in range(0, 4):
cur_img = x[:, :, i * 4 + j]
title = f"max:{np.amax(cur_img):.4f} min:{np.amin(cur_img):.4f} mean:{np.mean(cur_img):.4f}"
plot = px.imshow(cur_img, labels=dict(x=title))
fig.add_traces(plot.data, rows=i + 1, cols=j + 1)
# plt.title(f"max:{np.amax(x[:,:,i]):.4f} min:{np.amin(x[:,:,i]):.4f} mean:{np.mean(x[:,:,i]):.4f}")
# fig.update_layout(coloraxis_showscale=False)
if infos:
fig.update_layout(
title=
f"train_step:{infos[0]}, ca_step:{infos[1]}, layer:{infos[2]}, batch:{infos[3]}"
)
if render_in_browser:
pio.renderers.default = "browser"
if return_fig:
return fig
else:
fig.show()
def colorhist(img,imgtype,grayimg=None,save=False):
#Plolty Hist
if imgtype=="BGR":
colors=["blue","green","red"]
labels=["blue","green","red"]
elif imgtype=="HSV":
colors=["blue","green","red"]
labels=["H","S","V"]
coldict={}
ff=go.Figure()
bgr_img=None
for i,col in enumerate(colors):
c_img=img[:,:,i]
coldict[col]=c_img
ff.add_trace(go.Histogram(x=c_img.flatten()[c_img.flatten()!=0],marker_color=col,name=labels[i]))
if bgr_img is None:
bgr_img=c_img
else:
bgr_img=cv2.hconcat([bgr_img,c_img])
if grayimg:
ff.add_trace(go.Histogram(x=grayimg.flatten()[grayimg.flatten()!=0],marker_color="gray",name="gray"))
if save:
bgr=px.imshow(bgr_img)
bgr.write_html(f"{imgtype}_colors.html")
bgr.show()
ff.write_html(f"{imgtype}_hist.html")
ff.show()
def update_output_div(year, quarter):
time = str(year) + 'Q' + str(quarter)
wordcloud = WordCloud(font_path=wordcloudFont,
width=300,
height=400,
background_color='white',
max_font_size=10,
max_words=20,
colormap='Set2')
words = countsByQuarter[time]
wordcloud.fit_words(words)
# plot the WordCloud image
fig = px.imshow(wordcloud)
fig.update_yaxes(visible=False, showticklabels=False)
fig.update_xaxes(visible=False, showticklabels=False)
fig.update_layout(title=str(time),
yaxis={
'visible': False,
'showticklabels': False
},
xaxis={
'visible': False,
'showticklabels': False
},
font=dict(family="Courier New, monospace",
size=18,
color="RebeccaPurple"))
return fig
def run_model(n_clicks, n_submit, url):
try:
im = Image.open(requests.get(url, stream=True).raw)
except Exception as e:
print(e)
return px.scatter(title="Error: " + e)
fig = px.imshow(im, title="Original Image")
im_pt = transform(im).unsqueeze(0)
with torch.no_grad():
preds = torch.softmax(model(im_pt), dim=1)
scores = preds.numpy().squeeze()
topk_idx = scores.argsort()[::-1][:10]
top_classes = CLASSES[topk_idx][::-1]
top_scores = scores[topk_idx][::-1]
scores_fig = px.bar(
x=top_scores,
y=top_classes,
labels=dict(x="Confidence", y="Classes"),
title="ImageNet predictions by DEiT-base",
orientation="h",
)
return fig, scores_fig
def update_heatmap(patients_select):
features_nice = [columns_mapping[x] for x in features]
if len(patients_select) > 0:
df_ind_sub = pd.DataFrame(
append_spaceshifts_to_individual_parameters_dataframe(
pd.DataFrame(df_ind[np.isin(df_ind["ID"], patients_select)]),
leaspy)[[
"w_{}".format(i) for i in range(leaspy.model.dimension)
]].mean())
df_ind_sub.index = features_nice
else:
df_ind_sub = pd.DataFrame([0] * leaspy.model.dimension,
index=features_nice)
fig = px.imshow(-df_ind_sub.T,
color_continuous_scale="RdYlGn",
range_color=[-range_w, range_w],
height=height_w)
fig.update_yaxes(showticklabels=False)
fig.update_layout(
margin=dict(l=2, r=2, t=40, b=10),
paper_bgcolor="#f9f9f9",
autosize=True,
#showscale=False,
title={
'text': "Patient space-shifts",
"x": 0.5,
"y": 0.95,
'xanchor': 'center'
})
return fig
def make_default_figure(
images=filelist[0],
stroke_color=class_to_color(DEFAULT_LABEL_CLASS),
stroke_width=int(round(2 ** (DEFAULT_STROKE_WIDTH))),
shapes=[],
):
fig = px.imshow(io.imread(images))
fig.update_layout(
dragmode="drawclosedpath",
margin=dict(l=0, r=0, b=0, t=0, pad=4),
shapes=shapes,
uirevision=images,
newshape=dict(
line_color=stroke_color,
line_width=stroke_width,
opacity=0.5,
fillcolor= stroke_color,
)
)
fig.update_layout(
dragmode="drawclosedpath",
)
return fig
def plot_heatmap(fobject,
other_objects=None,
metrics='all',
title=None,
verbose=True,
**kwargs):
if metrics == 'all':
metrics = list(fobject.parity_loss.index)
data = _unwrap_parity_loss_data(fobject, other_objects, metrics, verbose=verbose)
score_data = data.score.values.reshape(len(data.label.unique()), len(data.metric.unique()))
fig = px.imshow(score_data,
labels=dict(x="parity loss metrics", y="model", color="Metric's parity loss"),
x=list(data.metric.unique()),
y=list(data.label.unique()),
color_continuous_scale=["#c7f5bf", "#8bdcbe", "#46bac2", "#4378bf", "#371ea3"])
if title is None:
title = "Fairness Heatmap"
fig.update_layout(_fairness_theme(title))
fig.update_traces(
hovertemplate="<br>".join([
"<b>%{y}</b><br>",
"Parity loss metric: %{x}",
"parity loss: %{z:.3f}",
"<extra></extra>"
]))
return fig
def missing_structure(data, n_clicks):
df = pd.DataFrame(data)
if n_clicks is None or n_clicks % 2 == 0:
pass
elif n_clicks % 2 == 1:
for i in range(0, len(combined_columns), 2):
df[combined_columns[i]] = df[combined_columns[i]].fillna(
df[combined_columns[i + 1]])
df[combined_columns[i]] = df[combined_columns[i]].mask(df[combined_columns[i]] == 0).fillna(
df[combined_columns[i + 1]])
for i in range(1, len(combined_columns), 2):
df[combined_columns[i]] = df[combined_columns[i]].fillna(
df[combined_columns[i - 1]])
df[combined_columns[i]] = df[combined_columns[i]].mask(df[combined_columns[i]] == 0).fillna(
df[combined_columns[i - 1]])
for i in range(len(summer_columns)):
df[error_columns[i]] = df[[summer_columns[i], winter_columns[i]]
].isnull().apply(lambda x: any(x), axis=1)
fig = px.imshow(df[error_columns].T, color_continuous_scale=px.colors.sequential.Greys,
title="Missing Structure")
fig.update_layout(title_font={'size': 27}, title_x=0.5)
return fig
def plotgraphs(e,acu,val_acu,loss,val_loss,m,accuracy_score):
file = open(base_dir+"/classification/templates/temp_graphs.html","r+")
file.truncate(0)
file.close()
fig = go.Figure()
fig.add_trace(go.Scatter(x=list(range(1,e)), y=acu, name='training accuracy',line=dict(color='firebrick'),mode='lines'))
fig.add_trace(go.Scatter(x=list(range(1,e)), y=val_acu, name='val accuracy',line=dict(color='royalblue'),mode='lines'))
fig.update_layout(title='Accuracy', xaxis_title='Epochs',yaxis_title='accuracy')
with open(base_dir+'/classification/templates/temp_graphs.html', 'a') as f:
f.write(fig.to_html(full_html=False, include_plotlyjs='cdn'))
fig = go.Figure()
fig.add_trace(go.Scatter(x=list(range(1,e)), y=loss, name='training loss',line=dict(color='firebrick'),mode='lines'))
fig.add_trace(go.Scatter(x=list(range(1,e)), y=val_loss, name='val loss',line=dict(color='royalblue'),mode='lines'))
fig.update_layout(title='Loss', xaxis_title='epochs',yaxis_title='loss')
with open(base_dir+'/classification/templates/temp_graphs.html', 'a') as f:
f.write(fig.to_html(full_html=False, include_plotlyjs='cdn'))
fig=px.imshow(m)
fig.update_layout(title='accuracy = {}'.format(accuracy_score))
with open(base_dir+'/classification/templates/temp_graphs.html', 'a') as f:
f.write(fig.to_html(full_html=False, include_plotlyjs='cdn'))
def callback(url, run, threshold, head, options):
try:
im = download_img(url)
except:
return go.Figure().update_layout(title="Incorrect URL")
ix = int(head)
# Run model
img = transform(im).to(device)
attentions, w_featmap, h_featmap = predict(img)
th_attn, scalar_attn = apply_threshold(attentions, w_featmap, h_featmap, threshold)
attns = th_attn if "use threshold" in options else scalar_attn
if "overlay" in options:
fig = px.imshow(im)
fig.add_trace(go.Heatmap(z=attns[ix], opacity=0.55))
else:
fig = make_subplots(1, 2)
fig.add_trace(go.Image(z=im), 1, 1)
fig.add_trace(go.Heatmap(z=attns[ix]), 1, 2)
fig.update_xaxes(matches="x")
fig.update_yaxes(matches="y")
return fig
def update_graph(select_pillar1):
if not select_pillar1:
raise PreventUpdate
# topic = 'TRQ'
topic = select_pillar1
if 'data' in globals():
del data
data = load_data()
selected = data[data['Topics'].str.contains(topic)].sort_values('Year')
selected_symbols = selected['Symbol'].tolist()
selected_docs = selected['Words'].tolist()
sim_sorted = calc_similarity(selected_symbols,
selected_docs,
kRandom=3,
nClusters=3,
sortCluster=False)
figure = px.imshow(sim_sorted)
figure.update_layout(height=800,
width=800,
font=dict(family="Courier New, monospace",
size=8,
color="RebeccaPurple"),
xaxis=dict(autorange='reversed'))
return figure
def _make_figure(self, overlap_matrix, labels):
figure = px.imshow(overlap_matrix, x=labels, y=labels, zmin=0, zmax=100, color_continuous_scale=px.colors.sequential.Teal,
template='plotly_white')
figure.update_traces(hovertemplate="Overlap of disease-associated<br>sequences between datasets<br>%{x} and %{y}:<br>%{z}%<extra></extra>")
figure_path = self.result_path + "sequence_overlap.html"
figure.write_html(figure_path)
return figure_path
def update_graph(select_pillar2):
if not select_pillar2:
raise PreventUpdate
if 'data' in globals():
del data
data = load_data()
topic = select_pillar2
text = " ".join(
review for review in data[data["Topics"].str.contains(topic)]['text'])
# Generate a word cloud image
wordcloud = WordCloud(background_color="white", width=900,
height=600).generate(text)
# Display the generated image:
figure = px.imshow(wordcloud)
figure.update_layout(
width=800,
height=650,
xaxis_visible=False,
yaxis_visible=False,
font=dict(family="Courier New, monospace",
size=8,
color="RebeccaPurple"),
)
return figure
def update_test_output(n_clicks, contents,tab, patch_size, inline_number,filename):
content_type, content_string = contents[0].split(',')
decoded = base64.b64decode(content_string)
file_like_object = io.BytesIO(decoded)
vol = np.load(file_like_object,allow_pickle=True)
volume=vol[:100,:patch_size,:patch_size]
volume = volume.T
if tab == 'tab-1':
fig=show_cube(volume)
return html.Div([
dcc.Graph(figure=fig)
])
elif tab == 'tab-2':
fig2 = px.imshow(vol[inline_number])
return html.Div([
dcc.Graph(figure=fig2)
])
elif tab == 'tab-3':
#command="python test.py --patch_size "+str(patch_size)+"--inline_number"+str(inline_number)
#subprocess.call(command, shell=True)
return html.Div([
html.H5("Tab content 3")
])
def create_image(self, matrix, file_path):
ratio = 8
fig = px.imshow(matrix)
fig.update_layout(width=int(matrix.shape[1] * ratio),
height=int(matrix.shape[0] * ratio),
margin=dict(l=2, r=2, b=2, t=2))
fig.write_image(file_path)
