def hdf5_cast(fname, display_min=None, display_max=None, dtype='uint16'):
f = h5py.File(fname)
dset = f['exchange/data']
n_slices = dset.shape[0]
if display_min is None:
if rank == 0:
display_min = dset.min()
for i in range(1, size):
comm.send(display_min, dest=i)
else:
display_min = comm.recv(source=0)
comm.Barrier()
if display_max is None:
if rank == 0:
display_max = dset.max()
for i in range(1, size):
comm.send(display_max, dest=i)
else:
display_max = comm.recv(source=0)
comm.Barrier()
alloc_set = allocate_mpi_subsets(n_slices, size)
for i in alloc_set[rank]:
temp = dset[i, :, :]
temp = img_cast(temp, display_min, display_max, dtype=dtype)
dset[i, :, :] = temp
print(' Rank: {:d}, slice: {:d}'.format(rank, i))
dset = dset.astype(dtype)
try:
dset = f['exchange/data_white']
alloc_set = allocate_mpi_subsets(dset.shape[0], size)
for i in alloc_set[rank]:
temp = dset[i, :, :]
temp = img_cast(temp, display_min, display_max, dtype=dtype)
dset[i, :, :] = temp
dset = dset.astype(dtype)
except:
pass
try:
dset = f['exchange/data_dark']
alloc_set = allocate_mpi_subsets(dset.shape[0], size)
for i in alloc_set[rank]:
temp = dset[i, :, :]
temp = img_cast(temp, display_min, display_max, dtype=dtype)
dset[i, :, :] = temp
dset = dset.astype(dtype)
except:
pass
return
def hdf5_cast(fname, display_min=None, display_max=None, dtype='uint16'):
f = h5py.File(fname)
dset = f['exchange/data']
n_slices = dset.shape[0]
if display_min is None:
if rank == 0:
display_min = dset.min()
for i in range(1, size):
comm.send(display_min, dest=i)
else:
display_min = comm.recv(source=0)
comm.Barrier()
if display_max is None:
if rank == 0:
display_max = dset.max()
for i in range(1, size):
comm.send(display_max, dest=i)
else:
display_max = comm.recv(source=0)
comm.Barrier()
alloc_set = allocate_mpi_subsets(n_slices, size)
for i in alloc_set[rank]:
temp = dset[i, :, :]
temp = img_cast(temp, display_min, display_max, dtype=dtype)
dset[i, :, :] = temp
print(' Rank: {:d}, slice: {:d}'.format(rank, i))
dset = dset.astype(dtype)
try:
dset = f['exchange/data_white']
alloc_set = allocate_mpi_subsets(dset.shape[0], size)
for i in alloc_set[rank]:
temp = dset[i, :, :]
temp = img_cast(temp, display_min, display_max, dtype=dtype)
dset[i, :, :] = temp
dset = dset.astype(dtype)
except:
pass
try:
dset = f['exchange/data_dark']
alloc_set = allocate_mpi_subsets(dset.shape[0], size)
for i in alloc_set[rank]:
temp = dset[i, :, :]
temp = img_cast(temp, display_min, display_max, dtype=dtype)
dset[i, :, :] = temp
dset = dset.astype(dtype)
except:
pass
return
def tiff2hdf5(src_folder,
dest_folder,
dest_fname,
pattern='recon_*.tiff',
display_min=None,
display_max=None,
dtype='int8'):
dest_fname = check_fname_ext(dest_fname, 'h5')
filelist = glob.glob(os.path.join(src_folder, pattern))
filelist = sorted(filelist)
n_files = len(filelist)
temp = dxchange.read_tiff(filelist[0])
full_shape = np.array([n_files, temp.shape[0], temp.shape[1]])
if rank == 0:
if not os.path.exists(dest_folder):
os.mkdir(dest_folder)
f = h5py.File(os.path.join(dest_folder, dest_fname))
comm.Barrier()
if rank != 0:
f = h5py.File(os.path.join(dest_folder, dest_fname))
grp = f.create_group('exchange')
grp.create_dataset('data', full_shape, dtype='float32')
alloc_set = allocate_mpi_subsets(n_files, size)
dset = f['exchange/data']
for i in alloc_set[rank]:
img = dxchange.read_tiff(filelist[i])
dset[i, :, :] = img
print(' Rank: {:d}, file: {:d}'.format(rank, i))
comm.Barrier()
hdf5_cast(os.path.join(dest_folder, dest_fname),
display_min=display_min,
display_max=display_max,
dtype=dtype)
return
def tiff2hdf5(src_folder, dest_folder, dest_fname, pattern='recon_*.tiff', display_min=None, display_max=None,
dtype='int8'):
dest_fname = check_fname_ext(dest_fname, 'h5')
filelist = glob.glob(os.path.join(src_folder, pattern))
filelist = sorted(filelist)
n_files = len(filelist)
temp = imread(filelist[0])
full_shape = np.array([n_files, temp.shape[0], temp.shape[1]])
if rank == 0:
if not os.path.exists(dest_folder):
os.mkdir(dest_folder)
f = h5py.File(os.path.join(dest_folder, dest_fname))
comm.Barrier()
if rank != 0:
f = h5py.File(os.path.join(dest_folder, dest_fname))
grp = f.create_group('exchange')
grp.create_dataset('data', full_shape, dtype='float32')
alloc_set = allocate_mpi_subsets(n_files, size)
dset = f['exchange/data']
for i in alloc_set[rank]:
img = imread(filelist[i])
dset[i, :, :] = img
print(' Rank: {:d}, file: {:d}'.format(rank, i))
comm.Barrier()
hdf5_cast(os.path.join(dest_folder, dest_fname), display_min=display_min, display_max=display_max, dtype=dtype)
return
def blur_hdf5(fname, sigma):
"""
Apply Gaussian filter to each projection of a HDF5 for noise reduction.
"""
f = h5py.File(fname)
dset = f['exchange/data']
nframes = dset.shape[0]
alloc_sets = allocate_mpi_subsets(nframes, size)
for frame in alloc_sets[rank]:
print('Rank: {:d}; Frame: {:d}.'.format(rank, frame))
dset[frame, :, :] = gaussian_filter(dset[frame, :, :], sigma)
f.close()
gc.collect()
def blur_hdf5(fname, sigma):
"""
Apply Gaussian filter to each projection of a HDF5 for noise reduction.
"""
f = h5py.File(fname)
dset = f['exchange/data']
nframes = dset.shape[0]
alloc_sets = allocate_mpi_subsets(nframes, size)
for frame in alloc_sets[rank]:
print('Rank: {:d}; Frame: {:d}.'.format(rank, frame))
dset[frame, :, :] = gaussian_filter(dset[frame, :, :], sigma)
f.close()
gc.collect()
def recon_hdf5_mpi(src_fanme, dest_folder, sino_range, sino_step, center_vec, shift_grid, dtype='float32',
algorithm='gridrec', tolerance=1, save_sino=False, sino_blur=None, **kwargs):
"""
Reconstruct a single tile, or fused HDF5 created using util/total_fusion. MPI supported.
"""
raise DeprecationWarning
if rank == 0:
if not os.path.exists(dest_folder):
os.mkdir(dest_folder)
sino_ini = int(sino_range[0])
sino_end = int(sino_range[1])
f = h5py.File(src_fanme)
dset = f['exchange/data']
full_shape = dset.shape
theta = tomopy.angles(full_shape[0])
center_vec = np.asarray(center_vec)
sino_ls = np.arange(sino_ini, sino_end, sino_step, dtype='int')
grid_bins = np.ceil(shift_grid[:, 0, 0])
t0 = time.time()
alloc_set = allocate_mpi_subsets(sino_ls.size, size, task_list=sino_ls)
for slice in alloc_set[rank]:
print(' Rank {:d}: reconstructing {:d}'.format(rank, slice))
grid_line = np.digitize(slice, grid_bins)
grid_line = grid_line - 1
center = center_vec[grid_line]
data = dset[:, slice, :]
if sino_blur is not None:
data = gaussian_filter(data, sino_blur)
data = data.reshape([full_shape[0], 1, full_shape[2]])
data[np.isnan(data)] = 0
data = data.astype('float32')
if save_sino:
dxchange.write_tiff(data[:, slice, :], fname=os.path.join(dest_folder, 'sino/recon_{:05d}_{:d}.tiff').format(slice, center))
# data = tomopy.remove_stripe_ti(data)
rec = tomopy.recon(data, theta, center=center, algorithm=algorithm, **kwargs)
# rec = tomopy.remove_ring(rec)
rec = tomopy.remove_outlier(rec, tolerance)
rec = tomopy.circ_mask(rec, axis=0, ratio=0.95)
dxchange.write_tiff(rec, fname='{:s}/recon/recon_{:05d}_{:d}'.format(dest_folder, slice, center), dtype=dtype)
print('Rank {:d} finished in {:.2f} s.'.format(rank, time.time()-t0))
return
def recon_block(grid, shift_grid, src_folder, dest_folder, slice_range, sino_step, center_vec, ds_level=0, blend_method='max',
blend_options=None, tolerance=1, sinogram_order=False, algorithm='gridrec', init_recon=None, ncore=None, nchunk=None, dtype='float32',
crop=None, save_sino=False, assert_width=None, sino_blur=None, color_correction=False, flattened_radius=120, normalize=True,
test_mode=False, mode='180', phase_retrieval=None, **kwargs):
"""
Reconstruct dsicrete HDF5 tiles, blending sinograms only.
"""
raw_folder = os.getcwd()
os.chdir(src_folder)
sino_ini = int(slice_range[0])
sino_end = int(slice_range[1])
mod_start_slice = 0
center_vec = np.asarray(center_vec)
center_pos_cache = 0
sino_ls = np.arange(sino_ini, sino_end, sino_step, dtype='int')
pix_shift_grid = np.ceil(shift_grid)
pix_shift_grid[pix_shift_grid < 0] = 0
alloc_set = allocate_mpi_subsets(sino_ls.size, size, task_list=sino_ls)
for i_slice in alloc_set[rank]:
print('############################################')
print('Reconstructing ' + str(i_slice))
# judge from which tile to retrieve sinos
grid_lines = np.zeros(grid.shape[1], dtype=np.int)
slice_in_tile = np.zeros(grid.shape[1], dtype=np.int)
for col in range(grid.shape[1]):
bins = pix_shift_grid[:, col, 0]
grid_lines[col] = int(np.squeeze(np.digitize(i_slice, bins)) - 1)
if grid_lines[col] == -1:
print("WARNING: The specified starting slice number does not allow for full sinogram construction. Trying next slice...")
mod_start_slice = 1
break
else:
mod_start_slice = 0
slice_in_tile[col] = i_slice - bins[grid_lines[col]]
if mod_start_slice == 1:
continue
center_pos = int(np.round(center_vec[grid_lines].mean()))
if center_pos_cache == 0:
center_pos_cache = center_pos
center_diff = center_pos - center_pos_cache
center_pos_0 = center_pos
row_sino, center_pos = prepare_slice(grid, shift_grid, grid_lines, slice_in_tile, ds_level=ds_level,
method=blend_method, blend_options=blend_options, rot_center=center_pos,
assert_width=assert_width, sino_blur=sino_blur, color_correction=color_correction,
normalize=normalize, mode=mode, phase_retrieval=phase_retrieval)
rec0 = recon_slice(row_sino, center_pos, sinogram_order=sinogram_order, algorithm=algorithm,
init_recon=init_recon, ncore=ncore, nchunk=nchunk, **kwargs)
rec = tomopy.remove_ring(np.copy(rec0))
cent = int((rec.shape[1] - 1) / 2)
xx, yy = np.meshgrid(np.arange(rec.shape[2]), np.arange(rec.shape[1]))
mask0 = ((xx - cent) ** 2 + (yy - cent) ** 2 <= flattened_radius ** 2)
mask = np.zeros(rec.shape, dtype='bool')
for i in range(mask.shape[0]):
mask[i, :, :] = mask0
rec[mask] = (rec[mask] + rec0[mask]) / 2
rec = tomopy.remove_outlier(rec, tolerance)
rec = tomopy.circ_mask(rec, axis=0, ratio=0.95)
print('Center: {:d}'.format(center_pos))
rec = np.squeeze(rec)
if center_diff != 0:
rec = np.roll(rec, -center_diff, axis=0)
if not crop is None:
crop = np.asarray(crop)
rec = rec[crop[0, 0]:crop[1, 0], crop[0, 1]:crop[1, 1]]
os.chdir(raw_folder)
if test_mode:
dxchange.write_tiff(rec, fname=os.path.join(dest_folder, 'recon/recon_{:05d}_{:04d}.tiff'.format(i_slice, center_pos)), dtype=dtype)
else:
dxchange.write_tiff(rec, fname=os.path.join(dest_folder, 'recon/recon_{:05d}.tiff'.format(i_slice)), dtype=dtype)
if save_sino:
dxchange.write_tiff(np.squeeze(row_sino), fname=os.path.join(dest_folder, 'sino/sino_{:05d}.tiff'.format(i_slice)), overwrite=True)
os.chdir(src_folder)
os.chdir(raw_folder)
return
def recon_hdf5(src_fanme, dest_folder, sino_range, sino_step, shift_grid, center_vec=None, center_eq=None, dtype='float32',
algorithm='gridrec', tolerance=1, chunk_size=20, save_sino=False, sino_blur=None, flattened_radius=120,
mode='180', test_mode=False, phase_retrieval=None, ring_removal=True, **kwargs):
"""
center_eq: a and b parameters in fitted center position equation center = a*slice + b.
"""
if not os.path.exists(dest_folder):
try:
os.mkdir(dest_folder)
except:
pass
sino_ini = int(sino_range[0])
sino_end = int(sino_range[1])
sino_ls_all = np.arange(sino_ini, sino_end, sino_step, dtype='int')
alloc_set = allocate_mpi_subsets(sino_ls_all.size, size, task_list=sino_ls_all)
sino_ls = alloc_set[rank]
# prepare metadata
f = h5py.File(src_fanme)
dset = f['exchange/data']
full_shape = dset.shape
theta = tomopy.angles(full_shape[0])
if center_eq is not None:
a, b = center_eq
center_ls = sino_ls * a + b
center_ls = np.round(center_ls)
for iblock in range(int(sino_ls.size/chunk_size)+1):
print('Beginning block {:d}.'.format(iblock))
t0 = time.time()
istart = iblock*chunk_size
iend = np.min([(iblock+1)*chunk_size, sino_ls.size])
fstart = sino_ls[istart]
fend = sino_ls[iend]
center = center_ls[istart:iend]
data = dset[:, fstart:fend:sino_step, :]
data[np.isnan(data)] = 0
data = data.astype('float32')
data = tomopy.remove_stripe_ti(data, alpha=4)
if sino_blur is not None:
for i in range(data.shape[1]):
data[:, i, :] = gaussian_filter(data[:, i, :], sino_blur)
rec = tomopy.recon(data, theta, center=center, algorithm=algorithm, **kwargs)
rec = tomopy.remove_ring(rec)
rec = tomopy.remove_outlier(rec, tolerance)
rec = tomopy.circ_mask(rec, axis=0, ratio=0.95)
for i in range(rec.shape[0]):
slice = fstart + i*sino_step
dxchange.write_tiff(rec[i, :, :], fname=os.path.join(dest_folder, 'recon/recon_{:05d}_{:05d}.tiff').format(slice, sino_ini))
if save_sino:
dxchange.write_tiff(data[:, i, :], fname=os.path.join(dest_folder, 'sino/recon_{:05d}_{:d}.tiff').format(slice, int(center[i])))
iblock += 1
print('Block {:d} finished in {:.2f} s.'.format(iblock, time.time()-t0))
else:
# divide chunks
grid_bins = np.append(np.ceil(shift_grid[:, 0, 0]), full_shape[1])
chunks = []
center_ls = []
istart = 0
counter = 0
# irow should be 0 for slice 0
irow = np.searchsorted(grid_bins, sino_ls[0], side='right')-1
for i in range(sino_ls.size):
counter += 1
sino_next = i+1 if i != sino_ls.size-1 else i
if counter >= chunk_size or sino_ls[sino_next] >= grid_bins[irow+1] or sino_next == i:
iend = i+1
chunks.append((istart, iend))
istart = iend
center_ls.append(center_vec[irow])
if sino_ls[sino_next] >= grid_bins[irow+1]:
irow += 1
counter = 0
# reconstruct chunks
iblock = 1
for (istart, iend), center in izip(chunks, center_ls):
print('Beginning block {:d}.'.format(iblock))
t0 = time.time()
fstart = sino_ls[istart]
fend = sino_ls[iend-1]
print('Reading data...')
data = dset[:, fstart:fend+1:sino_step, :]
if mode == '360':
overlap = 2 * (dset.shape[2] - center)
data = tomosaic.morph.sino_360_to_180(data, overlap=overlap, rotation='right')
theta = tomopy.angles(data.shape[0])
data[np.isnan(data)] = 0
data = data.astype('float32')
if sino_blur is not None:
for i in range(data.shape[1]):
data[:, i, :] = gaussian_filter(data[:, i, :], sino_blur)
if ring_removal:
data = tomopy.remove_stripe_ti(data, alpha=4)
if phase_retrieval:
data = tomopy.retrieve_phase(data, kwargs['pixel_size'], kwargs['dist'], kwargs['energy'],
kwargs['alpha'])
rec0 = tomopy.recon(data, theta, center=center, algorithm=algorithm, **kwargs)
rec = tomopy.remove_ring(np.copy(rec0))
cent = int((rec.shape[1]-1) / 2)
xx, yy = np.meshgrid(np.arange(rec.shape[2]), np.arange(rec.shape[1]))
mask0 = ((xx-cent)**2+(yy-cent)**2 <= flattened_radius**2)
mask = np.zeros(rec.shape, dtype='bool')
for i in range(mask.shape[0]):
mask[i, :, :] = mask0
rec[mask] = (rec[mask] + rec0[mask])/2
else:
rec = tomopy.recon(data, theta, center=center, algorithm=algorithm, **kwargs)
rec = tomopy.remove_outlier(rec, tolerance)
rec = tomopy.circ_mask(rec, axis=0, ratio=0.95)
for i in range(rec.shape[0]):
slice = fstart + i*sino_step
if test_mode:
dxchange.write_tiff(rec[i, :, :], fname=os.path.join(dest_folder, 'recon/recon_{:05d}_{:d}.tiff').format(slice, center), dtype=dtype)
else:
dxchange.write_tiff(rec[i, :, :], fname=os.path.join(dest_folder, 'recon/recon_{:05d}.tiff').format(slice), dtype=dtype)
if save_sino:
dxchange.write_tiff(data[:, i, :], fname=os.path.join(dest_folder, 'sino/recon_{:05d}_{:d}.tiff').format(slice, center), dtype=dtype)
print('Block {:d} finished in {:.2f} s.'.format(iblock, time.time()-t0))
iblock += 1
return
def recon_hdf5(src_fanme,
dest_folder,
sino_range,
sino_step,
shift_grid,
center_vec=None,
center_eq=None,
dtype='float32',
algorithm='gridrec',
tolerance=1,
chunk_size=20,
save_sino=False,
sino_blur=None,
flattened_radius=120,
mode='180',
test_mode=False,
phase_retrieval=None,
ring_removal=True,
crop=None,
num_iter=None,
pad_length=0,
read_theta=True,
**kwargs):
"""
center_eq: a and b parameters in fitted center position equation center = a*slice + b.
"""
if not os.path.exists(dest_folder):
try:
os.mkdir(dest_folder)
except:
pass
sino_ini = int(sino_range[0])
sino_end = int(sino_range[1])
sino_ls_all = np.arange(sino_ini, sino_end, sino_step, dtype='int')
alloc_set = allocate_mpi_subsets(sino_ls_all.size,
size,
task_list=sino_ls_all)
sino_ls = alloc_set[rank]
# prepare metadata
f = h5py.File(src_fanme)
dset = f['exchange/data']
full_shape = dset.shape
if read_theta:
_, _, _, theta = read_data_adaptive(src_fanme, proj=(0, 1))
else:
theta = tomopy.angles(full_shape[0])
if center_eq is not None:
a, b = center_eq
center_ls = sino_ls_all * a + b
center_ls = np.round(center_ls)
for iblock in range(int(sino_ls.size / chunk_size) + 1):
internal_print('Beginning block {:d}.'.format(iblock))
t0 = time.time()
istart = iblock * chunk_size
iend = np.min([(iblock + 1) * chunk_size, sino_ls.size])
sub_sino_ls = sino_ls[istart:iend - 1]
center = np.take(center_ls, sub_sino_ls)
data = np.zeros([dset.shape[0], len(sub_sino_ls), dset.shape[2]])
for ind, i in enumerate(sub_sino_ls):
data[:, ind, :] = dset[:, i, :]
data[np.isnan(data)] = 0
data = data.astype('float32')
data = tomopy.remove_stripe_ti(data, alpha=4)
if sino_blur is not None:
for i in range(data.shape[1]):
data[:, i, :] = gaussian_filter(data[:, i, :], sino_blur)
if phase_retrieval:
data = tomopy.retrieve_phase(data, kwargs['pixel_size'],
kwargs['dist'], kwargs['energy'],
kwargs['alpha'])
if pad_length != 0:
data = pad_sinogram(data, pad_length)
data = tomopy.remove_stripe_ti(data, alpha=4)
if ring_removal:
rec0 = tomopy.recon(data,
theta,
center=center + pad_length,
algorithm=algorithm,
**kwargs)
rec = tomopy.remove_ring(np.copy(rec0))
cent = int((rec.shape[1] - 1) / 2)
xx, yy = np.meshgrid(np.arange(rec.shape[2]),
np.arange(rec.shape[1]))
mask0 = ((xx - cent)**2 +
(yy - cent)**2 <= flattened_radius**2)
mask = np.zeros(rec.shape, dtype='bool')
for i in range(mask.shape[0]):
mask[i, :, :] = mask0
rec[mask] = (rec[mask] + rec0[mask]) / 2
else:
rec = tomopy.recon(data,
theta,
center=center + pad_length,
algorithm=algorithm,
**kwargs)
if pad_length != 0:
rec = rec[:, pad_length:pad_length + full_shape[2],
pad_length:pad_length + full_shape[2]]
rec = tomopy.remove_outlier(rec, tolerance)
rec = tomopy.circ_mask(rec, axis=0, ratio=0.95)
if crop is not None:
crop = np.asarray(crop)
rec = rec[:, crop[0, 0]:crop[1, 0], crop[0, 1]:crop[1, 1]]
for i in range(rec.shape[0]):
slice = sub_sino_ls[i]
dxchange.write_tiff(
rec[i, :, :],
fname=os.path.join(
dest_folder, 'recon/recon_{:05d}.tiff').format(slice))
if save_sino:
dxchange.write_tiff(
data[:, i, :],
fname=os.path.join(
dest_folder, 'sino/recon_{:05d}_{:d}.tiff').format(
slice, int(center[i])))
iblock += 1
internal_print('Block {:d} finished in {:.2f} s.'.format(
iblock,
time.time() - t0))
else:
# divide chunks
grid_bins = np.append(np.ceil(shift_grid[:, 0, 0]), full_shape[1])
chunks = []
center_ls = []
istart = 0
counter = 0
# irow should be 0 for slice 0
irow = np.searchsorted(grid_bins, sino_ls[0], side='right') - 1
for i in range(sino_ls.size):
counter += 1
sino_next = i + 1 if i != sino_ls.size - 1 else i
if counter >= chunk_size or sino_ls[sino_next] >= grid_bins[
irow + 1] or sino_next == i:
iend = i + 1
chunks.append((istart, iend))
istart = iend
center_ls.append(center_vec[irow])
if sino_ls[sino_next] >= grid_bins[irow + 1]:
irow += 1
counter = 0
# reconstruct chunks
iblock = 1
for (istart, iend), center in zip(chunks, center_ls):
internal_print('Beginning block {:d}.'.format(iblock))
t0 = time.time()
internal_print('Reading data...')
sub_sino_ls = sino_ls[istart:iend]
data = np.zeros([dset.shape[0], len(sub_sino_ls), dset.shape[2]])
for ind, i in enumerate(sub_sino_ls):
data[:, ind, :] = dset[:, i, :]
if mode == '360':
overlap = 2 * (dset.shape[2] - center)
data = tomosaic.sino_360_to_180(data,
overlap=overlap,
rotation='right')
theta = tomopy.angles(data.shape[0])
data[np.isnan(data)] = 0
data = data.astype('float32')
if sino_blur is not None:
for i in range(data.shape[1]):
data[:, i, :] = gaussian_filter(data[:, i, :], sino_blur)
if phase_retrieval:
data = tomopy.retrieve_phase(data, kwargs['pixel_size'],
kwargs['dist'], kwargs['energy'],
kwargs['alpha'])
if pad_length != 0:
data = pad_sinogram(data, pad_length)
data = tomopy.remove_stripe_ti(data, alpha=4)
if ring_removal:
rec0 = tomopy.recon(data,
theta,
center=center + pad_length,
algorithm=algorithm,
**kwargs)
rec = tomopy.remove_ring(np.copy(rec0))
cent = int((rec.shape[1] - 1) / 2)
xx, yy = np.meshgrid(np.arange(rec.shape[2]),
np.arange(rec.shape[1]))
mask0 = ((xx - cent)**2 +
(yy - cent)**2 <= flattened_radius**2)
mask = np.zeros(rec.shape, dtype='bool')
for i in range(mask.shape[0]):
mask[i, :, :] = mask0
rec[mask] = (rec[mask] + rec0[mask]) / 2
else:
rec = tomopy.recon(data,
theta,
center=center + pad_length,
algorithm=algorithm,
**kwargs)
if pad_length != 0:
rec = rec[:, pad_length:pad_length + full_shape[2],
pad_length:pad_length + full_shape[2]]
rec = tomopy.remove_outlier(rec, tolerance)
rec = tomopy.circ_mask(rec, axis=0, ratio=0.95)
if crop is not None:
crop = np.asarray(crop)
rec = rec[:, crop[0, 0]:crop[1, 0], crop[0, 1]:crop[1, 1]]
for i in range(rec.shape[0]):
slice = sub_sino_ls[i]
if test_mode:
dxchange.write_tiff(
rec[i, :, :],
fname=os.path.join(
dest_folder,
'recon/recon_{:05d}_{:d}.tiff').format(
slice, center),
dtype=dtype)
else:
dxchange.write_tiff(
rec[i, :, :],
fname=os.path.join(
dest_folder,
'recon/recon_{:05d}.tiff').format(slice),
dtype=dtype)
if save_sino:
dxchange.write_tiff(
data[:, i, :],
fname=os.path.join(
dest_folder, 'sino/recon_{:05d}_{:d}.tiff').format(
slice, center),
dtype=dtype)
internal_print('Block {:d} finished in {:.2f} s.'.format(
iblock,
time.time() - t0))
iblock += 1
return
def recon_hdf5_mpi(src_fanme,
dest_folder,
sino_range,
sino_step,
center_vec,
shift_grid,
dtype='float32',
algorithm='gridrec',
tolerance=1,
save_sino=False,
sino_blur=None,
**kwargs):
"""
Reconstruct a single tile, or fused HDF5 created using util/total_fusion. MPI supported.
"""
raise DeprecationWarning
if rank == 0:
if not os.path.exists(dest_folder):
os.mkdir(dest_folder)
sino_ini = int(sino_range[0])
sino_end = int(sino_range[1])
f = h5py.File(src_fanme)
dset = f['exchange/data']
full_shape = dset.shape
theta = tomopy.angles(full_shape[0])
center_vec = np.asarray(center_vec)
sino_ls = np.arange(sino_ini, sino_end, sino_step, dtype='int')
grid_bins = np.ceil(shift_grid[:, 0, 0])
t0 = time.time()
alloc_set = allocate_mpi_subsets(sino_ls.size, size, task_list=sino_ls)
for slice in alloc_set[rank]:
print(' Rank {:d}: reconstructing {:d}'.format(rank, slice))
grid_line = np.digitize(slice, grid_bins)
grid_line = grid_line - 1
center = center_vec[grid_line]
data = dset[:, slice, :]
if sino_blur is not None:
data = gaussian_filter(data, sino_blur)
data = data.reshape([full_shape[0], 1, full_shape[2]])
data[np.isnan(data)] = 0
data = data.astype('float32')
if save_sino:
dxchange.write_tiff(data[:, slice, :],
fname=os.path.join(
dest_folder,
'sino/recon_{:05d}_{:d}.tiff').format(
slice, center))
# data = tomopy.remove_stripe_ti(data)
rec = tomopy.recon(data,
theta,
center=center,
algorithm=algorithm,
**kwargs)
# rec = tomopy.remove_ring(rec)
rec = tomopy.remove_outlier(rec, tolerance)
rec = tomopy.circ_mask(rec, axis=0, ratio=0.95)
dxchange.write_tiff(rec,
fname='{:s}/recon/recon_{:05d}_{:d}'.format(
dest_folder, slice, center),
dtype=dtype)
print('Rank {:d} finished in {:.2f} s.'.format(rank, time.time() - t0))
return
def partial_center_alignment(file_grid, shift_grid, center_vec, src_folder, range_0=-5, range_1=5):
"""
Further refine shift to optimize reconstruction in case of tilted rotation center, using entropy minimization as
metric.
"""
n_tiles = file_grid.size
if size > n_tiles:
raise ValueError('Number of ranks larger than number of tiles.')
root_folder = os.getcwd()
os.chdir(src_folder)
if rank == 0:
f = h5py.File(file_grid[0, 0])
dset = f['exchange/data']
slice = int(dset.shape[1]/2)
xcam = dset.shape[2]
n_angles = dset.shape[0]
for i in range(1, size):
comm.send(slice, dest=i)
comm.send(xcam, dest=i)
comm.send(n_angles, dest=i)
else:
slice = comm.recv(source=0)
xcam = comm.recv(source=0)
n_angles = comm.recv(source=0)
comm.Barrier()
width = shift_grid[:, -1, 1].max() + xcam
tile_ls = np.zeros([file_grid.size, 2], dtype='int')
a = np.unravel_index(range(n_tiles), file_grid.shape)
tile_ls[:, 0] = a[0]
tile_ls[:, 1] = a[1]
theta = tomopy.angles(n_angles)
shift_corr = np.zeros(shift_grid.shape)
alloc_set = allocate_mpi_subsets(n_tiles, size)
for i in alloc_set[rank]:
y, x = tile_ls[i]
center = center_vec[y]
fname = file_grid[y, x]
sino, flt, drk = read_aps_32id_adaptive(fname, sino=(slice, slice+1))
sino = np.squeeze(tomopy.normalize(sino, flt, drk))
sino = preprocess(sino)
s_opt = np.inf
for delta in range(range_0, range_1+1):
sino_pad = np.zeros([n_angles, width])
sino_pad = arrange_image(sino_pad, sino, (0, shift_grid[y, x, 1]+delta))
sino_pad = sino_pad.reshape(sino_pad.shape[0], 1, sino_pad.shape[1])
rec = tomopy.recon(sino_pad, theta, center=center)
rec = np.squeeze(rec)
s = entropy(rec)
if s < s_opt:
s_opt = s
delta_opt = delta
shift_corr[y, x, 1] += delta_opt
comm.Barrier()
if rank != 0:
comm.send(shift_corr, dest=0)
else:
for i in range(1, size):
shift_corr = shift_corr + comm.recv(source=i)
os.chdir(root_folder)
np.save('shift_corr', shift_corr)
return
def total_fusion(src_folder, dest_folder, dest_fname, file_grid, shift_grid, blend_method='pyramid', blend_method2=None,
blend_options={}, blend_options2={}, blur=None, color_correction=False, dtype='float16'):
"""
Fuse hdf5 of all tiles in to one single file. MPI is supported.
Parameters
----------
blend_method: blending algorithm. If blend_method2 is None, the specified algorithm will be applied to both x and y
directions by default.
blend_method2: secondary blending algorithm. If this option is not None, it will be applied for blending in y-
direction, while blend_method will be applied for x.
"""
dest_fname = check_fname_ext(dest_fname, 'h5')
if rank == 0:
if not os.path.exists(dest_folder):
os.mkdir(dest_folder)
if os.path.exists(dest_folder + '/' + dest_fname):
print('Warning: File already exists. Continue anyway? (y/n) ')
cont = raw_input()
if cont in ['n', 'N']:
exit()
else:
print('Old file will be overwritten.')
os.remove(dest_folder + '/' + dest_fname)
f = h5py.File(dest_folder + '/' + dest_fname)
comm.Barrier()
if rank != 0:
assert os.path.exists(dest_folder + '/' + dest_fname)
f = h5py.File(dest_folder + '/' + dest_fname)
origin_dir = os.getcwd()
os.chdir(src_folder)
o = h5py.File(file_grid[0, 0])
n_frames, y_cam, x_cam = o['exchange/data'].shape
frames_per_rank = int(n_frames/size)
grp = f.create_group('exchange')
full_width = np.max(shift_grid[:, -1, 1]) + x_cam + 10
full_height = np.max(shift_grid[-1, :, 0]) + y_cam + 10
full_shape = (n_frames, full_height, full_width)
dset_data = grp.create_dataset('data', full_shape, dtype=dtype)
dset_flat = grp.create_dataset('data_white', (1, full_height, full_width), dtype=dtype)
dset_dark = grp.create_dataset('data_dark', (1, full_height, full_width), dtype=dtype)
dset_flat[:, :, :] = np.ones(dset_flat.shape, dtype=dtype)
dset_dark[:, :, :] = np.zeros(dset_dark.shape, dtype=dtype)
print('Started to build full hdf5.')
t0 = time.time()
alloc_set = allocate_mpi_subsets(n_frames, size)
for frame in alloc_set[rank]:
print('alloc set {:d}'.format(rank))
print(' Rank: {:d}; current frame: {:d}..'.format(rank, frame))
t00 = time.time()
pano = np.zeros((full_height, full_width), dtype=dtype)
# save_stdout = sys.stdout
# sys.stdout = open('log', 'w')
temp = build_panorama(src_folder, file_grid, shift_grid, frame=frame, method=blend_method, method2=blend_method2,
blend_options=blend_options, blend_options2=blend_options2, blur=blur, color_correction=color_correction)
temp[np.isnan(temp)] = 0
# sys.stdout = save_stdout
pano[:temp.shape[0], :temp.shape[1]] = temp.astype(dtype)
dset_data[frame, :, :] = pano
print(' Frame {:d} done in {:.3f} s.'.format(frame, time.time() - t00))
print('Data built and written in {:.3f} s.'.format(time.time() - t0))
# try:
# os.remove('trash')
# except:
# print('Please remove trash manually.')
os.chdir(origin_dir)
def hdf5_retrieve_phase(src_folder, src_fname, dest_folder, dest_fname, method='paganin', corr_flat=False,
dtype='float16', sino_range=None, **kwargs):
src_fname = check_fname_ext(src_fname, 'h5')
dest_fname = check_fname_ext(dest_fname, 'h5')
o = h5py.File('{:s}/{:s}'.format(src_folder, src_fname))
dset_src = o['exchange/data']
n_frames = dset_src.shape[0]
if rank == 0:
if not os.path.exists(dest_folder):
os.mkdir(dest_folder)
if os.path.exists(dest_folder + '/' + dest_fname):
print('Warning: File already exists. Continue anyway? (y/n) ')
cont = raw_input()
if cont in ['n', 'N']:
exit()
else:
print('Old file will be overwritten.')
os.remove(dest_folder+'/' + dest_fname)
#f = make_empty_hdf5(dest_folder, dest_fname, dset_src.shape, dtype=dtype)
f = h5py.File(dest_folder+'/'+dest_fname)
comm.Barrier()
if rank != 0:
f = h5py.File(dest_folder+'/'+dest_fname)
full_shape = dset_src.shape
grp = f.create_group('exchange')
if sino_range is None:
dset_dest = grp.create_dataset('data', full_shape, dtype=dtype)
dset_flat = grp.create_dataset('data_white', (1, full_shape[1], full_shape[2]), dtype=dtype)
dset_dark = grp.create_dataset('data_dark', (1, full_shape[1], full_shape[2]), dtype=dtype)
else:
sino_start = sino_range[0]
sino_end = sino_range[1]
dset_dest = grp.create_dataset('data', (full_shape[0], (sino_end-sino_start), full_shape[2]), dtype=dtype)
dset_flat = grp.create_dataset('data_white', (1, (sino_end-sino_start), full_shape[2]), dtype=dtype)
dset_dark = grp.create_dataset('data_dark', (1, (sino_end-sino_start), full_shape[2]), dtype=dtype)
dset_flat[:, :, :] = np.ones(dset_flat.shape, dtype=dtype)
dset_dark[:, :, :] = np.zeros(dset_dark.shape, dtype=dtype)
comm.Barrier()
flt = o['exchange/data_white'].value
drk = o['exchange/data_dark'].value
print('Method: {:s}'.format(method), kwargs)
alloc_set = allocate_mpi_subsets(n_frames, size)
for frame in alloc_set[rank]:
t0 = time.time()
print(' Rank: {:d}; current frame: {:d}.'.format(rank, frame))
if sino_range is None:
temp = dset_src[frame, :, :]
else:
sino_start = sino_range[0]
sino_end = sino_range[1]
temp = dset_src[frame, sino_start:sino_end, :]
if corr_flat:
temp = temp.reshape([1, temp.shape[0], temp.shape[1]])
temp = tomopy.normalize(temp, flt, drk)
temp = preprocess(temp)
temp = np.squeeze(temp)
temp = retrieve_phase(temp, method=method, **kwargs)
dset_dest[frame, :, :] = temp.astype(dtype)
print(' Done in {:.2f}s. '.format(time.time()-t0))
f.close()
comm.Barrier()
return
def hdf5_retrieve_phase(src_folder,
src_fname,
dest_folder,
dest_fname,
method='paganin',
corr_flat=False,
dtype='float16',
sino_range=None,
**kwargs):
src_fname = check_fname_ext(src_fname, 'h5')
dest_fname = check_fname_ext(dest_fname, 'h5')
o = h5py.File('{:s}/{:s}'.format(src_folder, src_fname))
dset_src = o['exchange/data']
n_frames = dset_src.shape[0]
if rank == 0:
if not os.path.exists(dest_folder):
os.mkdir(dest_folder)
if os.path.exists(dest_folder + '/' + dest_fname):
print('Warning: File already exists. Continue anyway? (y/n) ')
cont = six.moves.input()
if cont in ['n', 'N']:
exit()
else:
print('Old file will be overwritten.')
os.remove(dest_folder + '/' + dest_fname)
#f = make_empty_hdf5(dest_folder, dest_fname, dset_src.shape, dtype=dtype)
f = h5py.File(dest_folder + '/' + dest_fname)
comm.Barrier()
if rank != 0:
f = h5py.File(dest_folder + '/' + dest_fname)
full_shape = dset_src.shape
grp = f.create_group('exchange')
if sino_range is None:
dset_dest = grp.create_dataset('data', full_shape, dtype=dtype)
dset_flat = grp.create_dataset('data_white',
(1, full_shape[1], full_shape[2]),
dtype=dtype)
dset_dark = grp.create_dataset('data_dark',
(1, full_shape[1], full_shape[2]),
dtype=dtype)
else:
sino_start = sino_range[0]
sino_end = sino_range[1]
dset_dest = grp.create_dataset(
'data', (full_shape[0], (sino_end - sino_start), full_shape[2]),
dtype=dtype)
dset_flat = grp.create_dataset(
'data_white', (1, (sino_end - sino_start), full_shape[2]),
dtype=dtype)
dset_dark = grp.create_dataset(
'data_dark', (1, (sino_end - sino_start), full_shape[2]),
dtype=dtype)
dset_flat[:, :, :] = np.ones(dset_flat.shape, dtype=dtype)
dset_dark[:, :, :] = np.zeros(dset_dark.shape, dtype=dtype)
comm.Barrier()
flt = o['exchange/data_white'].value
drk = o['exchange/data_dark'].value
print('Method: {:s}'.format(method), kwargs)
alloc_set = allocate_mpi_subsets(n_frames, size)
for frame in alloc_set[rank]:
t0 = time.time()
print(' Rank: {:d}; current frame: {:d}.'.format(rank, frame))
if sino_range is None:
temp = dset_src[frame, :, :]
else:
sino_start = sino_range[0]
sino_end = sino_range[1]
temp = dset_src[frame, sino_start:sino_end, :]
if corr_flat:
temp = temp.reshape([1, temp.shape[0], temp.shape[1]])
temp = tomopy.normalize(temp, flt, drk)
temp = preprocess(temp)
temp = np.squeeze(temp)
temp = retrieve_phase(temp, method=method, **kwargs)
dset_dest[frame, :, :] = temp.astype(dtype)
print(' Done in {:.2f}s. '.format(time.time() - t0))
f.close()
comm.Barrier()
return
def recon_block(grid,
shift_grid,
src_folder,
dest_folder,
slice_range,
sino_step,
center_vec,
ds_level=0,
blend_method='max',
blend_options=None,
tolerance=1,
sinogram_order=False,
algorithm='gridrec',
init_recon=None,
ncore=None,
nchunk=None,
dtype='float32',
crop=None,
save_sino=False,
assert_width=None,
sino_blur=None,
color_correction=False,
flattened_radius=120,
normalize=True,
test_mode=False,
mode='180',
phase_retrieval=None,
data_format='aps_32id',
read_theta=True,
ring_removal=True,
**kwargs):
"""
Reconstruct dsicrete HDF5 tiles, blending sinograms only.
"""
sino_ini = int(slice_range[0])
sino_end = int(slice_range[1])
mod_start_slice = 0
center_vec = np.asarray(center_vec)
center_pos_cache = 0
sino_ls = np.arange(sino_ini, sino_end, sino_step, dtype='int')
alloc_set = allocate_mpi_subsets(sino_ls.size, size, task_list=sino_ls)
for i_slice in alloc_set[rank]:
internal_print('############################################')
internal_print('Reconstructing ' + str(i_slice))
row_sino, center_pos = create_row_sinogram(
grid, shift_grid, src_folder, i_slice, center_vec, ds_level,
blend_method, blend_options, assert_width, sino_blur,
color_correction, normalize, mode, phase_retrieval, data_format)
if row_sino is None:
continue
if read_theta:
_, _, _, theta = read_data_adaptive(os.path.join(
src_folder, grid[0, 0]),
proj=(0, 1),
return_theta=True)
if ring_removal:
rec0 = recon_slice(row_sino,
theta,
center_pos,
sinogram_order=sinogram_order,
algorithm=algorithm,
init_recon=init_recon,
ncore=ncore,
nchunk=nchunk,
**kwargs)
rec = tomopy.remove_ring(np.copy(rec0))
cent = int((rec.shape[1] - 1) / 2)
xx, yy = np.meshgrid(np.arange(rec.shape[2]),
np.arange(rec.shape[1]))
mask0 = ((xx - cent)**2 + (yy - cent)**2 <= flattened_radius**2)
mask = np.zeros(rec.shape, dtype='bool')
for i in range(mask.shape[0]):
mask[i, :, :] = mask0
rec[mask] = (rec[mask] + rec0[mask]) / 2
else:
rec = recon_slice(row_sino,
theta,
center_pos,
sinogram_order=sinogram_order,
algorithm=algorithm,
init_recon=init_recon,
ncore=ncore,
nchunk=nchunk,
**kwargs)
#rec = tomopy.remove_outlier(rec, tolerance)
rec = tomopy.circ_mask(rec, axis=0, ratio=0.95)
internal_print('Center: {:d}'.format(center_pos))
rec = np.squeeze(rec)
# correct recon position shifting due to center misalignment
if center_pos_cache == 0:
center_pos_cache = center_pos
center_diff = center_pos - center_pos_cache
if center_diff != 0:
rec = np.roll(rec, -center_diff, axis=0)
if not crop is None:
crop = np.asarray(crop)
rec = rec[crop[0, 0]:crop[1, 0], crop[0, 1]:crop[1, 1]]
if test_mode:
dxchange.write_tiff(rec,
fname=os.path.join(
dest_folder,
'recon/recon_{:05d}_{:04d}.tiff'.format(
i_slice, center_pos)),
dtype=dtype)
else:
dxchange.write_tiff(rec,
fname=os.path.join(
dest_folder,
'recon/recon_{:05d}.tiff'.format(i_slice)),
dtype=dtype)
if save_sino:
dxchange.write_tiff(np.squeeze(row_sino),
fname=os.path.join(
dest_folder,
'sino/sino_{:05d}.tiff'.format(i_slice)),
overwrite=True)
return
def reorganize_dir(file_list, raw_ds=(2,4), dtype='float16', **kwargs):
"""
Reorganize hdf5 files and reorganize directory as:
----------------
/data_raw_1x/1920x1200x4500 x* 12x11
/shift_matrix
/center_matrix
/data_raw_2x/960x600x4500 x* 12x11
/raw_4x/480x300x4500 x* 12x11
---------------
/recon_gridrec_1x
x* means grid of hdf5 files
Parameters:
-----------
file_list : ndarray
List of h5 files in the directory.
convert : int, optional
Bit of integer the data are to be converted into.
"""
# downsample
try:
f = h5py.File(file_list[0])
full_shape = f['exchange/data'].shape
except:
f = h5py.File(os.path.join('data_raw_1x', file_list[0]))
full_shape = f['exchange/data'].shape
comm.Barrier()
for fname in file_list:
print('Now processing '+str(fname))
# make downsampled subdirectories
for ds in raw_ds:
# create downsample folder if not existing
folder_name = 'data_raw_'+str(ds)+'x'
if rank == 0:
if not os.path.exists(folder_name):
os.mkdir(folder_name)
comm.Barrier()
# move file if downsample level is 1
if ds == 1:
if rank == 0:
if not os.path.isfile(folder_name+'/'+fname):
shutil.move(fname, folder_name+'/'+fname)
comm.Barrier()
# otherwise perform downsampling
else:
if rank == 0:
if not os.path.exists(folder_name):
os.mkdir(folder_name)
comm.Barrier()
try:
o = h5py.File('data_raw_1x/' + fname, 'r')
except:
o = h5py.File(fname, 'r')
raw = o['exchange/data']
if rank == 0:
if os.path.exists(folder_name+'/'+fname):
print('Warning: File already exists. Continue anyway? (y/n) ')
cont = raw_input()
if cont in ['n', 'N']:
exit()
else:
print('Old file will be overwritten. '+folder_name+'/' + fname)
os.remove(folder_name+'/' + fname)
f = h5py.File(folder_name+'/'+fname)
comm.Barrier()
if rank != 0:
f = h5py.File(folder_name+'/'+fname)
dat_grp = f.create_group('exchange')
dat = dat_grp.create_dataset('data', (full_shape[0], np.floor(full_shape[1]/ds),
np.floor(full_shape[2]/ds)), dtype=dtype)
# write downsampled data frame-by-frame
n_frames = full_shape[0]
alloc_sets = allocate_mpi_subsets(n_frames, size)
for frame in alloc_sets[rank]:
temp = raw[frame, :, :]
temp = image_downsample(temp, ds)
dat[frame, :, :] = temp
print('\r Rank: {:d}, DS: {:d}, at frame {:d}'.format(rank, ds, frame))
print(' ')
# downsample flat/dark field data
comm.Barrier()
raw = o['exchange/data_white']
aux_shape = raw.shape
dat = dat_grp.create_dataset('data_white', (aux_shape[0], np.floor(aux_shape[1]/ds),
np.floor(aux_shape[2]/ds)), dtype=dtype)
comm.Barrier()
print(' Downsampling whites and darks')
for frame in range(aux_shape[0]):
temp = raw[frame, :, :]
temp = image_downsample(temp, ds)
dat[frame, :, :] = temp
raw = o['exchange/data_dark']
aux_shape = raw.shape
dat = dat_grp.create_dataset('data_dark', (aux_shape[0], np.floor(aux_shape[1]/ds),
np.floor(aux_shape[2]/ds)), dtype=dtype)
comm.Barrier()
for frame in range(aux_shape[0]):
temp = raw[frame, :, :]
temp = image_downsample(temp, ds)
dat[frame, :, :] = temp
comm.Barrier()
f.close()
comm.Barrier()
# delete file after all done
try:
os.remove(fname)
except:
pass