def calibrate_DM(self, rcond=0.1, fname_append=None, force_new=False):
"""Calculate and save the imagae reconstruction matrix for the AO system"""
from os import path
if fname_append is not None:
fname = "rmat_" + str(
self.DM.num_actuators) + "_" + str(rcond).replace(
".", "") + "_" + fname_append
else:
fname = "rmat_" + str(
self.DM.num_actuators) + "_" + str(rcond).replace(".", "")
#first we make a reference image for an unaberrated wavefront passing through the pwfs
wf = hc.Wavefront(self.ap, wavelength=self.reference_wavelength)
wf.total_power = 1
wf_pwfs = self.pwfs.forward(wf)
self.ref_image = self.read_out(wf_pwfs, poisson=False)
if path.exists(fname + ".npy") and not force_new:
print("trying to load reconstruction matrix from " + fname)
rmat = np.load(fname + str(".npy"))
print("loaded cached rmat")
else:
print("computing reconstruction matrix")
#compute the interaction matrix relating incoming abberations to wfs response
probe_disp = 0.01 * self.wavelength
slopes = []
for i in range(self.DM.num_actuators):
printProgressBar(i, self.DM.num_actuators)
slope = 0
for s in (-1, 1):
disps = np.zeros((self.DM.num_actuators, ))
disps[i] = s * probe_disp
self.DM.actuators = disps
wf_dm = self.DM.forward(wf) #pass through DM
wf_dm_pwfs = self.pwfs.forward(wf_dm) #pass through wfs
image = self.read_out(wf_dm_pwfs)
slope += s * (image - self.ref_image) / (2 * probe_disp)
slopes.append(slope)
print("matrix inversion...")
basis = hc.ModeBasis(slopes)
rmat = hc.inverse_tikhonov(basis.transformation_matrix,
rcond=rcond,
svd=None)
np.save(fname, rmat)
self.DM.actuators = np.zeros((self.DM.num_actuators, ))
self.rmat = rmat
return rmat
def run_closed_loop(self,
leakage,
gain,
fileout,
run_for=10,
freq=1000,
save_every=100,
wl=None):
"""like the original function but use's Mike's phase screen code"""
#reset DM
self.DM.actuators[:] = 0.
t_arr = np.linspace(0, run_for, int(run_for * freq) + 1)
wf_pupil, wf_pupil_hires, wf_focal = self.wf_pupil, self.wf_pupil_hires, self.wf_focal
perfect_u = get_u(wf_focal)
print("perfect psf of current optical system: ")
plt.imshow(np.abs(perfect_u))
plt.show()
num_saves = int(len(t_arr) / save_every)
DMshapes = np.empty((num_saves, len(self.DM.actuators)))
avg = np.zeros_like(perfect_u, dtype=np.float)
psf_arr = np.zeros((num_saves, perfect_u.shape[0], perfect_u.shape[1]),
dtype=np.complex128)
times = []
norm = np.sqrt(np.sum(perfect_u * np.conj(perfect_u)))
print("simulating AO system...")
j = 0
for i in range(len(t_arr)):
self.get_screen()
self.update_DM(wf_pupil, leakage, gain)
full_prop = (i != 0 and i % save_every == 0)
if full_prop:
# do a full optical propagation
_wf = self.propagate(wf_pupil_hires)
u = get_u(_wf, norm)
avg += np.real(u * np.conj(u))
psf_arr[j] = u
DMshapes[j] = self.DM.actuators
times.append(t_arr[i])
j += 1
printProgressBar(j, num_saves)
avg /= j
avg = np.sqrt(avg)
s = get_strehl(avg, perfect_u / norm)
with h5py.File(fileout + ".hdf5", "w") as f:
f.create_dataset("DMs", data=DMshapes)
f.create_dataset("psfs", data=psf_arr)
f.create_dataset("ts", data=times)
self.save_args_to_file(f)
return u, avg, s
def main(config):
rm_mkdir(config.train_path)
rm_mkdir(config.train_GT_path)
rm_mkdir(config.valid_path)
rm_mkdir(config.valid_GT_path)
rm_mkdir(config.test_path)
rm_mkdir(config.test_GT_path)
filenames = os.listdir(config.origin_data_path)
data_list = []
GT_list = []
for filename in filenames:
ext = os.path.splitext(filename)[-1]
if ext == '.jpg':
filename = filename.split('_')[-1][:-len('.jpg')]
data_list.append('ISIC_' + filename + '.jpg')
GT_list.append('ISIC_' + filename + '_segmentation.png')
num_total = len(data_list)
num_train = int(
(config.train_ratio /
(config.train_ratio + config.valid_ratio + config.test_ratio)) *
num_total)
num_valid = int(
(config.valid_ratio /
(config.train_ratio + config.valid_ratio + config.test_ratio)) *
num_total)
num_test = num_total - num_train - num_valid
print('\nNum of train set : ', num_train)
print('\nNum of valid set : ', num_valid)
print('\nNum of test set : ', num_test)
Arange = list(range(num_total))
random.shuffle(Arange)
for i in range(num_train):
idx = Arange.pop()
src = os.path.join(config.origin_data_path, data_list[idx])
dst = os.path.join(config.train_path, data_list[idx])
copyfile(src, dst)
src = os.path.join(config.origin_GT_path, GT_list[idx])
dst = os.path.join(config.train_GT_path, GT_list[idx])
copyfile(src, dst)
printProgressBar(i + 1,
num_train,
prefix='Producing train set:',
suffix='Complete',
length=50)
for i in range(num_valid):
idx = Arange.pop()
src = os.path.join(config.origin_data_path, data_list[idx])
dst = os.path.join(config.valid_path, data_list[idx])
copyfile(src, dst)
src = os.path.join(config.origin_GT_path, GT_list[idx])
dst = os.path.join(config.valid_GT_path, GT_list[idx])
copyfile(src, dst)
printProgressBar(i + 1,
num_valid,
prefix='Producing valid set:',
suffix='Complete',
length=50)
for i in range(num_test):
idx = Arange.pop()
src = os.path.join(config.origin_data_path, data_list[idx])
dst = os.path.join(config.test_path, data_list[idx])
copyfile(src, dst)
src = os.path.join(config.origin_GT_path, GT_list[idx])
dst = os.path.join(config.test_GT_path, GT_list[idx])
copyfile(src, dst)
printProgressBar(i + 1,
num_test,
prefix='Producing test set:',
suffix='Complete',
length=50)
def main(config):
# import pdb; pdb.set_trace()
rm_mkdir(config.train_path)
rm_mkdir(config.train_GT_path)
rm_mkdir(config.valid_path)
rm_mkdir(config.valid_GT_path)
rm_mkdir(config.test_path)
rm_mkdir(config.test_GT_path)
# Get list of all masks
filenames = os.listdir(config.origin_GT_path)
data_list = filenames
GT_list = filenames
num_total = len(data_list)
num_train = int(
(config.train_ratio /
(config.train_ratio + config.valid_ratio + config.test_ratio)) *
num_total)
num_valid = int(
(config.valid_ratio /
(config.train_ratio + config.valid_ratio + config.test_ratio)) *
num_total)
num_test = num_total - num_train - num_valid
print('\nNum of train set : ', num_train)
print('\nNum of valid set : ', num_valid)
print('\nNum of test set : ', num_test)
Arange = list(range(num_total))
random.shuffle(Arange)
for i in range(num_train):
idx = Arange.pop()
src = os.path.join(config.origin_data_path, data_list[idx])
dst = os.path.join(config.train_path, data_list[idx])
copyfile(src, dst)
src = os.path.join(config.origin_GT_path, GT_list[idx])
dst = os.path.join(config.train_GT_path, GT_list[idx])
copyfile(src, dst)
printProgressBar(i + 1,
num_train,
prefix='Producing train set:',
suffix='Complete',
length=50)
for i in range(num_valid):
idx = Arange.pop()
src = os.path.join(config.origin_data_path, data_list[idx])
dst = os.path.join(config.valid_path, data_list[idx])
copyfile(src, dst)
src = os.path.join(config.origin_GT_path, GT_list[idx])
dst = os.path.join(config.valid_GT_path, GT_list[idx])
copyfile(src, dst)
printProgressBar(i + 1,
num_valid,
prefix='Producing valid set:',
suffix='Complete',
length=50)
for i in range(num_test):
idx = Arange.pop()
src = os.path.join(config.origin_data_path, data_list[idx])
dst = os.path.join(config.test_path, data_list[idx])
copyfile(src, dst)
src = os.path.join(config.origin_GT_path, GT_list[idx])
dst = os.path.join(config.test_GT_path, GT_list[idx])
copyfile(src, dst)
printProgressBar(i + 1,
num_test,
prefix='Producing test set:',
suffix='Complete',
length=50)
def main(config):
rm_mkdir(config.train_path)
rm_mkdir(config.train_GT_path)
rm_mkdir(config.valid_path)
rm_mkdir(config.valid_GT_path)
origin_GT_file = csv.DictReader(open(config.origin_GT_path+config.origin_GT_file, encoding='UTF-8-sig'))
origin_data_list = [i for i in origin_GT_file]
data_list = []
for index in range(len(origin_data_list)):
filename = origin_data_list[index]['FileName']
multi_GT = origin_data_list[index]['Code'].split(';')
for j in multi_GT:
data = {}
data['FileName'] = filename
data['Code'] = j
data_list.append(data)
train_list = []
valid_list = []
test_file = csv.DictReader(open(config.test_GT_path+'test_label.csv', encoding='UTF-8-sig'))
test_list = [i for i in test_file]
num_total = len(data_list)
num_train = int((config.train_ratio/(config.train_ratio+config.valid_ratio+config.test_ratio))*num_total)
num_valid = int((config.valid_ratio/(config.train_ratio+config.valid_ratio+config.test_ratio))*num_total)
num_test = len(test_list)
print('\nNum of train set : ', num_train)
print('\nNum of valid set : ', num_valid)
print('\nNum of test set : ', num_test)
Arange = list(range(num_total))
random.shuffle(Arange)
for i in range(num_train):
idx = Arange.pop()
filename = data_list[idx]['FileName']
src = os.path.join(config.origin_data_path, filename)
dst = os.path.join(config.train_path, filename)
copyfile(src, dst)
train_list.append(data_list[idx])
printProgressBar(i + 1, num_train, prefix = 'Producing train set:', suffix = 'Complete', length = 50)
train_data_writer = csv.DictWriter(open(config.train_GT_path+'train_label.csv','w'), origin_GT_file.fieldnames)
train_data_writer.writeheader()
train_data_writer.writerows(train_list)
for i in range(num_valid):
idx = Arange.pop()
filename = data_list[idx]['FileName']
src = os.path.join(config.origin_data_path, filename)
dst = os.path.join(config.valid_path, filename)
copyfile(src, dst)
valid_list.append(data_list[idx])
printProgressBar(i + 1, num_valid, prefix = 'Producing valid set:', suffix = 'Complete', length = 50)
valid_data_writer = csv.DictWriter(open(config.valid_GT_path+'valid_label.csv','w'), origin_GT_file.fieldnames)
valid_data_writer.writeheader()
valid_data_writer.writerows(valid_list)
def prop2end(self,
u,
xyslice,
zslice,
u1_func=None,
writeto=None,
ucrit=5.e-3,
remesh_every=20,
dynamic_n0=True):
mesh = self.mesh
PML = mesh.PML
za_keep = mesh.za[zslice]
if type(za_keep) == np.ndarray:
minz, maxz = za_keep[0], za_keep[-1]
shape = (len(za_keep), *mesh.xg[xyslice].shape)
else:
raise Exception('uhh not implemented')
self.field = np.zeros(shape, dtype=c128)
xa_in = np.linspace(-mesh.xw / 2, mesh.xw / 2, u.shape[0])
ya_in = np.linspace(-mesh.yw / 2, mesh.yw / 2, u.shape[1])
dx0 = xa_in[1] - xa_in[0]
dy0 = ya_in[1] - ya_in[0]
print("normalizing input file")
normalize(u, weight=dx0 * dy0)
__z = 0
#pull xy mesh
xy = mesh.xy
dx, dy = xy.dx0, xy.dy0
#resample the field onto the smaller xy mesh (in the smaller mesh's computation zone!)
u0 = xy.resample_complex(u, xa_in, ya_in, xy.xa[PML:-PML],
xy.ya[PML:-PML])
#now we pad w/ zeros to extend it into the PML zone
u0 = np.pad(u0, ((PML, PML), (PML, PML)))
#initial mesh refinement
print("initial remesh")
xy.refine_base(u0, ucrit)
#xy.plot_mesh(4)
weights = xy.get_weights()
#now resample the field onto the smaller *non-uniform* xy mesh
u = xy.resample_complex(u, xa_in, ya_in, xy.xa[PML:-PML],
xy.ya[PML:-PML])
u = np.pad(u, ((PML, PML), (PML, PML)))
#do another norm to correct for the slight power change you get when resampling. I measure 0.1% change for psflo. should check again
norm_nonu(u, weights)
counter = 0
total_iters = self.mesh.zres
print("propagating field...")
z__ = 0
#step 0 setup
self.update_grid_cor_facs('x')
self.update_grid_cor_facs('y')
# initial array allocation
_trimatsx, rmatx, gx, _trimatsy, rmaty, gy, IORsq__, _IORsq_, __IORsq = self.allocate_mats(
)
self.precomp_trimats('x')
self.precomp_trimats('y')
self.rmat_precomp('x')
self.rmat_precomp('y')
self._pmlcorrect(_trimatsx, 'x')
self._pmlcorrect(_trimatsy, 'y')
#get the current IOR dist
self.set_IORsq(IORsq__, z__)
print("initial shape: ", xy.shape)
for i in range(total_iters):
printProgressBar(i, total_iters - 1)
u0 = xy.get_base_field(u)
u0c = np.conj(u0)
weights = xy.get_weights()
## Total power monitor ##
self.totalpower[i] = overlap_nonu(u, u, weights)
print(self.totalpower[i])
## Other monitors ##
if u1_func is not None:
lp = norm_nonu(u1_func(xy.xg, xy.yg), weights)
self.power[i] = power(overlap_nonu(u, lp, weights), 2)
_z_ = z__ + mesh.half_dz
__z = z__ + mesh.dz
if minz <= __z <= maxz:
ix0, ix1, ix2, ix3 = mesh.get_loc()
mid = int(u0.shape[1] / 2)
self.field[counter][ix0:ix1 + 1] = u0[:, mid] ## FIX ##
counter += 1
#avoid remeshing on step 0
if (i + 1) % remesh_every == 0:
#xy.plot_mesh(4)
## update the effective index
if dynamic_n0:
#update the effective index
base = xy.get_base_field(IORsq__)
self.n02 = xy.dx0 * xy.dy0 * np.real(
np.sum(u0c * u0 * base)) / self.k02
oldxm, oldxM = xy.xm, xy.xM
oldym, oldyM = xy.ym, xy.yM
oldxw, oldyw = xy.xw, xy.yw
#expand the grid if necessary
new_xw = mesh.xwfunc(__z)
new_yw = mesh.ywfunc(__z)
new_xw, new_yw = xy.snapto(new_xw, new_yw)
xy.reinit(new_xw,
new_yw) #set grid back to base res with new dims
if (xy.xw > oldxw or xy.yw > oldyw):
#now we need to pad u,u0 with zeros to make sure it matches the new space
xpad = int((xy.shape0[0] - u0.shape[0]) / 2)
ypad = int((xy.shape0[1] - u0.shape[1]) / 2)
u = np.pad(u, ((xpad, xpad), (ypad, ypad)))
u0 = np.pad(u0, ((xpad, xpad), (ypad, ypad)))
#pad coord arrays to do interpolation
xy.xa_last = np.hstack(
(np.linspace(xy.xm, oldxm - dx, xpad), xy.xa_last,
np.linspace(oldxM + dx, xy.xM, xpad)))
xy.ya_last = np.hstack(
(np.linspace(xy.ym, oldym - dy, ypad), xy.ya_last,
np.linspace(oldyM + dy, xy.yM, ypad)))
#subdivide into nonuniform grid
xy.refine_base(u0, ucrit)
#interp the field to the new grid
u = xy.resample_complex(u)
#give the grid to the optical sys obj so it can compute IORs
self.optical_system.set_sampling(xy)
#compute nonuniform grid correction factors R_i
self.update_grid_cor_facs('x')
self.update_grid_cor_facs('y')
# grid size has changed, so now we need to reallocate arrays for at least the next remesh_period iters
_trimatsx, rmatx, gx, _trimatsy, rmaty, gy, IORsq__, _IORsq_, __IORsq = self.allocate_mats(
)
#get the current IOR dist
self.set_IORsq(IORsq__, z__)
#precompute things that will be reused
self.precomp_trimats('x')
self.precomp_trimats('y')
self.rmat_precomp('x')
self.rmat_precomp('y')
self._pmlcorrect(_trimatsx, 'x')
self._pmlcorrect(_trimatsy, 'y')
self.set_IORsq(
_IORsq_,
_z_,
)
self.set_IORsq(__IORsq, __z)
self.rmat(rmatx, u, IORsq__, 'x')
self.rmat_pmlcorrect(rmatx, u, 'x')
self._trimats(_trimatsx, _IORsq_, 'x')
self._trimats(_trimatsy, __IORsq.T, 'y')
tri_solve_vec(_trimatsx[0], _trimatsx[1], _trimatsx[2], rmatx, gx,
u)
self.rmat(rmaty, u.T, _IORsq_.T, 'y')
self.rmat_pmlcorrect(rmaty, u.T, 'y')
tri_solve_vec(_trimatsy[0], _trimatsy[1], _trimatsy[2], rmaty, gy,
u.T)
z__ = __z
if (i + 2) % remesh_every != 0:
IORsq__[:, :] = __IORsq
print("final total power", self.totalpower[-1])
if writeto:
np.save(writeto, self.field)
return u
cell_label_map[cell_label_map == region.label] = 0
cell_mask = cell_label_map > 0
postprocessed_path = config.result_path + 'postprocessed_png/'
if not os.path.exists(postprocessed_path):
os.mkdir(postprocessed_path)
save_folder = postprocessed_path + '%s/' % well
if not os.path.exists(save_folder):
os.mkdir(save_folder)
plt.imsave(save_folder + whole_img_predic_list[slice_index].split('/')[-1].replace('.npy', '_postprocessed.png'), cell_mask)
try:
cell_mask_3D[:, :, slice_index - 30] = cell_mask
nuclei_mask_3D[:, :, slice_index - 30] = nuclei_mask
nuclei_segmentation_3D[:, :, slice_index - 30] = nucleus_image * nuclei_mask
nuclei_channel_cell_segmentation_3D[:, :, slice_index - 30] = nucleus_image * cell_mask
printProgressBar(slice_index, 30)
except:
printProgressBar(slice_index, len(sub_prediction_list))
# Nifti shell is a original nifti scan that we used to keep all the files with the same affine and header
# You may need to change your nifti shell here
try:
NIFTI_shell_file = './Step02_channel_combined_input/demo/1600*1600_nifti_shell.nii.gz'
# change the result path to where you want to save this file
result_path = config.result_path + 'nifti_30frames/'
if not os.path.exists(result_path):
os.mkdir(result_path)
NIFTI_shell = nib.load(NIFTI_shell_file)
cell_mask_3D_patch_nii = nib.Nifti1Image(cell_mask_3D, NIFTI_shell.affine)
nuclei_mask_3D_patch_nii = nib.Nifti1Image(nuclei_mask_3D, NIFTI_shell.affine)
nuclei_segmentation_3D_patch_nii = nib.Nifti1Image(nuclei_segmentation_3D, NIFTI_shell.affine)
keep_region = False
for pixel in region.coords:
if seed[pixel[0], pixel[1]] == 1:
keep_region = True
if keep_region == False:
cell_label_map[cell_label_map == region.label] = 0
cell_mask = cell_label_map > 0
cell_mask_3D[:, :, slice_index - 30] = cell_mask
nuclei_mask_3D[:, :, slice_index - 30] = nuclei_mask
nuclei_segmentation_3D[:, :,
slice_index - 30] = nucleus_image * nuclei_mask
nuclei_channel_cell_segmentation_3D[:, :, slice_index -
30] = nucleus_image * cell_mask
printProgressBar(slice_index, 30)
# Nifti shell is a original nifti scan that we used to keep all the files with the same affine and header
# You need to change your nifti shell here
NIFTI_shell_file = '/media/sail/SSD1T/Tal_cell_tracking/Nifti/20190621_111240_generate_nifti_1_1/strct/1600*1600.nii.gz'
# change the result path to where you want to save this file
result_path = '/media/sail/SSD1T/Tal_cell_tracking/Nifti/%s_Prediction_comparison/' % well
if not os.path.exists(result_path):
os.mkdir(result_path)
NIFTI_shell = nib.load(NIFTI_shell_file)
cell_mask_3D_patch_nii = nib.Nifti1Image(cell_mask_3D, NIFTI_shell.affine)
nuclei_mask_3D_patch_nii = nib.Nifti1Image(nuclei_mask_3D,
NIFTI_shell.affine)
nuclei_segmentation_3D_patch_nii = nib.Nifti1Image(nuclei_segmentation_3D,
NIFTI_shell.affine)
nuclei_channel_cell_segmentation_3D_patch_nii = nib.Nifti1Image(
