def exp_border(exp_range=[],
fx_f=None,
fy_f=None,
mask=None,
young=1,
out_folder="",
method="binary_dilation"):
tensor_folder = createFolder(os.path.join(out_folder, "stress_tensors"))
mask_folder = createFolder(os.path.join(out_folder, "masks"))
stress_tensors = []
mask_exp_list = []
mask = mask.astype(int)
for i in tqdm(exp_range):
mask_exp = expand_mask(mask, i, mask.shape, method=method)
UG_sol, stress_tensor_f = stress_wrapper(mask_exp.astype(bool),
fx_f,
fy_f,
young,
sigma=0.5)
np.save(os.path.join(tensor_folder, "stress_tensor_f%s.npy" % str(i)),
stress_tensor_f)
np.save(os.path.join(mask_folder, "%s.npy" % str(i)), mask_exp)
stress_tensors.append(stress_tensor_f)
mask_exp_list.append(mask_exp)
mean_normal_list = [(st[:, :, 0, 0] + st[:, :, 1, 1]) / 2
for st in stress_tensors]
return stress_tensors, mean_normal_list, mask_exp_list
def cut_images(folder, files_dict, names=["after_shift.tif", "before_shift.tif", "bf_before_shift.tif"]):
for exp, frames_dict in files_dict.items():
new_folder = os.path.join(folder, exp + "_shift")
createFolder(new_folder)
for frame, img_files in frames_dict.items():
print("experiment", exp)
print("frame", frame)
print("image_file", img_files)
img_b = np.asarray(Image.open(img_files["before"]))
img_a = np.asarray(Image.open(img_files["after"]))
imb_b_BF = np.asarray(Image.open(img_files["bf"]))
shift_values = register_translation(img_b, img_a, upsample_factor=100)
shift_y = shift_values[0][0]
shift_x = shift_values[0][1]
# using interpolation to shift subpixel precision
img_shift_b = shift(img_b, shift=(-shift_y, -shift_x), order=5)
img_shift_bf = shift(imb_b_BF, shift=(-shift_y, -shift_x), order=5)
b = normalizing(croping_after_shift(img_shift_b, shift_x, shift_y))
a = normalizing(croping_after_shift(img_a, shift_x, shift_y))
bf = normalizing(croping_after_shift(img_shift_bf, shift_x, shift_y))
b_save = Image.fromarray(b * 255)
a_save = Image.fromarray(a * 255)
bf_save = Image.fromarray(bf * 255)
b_save.save(os.path.join(new_folder, frame + "after_shift.tif"))
a_save.save(os.path.join(new_folder, frame + "before_shift.tif"))
bf_save.save(os.path.join(new_folder, frame + "bf_before_shift.tif"))
def def_test():
for i in np.linspace(0, 0.5, 5):
out_folder = "/media/user/GINA1-BK/data_traction_force_microscopy/ev_square_square_edge_no_filter"
createFolder(out_folder)
print(i)
young = 1
h = 100
pixelsize = 1
f_type = "circular" # display_option
filter = None
mask = setup_geometry(im_shape=(100, 100),
shape_size=50,
shape="rectangle")
stress_tensor_b = setup_stress_field(mask,
distribution="uniform",
sigma_n=1,
sigma_shear=0,
sigma_gf=6)
fx_b, fy_b = force_from_stress_field(stress_tensor_b,
pixelsize,
plot=False,
grad_type="diff1")
u_b, v_b = finite_thickness_convolution(
fx_b,
fy_b,
pixelsize,
h,
young,
sigma=0.5,
kernel_size=None,
force_shift=i) # somwhat of an approximationn
fx_f, fy_f = traction_wrapper(u_b,
v_b,
pixelsize,
h,
young,
mask=mask,
filter=filter) # assuming pixelsize == 1
save_def_test(fx_b,
fy_b,
fx_f,
fy_f,
out_folder,
iteration=str(int(i * 10)))
def exp_border(exp_range=[],
fx=None,
fy=None,
mask=None,
young=1,
out_folder="",
method="binary_dilation",
verbose=False):
tensor_folder = createFolder(os.path.join(out_folder, "stress_tensors"))
mask_folder = createFolder(os.path.join(out_folder, "masks"))
stress_tensors = []
mask_exp_list = []
mask = mask.astype(int)
for i in tqdm(exp_range):
mask_exp = expand_mask(mask, i, mask.shape, method=method)
fx_f = fx.copy()
fy_f = fy.copy()
fx_f[~mask_exp.astype(
bool)] = np.nan # setting all values outside of mask area to zero
fy_f[~mask_exp.astype(bool)] = np.nan
fx_f2 = fx_f - np.nanmean(
fx_f
) # normalizing traction force to sum up to zero (no displacement)
fy_f2 = fy_f - np.nanmean(fy_f)
fx_f2, fy_f2, p = correct_torque(fx_f2, fy_f2,
mask.astype(bool)) # correct forces
#if np.any(np.isnan(fx_f2[mask_exp.astype(bool)])):
# print("####")
# print("####", np.any(np.isnan(fy_f2[mask_exp.astype(bool)])))
UG_sol, stress_tensor_f = stress_wrapper(mask_exp.astype(bool),
fx_f2,
fy_f2,
young,
sigma=0.5,
verbose=verbose)
np.save(os.path.join(tensor_folder, "stress_tensor_f%s.npy" % str(i)),
stress_tensor_f)
np.save(os.path.join(mask_folder, "%s.npy" % str(i)), mask_exp)
stress_tensors.append(stress_tensor_f)
mask_exp_list.append(mask_exp)
mean_normal_list = [(st[:, :, 0, 0] + st[:, :, 1, 1]) / 2
for st in stress_tensors]
return stress_tensors, mean_normal_list, mask_exp_list
def cut_images(folder, files_dict, names=["after_shift.tif", "before_shift.tif", "bf_before_shift.tif"]):
for exp, frames_dict in files_dict.items():
new_folder = os.path.join(folder, exp + "_shift")
createFolder(new_folder)
for frame, img_files in frames_dict.items():
print("experiment", exp)
print("frame", frame)
print("image_file", img_files)
img_b = np.asarray(Image.open(img_files["before"]))
img_a = np.asarray(Image.open(img_files["after"]))
imb_b_BF = np.asarray(Image.open(img_files["bf"]))
b, a [bf], (shift_x, shift_y) = correct_stage_drift(img_b, img_a, additional_images=[imb_b_BF])
b_save.save(os.path.join(new_folder, frame + "after_shift.tif"))
a_save.save(os.path.join(new_folder, frame + "before_shift.tif"))
bf_save.save(os.path.join(new_folder, frame + "bf_before_shift.tif"))
def general_display(plot_types=[],
pixelsize=1,
display_type="outline",
f_type="not circular",
cmap="coolwarm",
max_dict=defaultdict(lambda: None),
mean_normal_list=None,
mask_exp_list=None,
out_folder="",
fields={},
border_ex_test=None,
be_avm_list=None,
scalar_comaprisons=None,
strain_energies=None,
contractilities=None,
key_values=None,
plot_gt_exp=True,
dm=True,
at=True,
cb=True,
do=True):
'''
plot_types=["deformation_forward","deformation_backwards","mask","forces_forward","forces_forward","shear_forward","mean_normal_stress_forward",
"shear_backward","mean_normal_stress_backward","full_stress_tensor_forward","full_stress_tensor_backward"]
:param plot_types:
:param pixelsize:
:return:
'''
u_b, v_b, fx_b, fy_b, fx_f, fy_f, stress_tensor_f, stress_tensor_b, mask_fm, mask_fem, mask = \
[fields[x] for x in
["u_b", "v_b", "fx_b", "fy_b", "fx_f", "fy_f", "stress_tensor_f", "stress_tensor_b", "mask_fm", "mask_fem",
"mask"]]
figs = {}
createFolder(out_folder)
types = {
"def_f": "deformation_forward",
"def_b": "deformation_backwards",
"mask": "mask",
"f_f": "forces_forward",
"f_b": "forces_backward",
"st_f": "full_stress_tensor_forward",
"st_b": "full_stress_tensor_backward",
"sh_f": "shear_forward",
"sh_b": "shear_backward",
"norm_f": "mean_normal_stress_forward",
"norm_b": "mean_normal_stress_backward",
"m": "key measures",
"r": "correlation",
"exp_test1": "be1",
"exp_test2": "be2",
"exp_test2A": "be2A",
"exp_test3": "be3",
"exp_test4": "be4",
"exp_test5": "be5",
"mask_outline": "mask_outline",
"cbars": "cbars_only"
}
figsize = (7, 7)
arrow_scale = 0.13 # 0.1
arrow_width = 0.004
headlength = 4
headwidth = 4 # 6
headaxislength = 3
ext = ".svg"
mask_fm_color = "C2"
mask_fem_color = "#666666"
mask_outline_color = "#FFEF00"
mask_lw = 4
mask_line_dashes = (2, 1)
ps_new_ex = pixelsize # pixelsize when using windowsize 20, overlap 19.25
vmax_x_ep = 65 * 0.845
pd = {
"figsize": figsize,
"arrow_scale": arrow_scale,
"arrow_width": arrow_width,
"headlength": headlength,
"headwidth": headwidth,
"headaxislength": headaxislength,
"ext": ext,
"mask_fm_color": mask_fm_color,
"mask_fem_color": mask_fem_color,
"mask_outline_color": mask_outline_color,
"dashes": mask_line_dashes,
"mask_lw": mask_lw
}
paras = {**locals(), **pd}
if isinstance(mask_fem, np.ndarray):
mask_fem = mask_fem.astype(bool)
if types["def_b"] in plot_types or plot_types == "all":
fig, ax = show_quiver(u_b,
v_b,
scale_ratio=arrow_scale,
filter=[0, 5],
width=arrow_width,
headlength=headlength,
headwidth=headwidth,
headaxislength=2,
cbar_tick_label_size=30,
cmap=cmap,
cbar_style="not-clickpoints",
vmin=0,
vmax=max_dict["def"],
plot_cbar=cb)
draw_outline(ax, do=do)
add_title(fig, types["def_b"], at=at)
display_mask(fig,
mask,
display_type=display_type,
dm=dm,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes)
display_mask(fig,
mask_fm,
display_type=display_type,
color=mask_fm_color,
d=np.sqrt(2),
dm=dm,
lw=mask_lw,
dashes=mask_line_dashes)
fig.savefig(
os.path.join(out_folder,
types["def_b"] + name_add(cb=cb, dm=dm) + ext))
if types["cbars"] in plot_types or plot_types == "all":
# cbar for stress
fig = plt.figure(figsize=(3.2, 4.75))
plt.gca().set_axis_off()
cbar = add_colorbar(vmin=0,
vmax=1 + 0.01,
aspect=8,
shrink=1,
cbar_axes_fraction=1.2,
cmap=cmap,
cbar_style="not-clickpoints")
set_axis_attribute(cbar.ax, "set_color", "black")
cbar.ax.tick_params(axis="both",
which="both",
color="black",
length=4,
width=2,
labelsize=20,
labelcolor="black")
fig.savefig(
os.path.join(
out_folder,
types["cbars"] + "force" + name_add(cb=cb, dm=dm) + ext))
# cbar for stress
fig = plt.figure(figsize=(3.2, 4.75))
plt.gca().set_axis_off()
cbar = add_colorbar(vmin=0,
vmax=1 + 0.01,
aspect=8,
shrink=1,
cbar_axes_fraction=1.2,
cmap=cmap,
cbar_style="not-clickpoints")
set_axis_attribute(cbar.ax, "set_color", "black")
cbar.ax.tick_params(axis="both",
which="both",
color="black",
length=4,
width=2,
labelsize=20,
labelcolor="black")
fig.savefig(
os.path.join(
out_folder,
types["cbars"] + "stress" + name_add(cb=cb, dm=dm) + ext))
if types["mask"] in plot_types or plot_types == "all":
fig = plt.figure()
plt.imshow(mask)
add_title(fig, types["mask"], at=at)
fig.savefig(os.path.join(out_folder, types["mask"] + ext))
if types["mask_outline"] in plot_types or plot_types == "all":
fig = plt.figure()
plt.imshow(np.zeros(fx_f.shape), cmap=cmap, vmin=0, vmax=1)
draw_outline(plt.gca(), do=do)
try:
display_mask(fig,
mask,
display_type="outline",
dm=True,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes)
display_mask(fig,
mask_fm,
display_type="outline",
color=mask_fm_color,
d=np.sqrt(2),
dm=True,
lw=mask_lw,
dashes=mask_line_dashes)
display_mask(fig,
mask_fem,
display_type="outline",
color=mask_fem_color,
d=np.sqrt(2),
dm=True,
lw=mask_lw,
dashes=mask_line_dashes)
except RecursionError as e:
print(e)
if types["f_f"] in plot_types or plot_types == "all":
show_forces_forward(**paras)
if types["f_b"] in plot_types or plot_types == "all":
if f_type == "circular":
fx_filtered, fy_filtered = filter_arrows_for_square(
fx_b, fy_b,
filter=12) # only works when initial forces are circular
fig, ax = show_quiver(fx_filtered,
fy_filtered,
figsize=figsize,
scale_ratio=arrow_scale,
filter=[0, 0],
width=arrow_width,
headlength=headlength,
headwidth=headwidth,
headaxislength=headaxislength,
cbar_tick_label_size=30,
cmap=cmap,
cbar_style="not-clickpoints",
vmin=0,
vmax=max_dict["force"],
plot_cbar=cb)
im = fig.axes[0].imshow(np.sqrt(fx_b**2 + fy_b**2),
cmap=cmap,
vmin=0,
vmax=max_dict["force"])
if cb:
fig.axes[1].remove()
cb = plt.colorbar(im)
cb.ax.tick_params(labelsize=30)
plt.tight_layout()
else:
fx_filtered, fy_filtered = fx_b, fy_b
fig, ax = show_quiver(fx_filtered,
fy_filtered,
figsize=figsize,
scale_ratio=arrow_scale - 0.03,
filter=[0, 10],
width=arrow_width,
headlength=headlength,
headwidth=headwidth,
headaxislength=headaxislength,
cbar_tick_label_size=30,
cmap=cmap,
cbar_style="not-clickpoints",
vmin=0,
vmax=max_dict["force"],
plot_cbar=cb)
draw_outline(ax, do=do)
add_title(fig, types["f_b"], at=at)
display_mask(fig,
mask,
display_type=display_type,
dm=dm,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes)
# display_mask(fig, mask_fm, display_type=display_type, color=mask_fm_color,d=np.sqrt(2), dm=dm)
plt.tight_layout()
fig.savefig(
os.path.join(out_folder,
types["f_b"] + name_add(cb=cb, dm=dm) + ext))
if types["sh_f"] in plot_types or plot_types == "all":
shear = stress_tensor_f[:, :, 0,
1] # shear component of the stress tensor
fig, ax = show_map_clickpoints(shear,
show_mask=mask_fem,
figsize=figsize,
cbar_style="out",
cmap=cmap,
cbar_tick_label_size=30,
vmin=0,
vmax=max_dict["stress"],
plot_cbar=cb)
draw_outline(ax, do=do)
add_title(fig, types["sh_f"], at=at)
display_mask(fig,
mask,
display_type=display_type,
dm=dm,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes)
plt.tight_layout()
fig.savefig(
os.path.join(out_folder,
types["sh_f"] + name_add(cb=cb, dm=dm) + ext))
if types["norm_f"] in plot_types or plot_types == "all":
mean_normal_stress = (
(stress_tensor_f[:, :, 0, 0] + stress_tensor_f[:, :, 1, 1]) / 2)
mean_normal_stress[~mask_fem] = np.nan
fig, ax = show_map_clickpoints(mean_normal_stress,
show_mask=mask_fem,
figsize=figsize,
cbar_style="out",
background_color="white",
cmap=cmap,
cbar_tick_label_size=30,
vmin=0,
vmax=max_dict["stress"],
plot_cbar=cb)
draw_outline(ax, do=do)
add_title(fig, types["norm_f"], at=at)
display_mask(fig,
mask,
display_type=display_type,
dm=dm,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes)
plt.tight_layout()
# display_mask(fig, mask_fem, display_type=display_type, color=mask_fem_color, d=np.sqrt(2), dm=dm)
fig.savefig(
os.path.join(out_folder,
types["norm_f"] + name_add(cb=cb, dm=dm) + ext))
if types["sh_b"] in plot_types or plot_types == "all":
shear = stress_tensor_b[:, :, 0,
1] # shear component of the stress tensor
fig, ax = show_map_clickpoints(shear,
show_mask=mask_fem,
figsize=figsize,
cbar_style="out",
cmap=cmap,
cbar_tick_label_size=30,
vmin=0,
vmax=max_dict["stress"],
plot_cbar=cb)
display_mask(fig,
mask,
display_type=display_type,
dm=dm,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes)
draw_outline(ax, do=do)
add_title(fig, types["sh_b"], at=at)
plt.tight_layout()
fig.savefig(
os.path.join(out_folder,
types["sh_b"] + name_add(cb=cb, dm=dm) + ext))
if types["norm_b"] in plot_types or plot_types == "all":
mean_normal_stress = (
(stress_tensor_b[:, :, 0, 0] + stress_tensor_b[:, :, 1, 1]) / 2)
mean_normal_stress[~mask_fem] = np.nan
fig, ax = show_map_clickpoints(mean_normal_stress,
show_mask=np.ones(
mean_normal_stress.shape),
figsize=figsize,
cbar_style="out",
background_color="white",
cmap=cmap,
cbar_tick_label_size=30,
vmin=0,
vmax=max_dict["stress"],
plot_cbar=cb)
draw_outline(ax, do=do)
add_title(fig, types["norm_b"], at=at)
display_mask(fig,
mask,
display_type=display_type,
dm=dm,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes)
# display_mask(fig, mask_fem, display_type=display_type, color=mask_fem_color, d=np.sqrt(2), dm=dm)
plt.tight_layout()
fig.savefig(
os.path.join(out_folder,
types["norm_b"] + name_add(cb=cb, dm=dm) + ext))
if types["st_f"] in plot_types or plot_types == "all":
fig = display_stress_tensor(stress_tensor_f,
mask,
title_str=types["st_f"])
display_mask(fig,
mask,
display_type=display_type,
type=2,
dm=dm,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes)
plt.tight_layout()
fig.savefig(
os.path.join(out_folder,
types["st_f"] + name_add(cb=cb, dm=dm) + ext))
if types["st_b"] in plot_types or plot_types == "all":
fig = display_stress_tensor(stress_tensor_b,
mask,
title_str=types["st_b"])
display_mask(fig,
mask,
display_type=display_type,
type=2,
dm=dm,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes)
plt.tight_layout()
fig.savefig(
os.path.join(out_folder,
types["st_b"] + name_add(cb=cb, dm=dm) + ext))
if types["m"] in plot_types or plot_types == "all":
fig = bar_plots_pylu(key_values)
fig.savefig(os.path.join(out_folder, types["m"] + ext))
# values1 = [key_values["contractile_force_b"],key_values["contractile_force_f"]]
# labels1 = ["contractility", "contractility"]
# values2 =[key_values['mean_normal_stress_b'],key_values['mean_normal_stress_f'], key_values["mean_shear_b"], key_values["mean_shear_f"]]
# labels2 =["mean normal stress", "mean normal stress", "meanshear stress", "mean shear stress"]
# values3 = [key_values["cv_b"], key_values["cv_f"]]
# lables3 = ["cv", "cv"]
# fig1, ax1 = bar_plot(ax, values1, labels1, at=False, types=types)
# fig1.savefig(os.path.join(out_folder, types["m"] + "1" + ext))
# fig2, ax2 = bar_plot(values2, labels2, at=False, types=types)
# fig2.savefig(os.path.join(out_folder, types["m"] + "2" + ext))
# fig3, ax3 = bar_plot(values3, lables3, at=False, types=types, vmax=1)
# fig3.savefig(os.path.join(out_folder, types["m"] + "3" + ext))
if types["r"] in plot_types or plot_types == "all":
rs = {
key: value['r_squared']
for key, value in scalar_comaprisons.items()
if not np.isnan(value['r_squared'])
and key in ["forces", "mean normal stress"]
}
fig = plt.figure(figsize=(3.2, 4.75))
pos = [1, 1.7]
plt.bar(pos, list(rs.values()), width=0.4, color="C5")
# plt.xticks(rotation="70",fontsize=15)
# plt.xticks(rotation="70",fontsize=15)
plt.xticks(pos)
plt.gca().tick_params(axis="both",
which="both",
color="black",
length=4,
width=2,
labelsize=20,
labelcolor="black",
labelbottom=False)
set_axis_attribute(plt.gca(), "set_color", "black")
set_axis_attribute(plt.gca(), "set_linewidth", 2)
if at:
plt.title(types["r"])
plt.ylim((0, 1))
plt.tight_layout()
fig.savefig(os.path.join(out_folder, types["r"] + ext))
if types["exp_test1"] in plot_types or plot_types == "all" and len(
mean_normal_list) > 0:
fig = show_exp_test(mean_normal_list=mean_normal_list,
max_dict=max_dict,
mask_exp_list=mask_exp_list)
fig.savefig(os.path.join(out_folder, "expansion1" + ext))
if types["exp_test2"] in plot_types or plot_types == "all":
# average normal stress relative to groundtruth stress
fig = plt.figure()
be = np.array(border_ex_test) * ps_new_ex
if plot_gt_exp:
plt.plot(be, be_avm_list, color="C3", linewidth=5)
plt.plot(be, [1] * (len(be_avm_list)), color="C4", linewidth=5)
plt.ylim((0, max_dict["stress"] * 1.2))
else:
plt.plot(be, be_avm_list, color="C3", linewidth=5)
plt.ylim((0, max_dict["stress"] * 1.2))
plt.xlim(0, vmax_x_ep)
plt.gca().tick_params(axis="both",
which="both",
color="black",
length=4,
width=2,
labelsize=20,
labelcolor="black")
set_axis_attribute(plt.gca(), "set_color", "black")
set_axis_attribute(plt.gca(), "set_linewidth", 2)
# plt.title(types["exp_test2"])
plt.tight_layout()
fig.savefig(
os.path.join(out_folder, "avg_normal_stress_expansion" + ext))
if types["exp_test2A"] in plot_types or plot_types == "all":
# average normal stress relative to groundtruth stress
fig = plt.figure()
be = np.array(border_ex_test) * ps_new_ex
be_avm_listN = np.array(be_avm_list) / np.max(
be_avm_list) # normalizing
contractilitiesN = contractilities / contractilities.max()
strain_energiesN = strain_energies / strain_energies.max()
plt.plot(be, be_avm_listN, color="C3", linewidth=5, label="stress")
plt.plot(be,
contractilitiesN,
color="C2",
linewidth=5,
label="contractility")
#plt.plot(be, strain_energiesN, color="C4", linewidth=5, label="strain energy")
plt.legend()
plt.ylim((0, 1 * 1.1))
plt.xlim(0, vmax_x_ep)
plt.gca().tick_params(axis="both",
which="both",
color="black",
length=4,
width=2,
labelsize=20,
labelcolor="black")
set_axis_attribute(plt.gca(), "set_color", "black")
set_axis_attribute(plt.gca(), "set_linewidth", 2)
# plt.title(types["exp_test2"])
plt.tight_layout()
fig.savefig(
os.path.join(out_folder,
"stress_force_expansion_normalized1" + ext))
fig = plt.figure()
be = np.array(border_ex_test) * ps_new_ex
be_avm_listN = np.array(be_avm_list) / key_values[
"mean_normal_stress_b"] # normalizing
contractilitiesN = contractilities / key_values["contractile_force_b"]
strain_energiesN = strain_energies / key_values["cont_energy_b"]
plt.plot(be, be_avm_listN, color="C3", linewidth=5, label="stress")
plt.plot(be,
contractilitiesN,
color="C2",
linewidth=5,
label="contractility")
#plt.plot(be, strain_energiesN, color="C4", linewidth=5, label="strain energy")
plt.legend()
plt.ylim((0, 1 * 1.1))
plt.xlim(0, vmax_x_ep)
plt.gca().tick_params(axis="both",
which="both",
color="black",
length=4,
width=2,
labelsize=20,
labelcolor="black")
set_axis_attribute(plt.gca(), "set_color", "black")
set_axis_attribute(plt.gca(), "set_linewidth", 2)
# plt.title(types["exp_test2"])
plt.tight_layout()
fig.savefig(
os.path.join(out_folder,
"stress_force_expansion_normalized_gt" + ext))
if types["exp_test2"] in plot_types or plot_types == "all":
# average normal stress relative to groundtruth stress
if len(be_avm_list) > 0:
fig = plt.figure()
be = np.array(border_ex_test) * ps_new_ex
be_avm_list = np.array(be_avm_list) / np.max(
be_avm_list) # normalizing
if plot_gt_exp:
plt.plot(be, be_avm_list, color="C3", linewidth=5)
plt.plot(be, [1] * (len(be_avm_list)), color="C4", linewidth=5)
plt.ylim((0, 1.1))
else:
plt.plot(be, be_avm_list, color="C3", linewidth=5)
plt.ylim((0, 1.1))
plt.xlim(0, vmax_x_ep)
plt.gca().tick_params(axis="both",
which="both",
color="black",
length=4,
width=2,
labelsize=20,
labelcolor="black")
set_axis_attribute(plt.gca(), "set_color", "black")
set_axis_attribute(plt.gca(), "set_linewidth", 2)
# plt.title(types["exp_test2"])
plt.tight_layout()
fig.savefig(
os.path.join(out_folder,
"avg_normal_stress_expansion_normalized" + ext))
if types["exp_test3"] in plot_types or plot_types == "all" and len(
mean_normal_list) > 0:
# displaying forces and masks
nf = createFolder(os.path.join(out_folder, "exp_plots_forces"))
max_dict_local = {"force": None}
for i, m_exp in enumerate(mask_exp_list):
pl = copy.deepcopy(paras)
pl.update({
"dm": True,
"show_fm": True,
"mask_fm": m_exp.astype(bool),
"add_name": "_exp" + str(i),
"out_folder": nf,
"max_dict": max_dict_local,
"fx_f": fields["fx_f_exp"],
"fy_f": fields["fy_f_exp"],
"mask": fields["mask_exp"]
})
try:
fig, ax = show_forces_forward(**pl)
except RecursionError:
pass
if types["exp_test4"] in plot_types or plot_types == "all" and len(
mean_normal_list) > 0:
sub_folder_stress = createFolder(os.path.join(out_folder, "stresses"))
sub_folder_force = createFolder(os.path.join(out_folder, "forces"))
for i, (ms,
mask_expand) in enumerate(zip(mean_normal_list,
mask_exp_list)):
fig, ax = show_map_clickpoints(ms,
cbar_style="out",
figsize=figsize,
cmap=cmap,
cbar_tick_label_size=30,
vmin=0,
vmax=max_dict["stress"])
add_title(fig, types["norm_b"], at=at)
display_mask(fig,
mask,
display_type=display_type,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes)
display_mask(fig,
mask_expand,
display_type=display_type,
color="C3",
lw=mask_lw,
dashes=mask_line_dashes)
fig.savefig(
os.path.join(sub_folder_stress,
types["exp_test4"] + "%s" % str(i) + ext))
fig, ax = show_quiver(fx_f,
fy_f,
figsize=figsize,
scale_ratio=arrow_scale,
filter=[0, 10],
width=arrow_width,
headlength=3,
headwidth=4,
headaxislength=2,
cbar_tick_label_size=30,
cmap=cmap,
cbar_style="not-clickpoints",
vmin=0,
vmax=1600)
add_title(fig, types["f_f"], at=at)
display_mask(fig,
mask,
display_type=display_type,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes,
dm=dm)
display_mask(fig,
mask_expand,
display_type=display_type,
color="C3",
dm=dm,
lw=mask_lw,
dashes=mask_line_dashes)
plt.tight_layout()
fig.savefig(
os.path.join(sub_folder_force,
types["exp_test4"] + "%s" % str(i) + ext))
if types["exp_test5"] in plot_types or plot_types == "all" and len(
mean_normal_list) > 0:
pl = copy.deepcopy(paras)
pl["dm"] = False
pl["figsize"] = (np.mean(paras["figsize"]) *
fields["mask_exp"].shape[1] /
fields["mask_exp"].shape[0],
np.mean(paras["figsize"]) * 1.022 * mask.shape[0] /
fields["mask_exp"].shape[1])
pl["fx_f"] = fields["fx_f_exp"]
pl["fy_f"] = fields["fy_f_exp"]
pl["max_dict"] = {"force": None}
pl["filter"] = [0, 7]
pl["filter_method"] = "local_maxima"
pl["filter_radius"] = 9
fig, ax = show_forces_forward(**pl)
ax.set_xlim(-0.5, 0.5 + fields["mask_exp"].shape[1])
ax.set_ylim(0.5 + fields["mask_exp"].shape[0], -0.5)
add_title(fig, types["f_f"], at=at)
be = np.array(border_ex_test) * ps_new_ex
# display_mask(fig, mask_exp_list[0], display_type=display_type, color=mask_fm_color, d=np.sqrt(2), dm=True, lw=7)
max_id = np.argmax(be_avm_list)
try:
# max_id=23
# max_id_disp = max_id + 4 if len(mask_exp_list) > max_id + 4 else len(mask_exp_list) - 1
display_mask(fig,
mask_exp_list[max_id],
display_type=display_type,
color=mask_fm_color,
d=np.sqrt(2),
dm=True,
lw=mask_lw,
dashes=mask_line_dashes) # mask_exp_list[max_id+6]
display_mask(fig,
fields["mask_exp"],
display_type=display_type,
color=mask_outline_color,
lw=mask_lw,
dashes=mask_line_dashes,
dm=True)
end_id = np.argmin(np.abs(be - vmax_x_ep))
display_mask(fig,
mask_exp_list[end_id],
display_type=display_type,
color=mask_fm_color,
d=np.sqrt(2),
dm=True,
lw=mask_lw,
dashes=mask_line_dashes)
except RecursionError as e:
print(e)
ax.set_position([0, 0, 1, 1])
fig.set_frameon(False)
if ext == ".svg":
print(out_folder)
fig.savefig(os.path.join(out_folder, "exp_forces_example" + ext))
else:
fig.savefig(os.path.join(out_folder, "exp_forces_example" + ext),
dpi=300)
fig, ax = show_quiver(x, y, figsize=figsize, scale_ratio=arrow_scale - 0.03, filter=filter,
width=arrow_width,
headlength=headlength, headwidth=headwidth,
headaxislength=headaxislength, cbar_tick_label_size=30, cmap=cmap,
cbar_style="not-clickpoints",
vmin=0, vmax=vmax, plot_cbar=cb)
return fig,ax
pixelsize=1
h=1000
young=1
new_calculation = False
output_folder = "/home/user/Desktop/backup_from_harddrive/data_traction_force_microscopy/gaussfilter_strain_energy"
createFolder(output_folder)
#fx_b, fy_b = np.zeros((200,200)), np.zeros((200,200))
#l1 = np.array([np.arange(35,45),np.arange(35,45)])
#l2 = np.array([np.arange(55,65),np.arange(55,65)])
out_folder2=createFolder(os.path.join(output_folder,"force_plots"))
cont_input = []
cont_output_filtered = []
cont_output_unfiltered = []
rs=list(range(1,12,2))
ar_size=600
mask=np.ones((ar_size,ar_size))
mask = binary_erosion(np.ones((ar_size, ar_size)), iterations=20).astype(bool)
def exp_border_real_data():
out_folder = "/home/user/Desktop/backup_from_harddrive/data_traction_force_microscopy/ev_paper_rd_expansion_fs3"
createFolder(out_folder)
border_ex_test = (list(range(0, 100, 2)))
f_type = "non-circular"
young = 1
h = 100
pixelsize = 1
filter = "gaussian"
# retrieving clickpoints mask and traction forces
folder = "/home/user/Desktop/backup_from_harddrive/data_traction_force_microscopy/WT_vs_KO_images/KOshift/"
db = clickpoints.DataFile(os.path.join(folder, "database.cdb"), "r")
mask = db.getMask(frame=2).data == 3
db.db.close()
u, v = np.load(os.path.join(out_folder, "u.npy")), np.load(
os.path.join(out_folder, "v.npy"))
fx_f, fy_f = traction_wrapper(
u, v, pixelsize, h, young, mask=mask, filter="gaussian",
fs=3) # this filtersize is equal to 3*0.85 ~3.5 µm for real data
mask = interpolation(mask, dims=fx_f.shape, min_cell_size=100)
mask = binary_fill_holes(mask)
np.save(os.path.join(out_folder, "mask.npy"), mask)
stress_tensors, mean_normal_list, mask_exp_list = exp_border(
exp_range=border_ex_test,
fx_f=fx_f,
fy_f=fy_f,
mask=mask,
out_folder=out_folder,
method="binary_dilation")
stress_tensor_b = stress_tensors[0]
max_dict = get_max_values(fx_f=fx_f,
fy_f=fy_f,
stress_tensor_b=stress_tensor_b,
exp_test=len(border_ex_test) > 0,
mean_normal_list=mean_normal_list)
# getting comparison scalar fields
mask_fm = standard_measures(mask=mask,
mean_normal_list=mean_normal_list,
stress_tensor_b=stress_tensor_b)
save_arr = np.array([
np.round(np.array(avg_normal_stress_be), 5),
np.array(border_ex_test)
]).T
np.savetxt(os.path.join(out_folder, "avg_norm_stress.txt"),
save_arr,
fmt="%.5f",
delimiter=",")
mask_exp = binary_dilation(mask, iterations=15)
scalar_comaprisons = full_field_comparision(
) # r gives mostly the spatial distribution
with suppress(KeyError):
del scalar_comaprisons["forces"]
plot_types = ["test for border expansion"]
plot_types.extend(
["forces_forward", "correlation", "test for border expansion"])
# plot_types = [ "forces_backward", "full_stress_tensor_backward"]
general_display(plot_types=plot_types,
mask=mask,
pixelsize=pixelsize,
max_dict=max_dict,
f_type=f_type,
mean_normal_list=mean_normal_list,
mask_exp_list=mask_exp_list,
out_folder=out_folder,
fx_f=fx_f,
fy_f=fy_f,
mask_exp=mask_exp,
scalar_comaprisons=scalar_comaprisons,
border_ex_test=border_ex_test,
plot_gt_exp=False)
plt.close("all")
method="manual") # highest aggreement (not completely sure
stress_tensor_b = setup_stress_field(mask,
distribution="uniform",
sigma_n=1,
sigma_shear=0,
sigma_gf=6)
fx_b, fy_b = traction_from_stress(stress_tensor_b,
pixelsize,
plot=False,
grad_type="diff1")
u_b, v_b = finite_thickness_convolution(
fx_b, fy_b, pixelsize, h, young, sigma=0.5,
kernel_size=None) # somwhat of an approximation
createFolder(out_folder)
np.save(os.path.join(out_folder, "u_b.npy"), u_b)
np.save(os.path.join(out_folder, "v_b.npy"), v_b)
u_b, v_b = np.load(os.path.join(out_folder, "u_b.npy")), np.load(
os.path.join(out_folder, "v_b.npy"))
# compare_scalar_fields(u,u1)
# u2,v2,z1=finite_thickenss_convolution_exact(fx, fy,pixelsize, h, young, sigma=0.5,kernel_size=None) # best solution possible
##forward worklow
# tractions from deformationa
fx_f, fy_f = traction_wrapper(u_b,
v_b,
pixelsize,
h,
young,
mask=mask,
times = np.arange(1, 23)
# keep these values for our nk cells stacks
win_um = 12
fac_overlap = 0.4
signoise_filter = 1.3
# windowsize for stacks
window_size = (int(win_um / du), int(win_um / dv), int(win_um / dw))
overlap = (int(fac_overlap * win_um / du), int(fac_overlap * win_um / dv), int(fac_overlap * win_um / dw))
search_area = (int(win_um / du), int(win_um / dv), int(win_um / dw))
# specify output folder and image stacks within the loop !
# loop through time
times = [2]
out_put = createFolder("out")
for t in tqdm(times):
print(t)
# create output folder
out_folder = r"pos02_ref21/t{}".format(str(t))
# create output folder if it does not exist, print warning otherwise
if not os.path.exists(out_folder):
os.makedirs(out_folder)
"""
load alive stacks
"""
folder = r"/home/user/Desktop/biophysDS/dboehringer/Platte_4/Measurements_NK_TFM/18.05.20-NK-TFM/Sample1_MarkandFind_001/Mark_and_Find_001"
images = glob.glob(
os.path.join(folder, "Mark_and_Find_001_Pos002_S001_t{}_z*_RAW_ch00.tif".format(str(t).zfill(2))))[30:-30]
im_shape = plt.imread(images[0]).shape
