def flat_correction(proj, flat, dark, params):
log.info(' *** normalization')
if (params.flat_correction_method == 'standard'):
try:
data = tomopy.normalize(proj,
flat,
dark,
cutoff=params.normalization_cutoff /
params.bright_exp_ratio)
data *= params.bright_exp_ratio
except AttributeError:
log.warning(' *** *** No bright_exp_ratio found. Ignore')
log.info(' *** *** ON %f cut-off' % params.normalization_cutoff)
elif (params.flat_correction_method == 'air'):
data = tomopy.normalize_bg(proj, air=params.air)
log.info(' *** *** air %d pixels' % params.air)
elif (params.flat_correction_method == 'none'):
data = proj
log.warning(' *** *** normalization is turned off')
else:
raise ValueError("Unknown value for *flat_correction_method*: {}. "
"Valid options are {}"
"".format(
params.flat_correction_method,
config.SECTIONS['flat-correction']
['flat-correction-method']['choices']))
return data
def project(ct_series, outdir, console_out):
"""convert ct image series to projection series"""
if os.path.exists(outdir):
msg = "%s existed, assume projection has already been done. skip this\n" % (
outdir,)
console_out.write(msg)
return
import tomopy
data = []; N = len(ct_series.identifiers)
prefix = "Read ct series"
for i,angle in enumerate(ct_series.identifiers):
# if i%3 != 0: continue
data1 = ct_series.getImage(angle).getData()
# data[data<=0] = 1.
data1 = data1[100:-100, 100:-100]
data.append(data1)
console_out.write("\r%s: %2.0f%%" % (prefix, (i+1)*100./N))
console_out.flush()
continue
console_out.write("\n"); console_out.flush()
# project
console_out.write("tomopy.normalize_bg..."); console_out.flush()
proj = tomopy.normalize_bg(data) # , ncore=ncore)
console_out.write("done\n"); console_out.flush()
del data
# remove negative intensities
proj[proj<0] = 0
# output
console_out.write("tomopy.write_tiff_stack..."); console_out.flush()
tomopy.write_tiff_stack(
proj, fname=os.path.join(outdir, 'proj'), axis=1, overwrite=False)
console_out.write("done\n"); console_out.flush()
return
def preprocess_data(prj,
flat,
dark,
FF_norm=flat_field_norm,
remove_rings=remove_rings,
FF_drift_corr=flat_field_drift_corr,
downsapling=binning):
if FF_norm: # dark-flat field correction
prj = tomopy.normalize(prj, flat, dark)
if FF_drift_corr: # flat field drift correction
prj = tomopy.normalize_bg(prj, air=50)
prj[prj <= 0] = 1 # check dark<data
prj = tomopy.minus_log(prj) # -logarithm
if remove_rings: # remove rings
prj = tomopy.remove_stripe_fw(prj,
level=7,
wname='sym16',
sigma=1,
pad=True)
#prj = tomopy.remove_stripe_ti(prj,2)
# prj = tomopy.remove_all_stripe(prj)
if downsapling > 0: # binning
prj = tomopy.downsample(prj, level=binning)
prj = tomopy.downsample(prj, level=binning, axis=1)
return prj
def preprocess_data(prj, flat, dark, FF_norm=flat_field_norm, remove_rings = remove_rings, medfilt_size=medfilt_size, FF_drift_corr=flat_field_drift_corr, downspling=binning):
if FF_norm:
# normalize the prj
print('\n*** Applying flat field correction:')
start_norm_time = time.time()
prj = tomopy.normalize(prj, flat, dark)
print(' done in %0.3f min' % ((time.time() - start_norm_time)/60))
if FF_drift_corr:
print('\n*** Applying flat field drift correction:')
start_norm_bg_time = time.time()
prj = tomopy.normalize_bg(prj, air=100)
print(' done in %0.3f min' % ((time.time() - start_norm_bg_time)/60))
# Applying -log
print('\n*** Applying -log:')
start_log_time = time.time()
prj = tomopy.minus_log(prj)
print(' done in %0.3f min' % ((time.time() - start_log_time)/60))
prj = tomopy.misc.corr.remove_neg(prj, val=0.000)
prj = tomopy.misc.corr.remove_nan(prj, val=0.000)
prj[np.where(prj == np.inf)] = 0.000
# prj[np.where(prj == 0)] = 0.000,2
print('\n*** Min and max val in prj before recon: %0.3f, %0.3f' % (np.min(prj), np.max(prj)))
if remove_rings:
# remove ring artefacts
tmp = prj[-1,:,:] # use to fixe the bug of remove_stripe_ti
print('\n*** Applying ring removal algo:')
start_ring_time = time.time()
# prj = tomopy.remove_stripe_ti(prj, nblock=0, alpha=2)
prj = tomopy.remove_stripe_fw(prj)
# prj = tomopy.remove_stripe_sf(prj,10); prj = tomopy.misc.corr.remove_neg(prj, val=0.000) # remove the neg values coming from remove_stripe_sf
print(' done in %0.3f min' % ((time.time() - start_ring_time)/60))
prj[-1,:,:] = tmp # fixe the bug of remove_stripe_ti
# Filtering data with 2D median filter before downsampling and recon
if medfilt_size>1:
start_filter_time = time.time()
print('\n*** Applying median filter')
#prj = tomopy.median_filter(prj,size=1)
prj = ndimage.median_filter(prj,footprint=np.ones((1, medfilt_size, medfilt_size)))
print(' done in %0.3f min' % ((time.time() - start_filter_time)/60))
# Downsampling data:
if downspling>0:
print('\n** Applying downsampling')
start_down_time = time.time()
prj = tomopy.downsample(prj, level=binning)
prj = tomopy.downsample(prj, level=binning, axis=1)
print(' done in %0.3f min' % ((time.time() - start_down_time)/60))
print('\n*** Shape of the data:'+str(np.shape(prj)))
print(' Dimension of theta:'+str(np.shape(theta)))
return prj
def main(arg):
parser = argparse.ArgumentParser()
parser.add_argument(
"top", help="top directory where the tiff images are located: /data/")
parser.add_argument("start",
nargs='?',
const=1,
type=int,
default=1,
help="index of the first image: 10001 (default 1)")
args = parser.parse_args()
top = args.top
index_start = int(args.start)
template = os.listdir(top)[1]
nfile = len(fnmatch.filter(os.listdir(top), '*.tif'))
index_end = index_start + nfile
ind_tomo = range(index_start, index_end)
fname = top + template
# Read the tiff raw data.
rdata = dxchange.read_tiff_stack(fname, ind=ind_tomo)
particle_bed_reference = particle_bed_location(rdata[0], plot=False)
print("Particle bed location: ", particle_bed_reference)
# Cut the images to remove the particle bed
cdata = rdata[:, 0:particle_bed_reference, :]
# Find the image when the shutter starts to close
dark_index = shutter_off(rdata)
print("shutter closes on image: ", dark_index)
# Set the [start, end] index of the blocked images, flat and dark.
flat_range = [0, 1]
data_range = [48, dark_index]
dark_range = [dark_index, nfile]
# # for fast testing
# data_range = [48, dark_index]
flat = cdata[flat_range[0]:flat_range[1], :, :]
proj = cdata[data_range[0]:data_range[1], :, :]
dark = np.zeros(
(dark_range[1] - dark_range[0], proj.shape[1], proj.shape[2]))
# if you want to use the shutter closed images as dark uncomment this:
#dark = cdata[dark_range[0]:dark_range[1], :, :]
ndata = tomopy.normalize(proj, flat, dark)
ndata = tomopy.normalize_bg(ndata, air=ndata.shape[2] / 2.5)
ndata = tomopy.minus_log(ndata)
sharpening(ndata)
slider(ndata)
def main(arg):
parser = argparse.ArgumentParser()
parser.add_argument("top", help="top directory where the tiff images are located: /data/")
parser.add_argument("start", nargs='?', const=1, type=int, default=1, help="index of the first image: 1000 (default 1)")
args = parser.parse_args()
top = args.top
index_start = int(args.start)
template = os.listdir(top)[0]
nfile = len(fnmatch.filter(os.listdir(top), '*.tif'))
index_end = index_start + nfile
ind_tomo = range(index_start, index_end)
fname = top + template
print (nfile, index_start, index_end, fname)
# Select the sinogram range to reconstruct.
start = 0
end = 512
sino=(start, end)
# Read the tiff raw data.
ndata = dxchange.read_tiff_stack(fname, ind=ind_tomo, slc=(sino, None))
# Normalize to 1 using the air counts
ndata = tomopy.normalize_bg(ndata, air=5)
# Set data collection angles as equally spaced between 0-180 degrees.
theta = tomopy.angles(ndata.shape[0])
ndata = tomopy.minus_log(ndata)
# Set binning and number of iterations
binning = 8
iters = 21
print("Original", ndata.shape)
ndata = tomopy.downsample(ndata, level=binning, axis=1)
# ndata = tomopy.downsample(ndata, level=binning, axis=2)
print("Processing:", ndata.shape)
fdir = 'aligned' + '/noblur_iter_' + str(iters) + '_bin_' + str(binning)
print(fdir)
cprj, sx, sy, conv = alignment.align_seq(ndata, theta, fdir=fdir, iters=iters, pad=(10, 10), blur=False, save=True, debug=True)
np.save(fdir + '/shift_x', sx)
np.save(fdir + '/shift_y', sy)
# Write aligned projections as stack of TIFs.
dxchange.write_tiff_stack(cprj, fname=fdir + '/radios/image')
def reconstruct(sname, rot_center, ovlpfind, s_start, s_end):
fname = dfolder + sname + '.h5'
print(fname)
start = s_start
end = s_end
chunks = 24
num_sino = (end - start) // chunks
for m in range(chunks):
sino_start = start + num_sino * m
sino_end = start + num_sino * (m + 1)
start_read_time = time.time()
proj, flat, dark, thetat = dxchange.read_aps_2bm(fname,
sino=(sino_start,
sino_end))
print(' done read in %0.1f min' %
((time.time() - start_read_time) / 60))
dark = proj[9001:9002]
flat = proj[0:1]
proj = proj[1:9000]
theta = tomopy.angles(proj.shape[0], 0., 360.)
proj = tomopy.sino_360_to_180(proj, overlap=ovlpfind, rotation='right')
proj = tomopy.remove_outlier(proj, dif=0.4)
proj = tomopy.normalize_bg(proj, air=10)
proj = tomopy.minus_log(proj)
center = rot_center
start_ring_time = time.time()
proj = tomopy.remove_stripe_fw(proj, wname='sym5', sigma=4, pad=False)
proj = tomopy.remove_stripe_sf(proj, size=3)
print(' done pre-process in %0.1f min' %
((time.time() - start_ring_time) / 60))
start_phase_time = time.time()
proj = tomopy.retrieve_phase(proj,
pixel_size=detector_pixel_size_x,
dist=sample_detector_distance,
energy=energy,
alpha=alpha,
pad=True,
ncore=None,
nchunk=None)
print(' done phase retrieval in %0.1f min' %
((time.time() - start_phase_time) / 60))
start_recon_time = time.time()
rec = tomopy.recon(proj,
theta,
center=center,
algorithm='gridrec',
filter_name='ramalk')
tomopy.circ_mask(rec, axis=0, ratio=0.95)
print("Reconstructed", rec.shape)
dxchange.write_tiff_stack(rec,
fname=dfolder + '/' + sname + '/' + sname,
overwrite=True,
start=sino_start)
print(' Chunk reconstruction done in %0.1f min' %
((time.time() - start_recon_time) / 60))
print("Done!")
def main(arg):
parser = argparse.ArgumentParser()
parser.add_argument("top", help="top directory where the tiff images are located: /data/")
parser.add_argument("start", nargs='?', const=1, type=int, default=1, help="index of the first image: 1000 (default 1)")
args = parser.parse_args()
top = args.top
index_start = int(args.start)
template = os.listdir(top)[0]
nfile = len(fnmatch.filter(os.listdir(top), '*.tif'))
index_end = index_start + nfile
ind_tomo = range(index_start, index_end)
fname = top + template
print (nfile, index_start, index_end, fname)
# Select the sinogram range to reconstruct.
start = 0
end = 512
sino=(start, end)
# Read the tiff raw data.
ndata = dxchange.read_tiff_stack(fname, ind=ind_tomo, slc=(sino, None))
print(ndata.shape)
binning = 8
ndata = tomopy.downsample(ndata, level=binning, axis=1)
print(ndata.shape)
# Normalize to 1 using the air counts
ndata = tomopy.normalize_bg(ndata, air=5)
## slider(ndata)
# Set data collection angles as equally spaced between 0-180 degrees.
theta = tomopy.angles(ndata.shape[0])
rot_center = 960
print("Center of rotation: ", rot_center)
ndata = tomopy.minus_log(ndata)
# Reconstruct object using Gridrec algorithm.
rec = tomopy.recon(ndata, theta, center=rot_center, algorithm='gridrec')
# Mask each reconstructed slice with a circle.
rec = tomopy.circ_mask(rec, axis=0, ratio=0.95)
# Write data as stack of TIFs.
dxchange.write_tiff_stack(rec, fname='/local/dataraid/mark/rec/recon')
def main(arg):
parser = argparse.ArgumentParser()
parser.add_argument("top", help="top directory where the tiff images are located: /data/")
parser.add_argument("start", nargs='?', const=1, type=int, default=1, help="index of the first image: 10001 (default 1)")
args = parser.parse_args()
top = args.top
index_start = int(args.start)
# Total number of images to read
nfile = len(fnmatch.filter(os.listdir(top), '*.tif'))
# Read the raw data
rdata = ximage.load_raw(top, index_start)
particle_bed_reference = ximage.particle_bed_location(rdata[0])
print("Particle bed location: ", particle_bed_reference)
# Cut the images to remove the particle bed
cdata = rdata[:, 0:particle_bed_reference, :]
# Find the image when the shutter starts to close
dark_index = ximage.shutter_off(rdata)
print("Shutter CLOSED on image: ", dark_index)
# Find the images when the laser is on
laser_on_index = ximage.laser_on(rdata, particle_bed_reference, alpha=1.00)
print("Laser ON on image: ", laser_on_index)
# Set the [start, end] index of the blocked images, flat and dark.
laser_on_index = 47
flat_range = [0, 1]
data_range = [laser_on_index, dark_index]
dark_range = [dark_index, nfile]
flat = cdata[flat_range[0]:flat_range[1], :, :]
proj = cdata[data_range[0]:data_range[1], :, :]
dark = np.zeros((dark_range[1]-dark_range[0], proj.shape[1], proj.shape[2]))
# if you want to use the shutter closed images as dark uncomment this:
#dark = cdata[dark_range[0]:dark_range[1], :, :]
ndata = tomopy.normalize(proj, flat, dark)
ndata = tomopy.normalize_bg(ndata, air=ndata.shape[2]/2.5)
ndata = tomopy.minus_log(ndata)
ximage.slider(ndata[150:160:,:])
ndata = ximage.scale_to_one(ndata)
ndata = ximage.sobel_stack(ndata)
ximage.slider(ndata[150:160:,:])
def preprocess(dat, blur=None, normalize_bg=False, minus_log=True):
dat[np.abs(dat) < 2e-3] = 2e-3
dat[dat > 1] = 1
if normalize_bg:
dat = tomopy.normalize_bg(dat)
if minus_log:
dat = -np.log(dat)
dat[np.where(np.isnan(dat) == True)] = 0
if blur is not None:
dat = gaussian_filter(dat, blur)
return dat
def main(arg):
parser = argparse.ArgumentParser()
parser.add_argument("top", help="top directory where the tiff images are located: /data/")
parser.add_argument("start", nargs='?', const=1, type=int, default=1, help="index of the first image: 10001 (default 1)")
args = parser.parse_args()
top = args.top
index_start = int(args.start)
template = os.listdir(top)[1]
nfile = len(fnmatch.filter(os.listdir(top), '*.tif'))
index_end = index_start + nfile
ind_tomo = range(index_start, index_end)
fname = top + template
# Read the tiff raw data.
rdata = dxchange.read_tiff_stack(fname, ind=ind_tomo)
particle_bed_reference = particle_bed_location(rdata[0], plot=False)
print("Particle bed location: ", particle_bed_reference)
# Cut the images to remove the particle bed
cdata = rdata[:, 0:particle_bed_reference, :]
# Find the image when the shutter starts to close
dark_index = shutter_off(rdata)
print("shutter closes on image: ", dark_index)
# Set the [start, end] index of the blocked images, flat and dark.
flat_range = [0, 1]
data_range = [48, dark_index]
dark_range = [dark_index, nfile]
# # for fast testing
# data_range = [48, dark_index]
flat = cdata[flat_range[0]:flat_range[1], :, :]
proj = cdata[data_range[0]:data_range[1], :, :]
dark = np.zeros((dark_range[1]-dark_range[0], proj.shape[1], proj.shape[2]))
# if you want to use the shutter closed images as dark uncomment this:
#dark = cdata[dark_range[0]:dark_range[1], :, :]
ndata = tomopy.normalize(proj, flat, dark)
ndata = tomopy.normalize_bg(ndata, air=ndata.shape[2]/2.5)
ndata = tomopy.minus_log(ndata)
sharpening(ndata)
slider(ndata)
def flat_correction(proj, flat, dark, params):
log.info(' *** normalization')
if (params.flat_correction_method == 'standard'):
data = tomopy.normalize(proj,
flat,
dark,
cutoff=params.normalization_cutoff)
log.info(' *** *** ON %f cut-off' % params.normalization_cutoff)
elif (params.flat_correction_method == 'air'):
data = tomopy.normalize_bg(proj, air=params.air)
log.info(' *** *** air %d pixels' % params.air)
elif (params.flat_correction_method == 'none'):
data = proj
log.warning(' *** *** normalization is turned off')
return data
def __call__usingtomopy(self, input_ct_series, output_ct_series):
print("Intensity fluctuation correction...")
import tomopy, numpy as np
data = [img.data for img in input_ct_series]
data = np.array(data)
data2 = tomopy.normalize_bg(data)
data2[data2 < 0] = 0
for i, identifier in enumerate(output_ct_series.identifiers):
img = output_ct_series.getImage(identifier)
# skip over existing result
if output_ct_series.exists(identifier):
print("%s already existed" % img)
continue
img.data = data2[i]
img.save()
continue
print("done")
return
def __call__usingtomopy(self, input_ct_series, output_ct_series):
print("Intensity fluctuation correction...")
import tomopy, numpy as np
data = [img.data for img in input_ct_series]
data = np.array(data)
data2 = tomopy.normalize_bg(data)
data2[data2<0] = 0
for i, identifier in enumerate(output_ct_series.identifiers):
img = output_ct_series.getImage(identifier)
# skip over existing result
if output_ct_series.exists(identifier):
print("%s already existed" % img)
continue
img.data = data2[i]
img.save()
continue
print("done")
return
def reconstruct(sname, rot_center, ovlpfind, s_start, s_end):
fname = dfolder + sname + '.h5'
print (fname)
start = s_start
end = s_end
chunks = 24
num_sino = (end - start) // chunks
for m in range(chunks):
sino_start = start + num_sino * m
sino_end = start + num_sino * (m + 1)
start_read_time = time.time()
proj, flat, dark, thetat = dxchange.read_aps_2bm(fname, sino=(sino_start, sino_end))
print(' done read in %0.1f min' % ((time.time() - start_read_time)/60))
dark = proj[9001:9002]
flat = proj[0:1]
proj = proj[1:9000]
theta = tomopy.angles(proj.shape[0], 0., 360.)
proj = tomopy.sino_360_to_180(proj, overlap=ovlpfind, rotation='right')
proj = tomopy.remove_outlier(proj, dif=0.4)
proj = tomopy.normalize_bg(proj, air=10)
proj = tomopy.minus_log(proj)
center = rot_center
start_ring_time = time.time()
proj = tomopy.remove_stripe_fw(proj, wname='sym5', sigma=4, pad=False)
proj = tomopy.remove_stripe_sf(proj, size=3)
print(' done pre-process in %0.1f min' % ((time.time() - start_ring_time)/60))
start_phase_time = time.time()
proj = tomopy.retrieve_phase(proj, pixel_size=detector_pixel_size_x, dist=sample_detector_distance, energy=energy, alpha=alpha, pad=True, ncore=None, nchunk=None)
print(' done phase retrieval in %0.1f min' % ((time.time() - start_phase_time)/60))
start_recon_time = time.time()
rec = tomopy.recon(proj, theta, center=center, algorithm='gridrec', filter_name='ramalk')
tomopy.circ_mask(rec, axis=0, ratio=0.95)
print ("Reconstructed", rec.shape)
dxchange.write_tiff_stack(rec, fname = dfolder + '/' + sname + '/' + sname, overwrite=True, start=sino_start)
print(' Chunk reconstruction done in %0.1f min' % ((time.time() - start_recon_time)/60))
print ("Done!")
def main(arg):
parser = argparse.ArgumentParser()
parser.add_argument(
"top", help="top directory where the tiff images are located: /data/")
parser.add_argument("start",
nargs='?',
const=1,
type=int,
default=1,
help="index of the first image: 1000 (default 1)")
args = parser.parse_args()
top = args.top
index_start = int(args.start)
template = os.listdir(top)[0]
nfile = len(fnmatch.filter(os.listdir(top), '*.tif'))
index_end = index_start + nfile
ind_tomo = range(index_start, index_end)
fname = top + template
print(nfile, index_start, index_end, fname)
# Select the sinogram range to reconstruct.
start = 0
end = 512
sino = (start, end)
# Read the tiff raw data.
ndata = dxchange.read_tiff_stack(fname, ind=ind_tomo, slc=(sino, None))
# Normalize to 1 using the air counts
ndata = tomopy.normalize_bg(ndata, air=5)
# Set data collection angles as equally spaced between 0-180 degrees.
theta = tomopy.angles(ndata.shape[0])
ndata = tomopy.minus_log(ndata)
# Set binning and number of iterations
binning = 8
iters = 21
print("Original", ndata.shape)
ndata = tomopy.downsample(ndata, level=binning, axis=1)
# ndata = tomopy.downsample(ndata, level=binning, axis=2)
print("Processing:", ndata.shape)
fdir = 'aligned' + '/noblur_iter_' + str(iters) + '_bin_' + str(binning)
print(fdir)
cprj, sx, sy, conv = alignment.align_seq(ndata,
theta,
fdir=fdir,
iters=iters,
pad=(10, 10),
blur=False,
save=True,
debug=True)
np.save(fdir + '/shift_x', sx)
np.save(fdir + '/shift_y', sy)
# Write aligned projections as stack of TIFs.
dxchange.write_tiff_stack(cprj, fname=fdir + '/radios/image')
def evaluate(self):
self.tomo.value = tomopy.normalize_bg(
self.tomo.value,
air=self.air.value,
ncore=self.ncore.value,
nchunk=self.nchunk.value)
import dxchange as dx
from netCDF4 import Dataset
if __name__ == '__main__':
## Set path (without file suffix) to the micro-CT data to reconstruct.
fname = 'data_dir/sample'
## Import Data.
proj, flat, dark, theta = dx.exchange.read_aps_13bm(fname, format = 'netcdf4')
## Flat-field correction of raw data.
proj = tp.normalize(proj, flat = flat, dark = dark)
## Additional flat-field correction of raw data to negate need to mask.
proj = tp.normalize_bg(proj, air = 10)
## Set rotation center.
rot_center = tp.find_center_vo(proj)
print('Center of rotation: ', rot_center)
tp.minus_log(proj, out = proj)
# Reconstruct object using Gridrec algorith.
rec = tp.recon(proj, theta, center = rot_center, sinogram_order = False, algorithm = 'gridrec', filter_name = 'hann')
rec = tp.remove_nan(rec)
## Writing data in netCDF3 .volume.
ncfile = Dataset('filename.volume', 'w', format = 'NETCDF3_64BIT', clobber = True)
NX = ncfile.createDimension('NX', rec.shape[2])
NY = ncfile.createDimension('NY', rec.shape[1])
from netCDF4 import Dataset
if __name__ == '__main__':
## Set path (without file suffix) to the micro-CT data to reconstruct.
fname = 'data_dir/sample'
## Import Data.
proj, flat, dark, theta = dx.exchange.read_aps_13bm(fname,
format='netcdf4')
## Flat-field correction of raw data.
proj = tp.normalize(proj, flat=flat, dark=dark)
## Additional flat-field correction of raw data to negate need to mask.
proj = tp.normalize_bg(proj, air=10)
## Set rotation center.
rot_center = tp.find_center_vo(proj)
print('Center of rotation: ', rot_center)
tp.minus_log(proj, out=proj)
# Reconstruct object using Gridrec algorith.
rec = tp.recon(proj,
theta,
center=rot_center,
sinogram_order=False,
algorithm='gridrec',
filter_name='hann')
rec = tp.remove_nan(rec)
exchange_rank = ExchangeRank
data, white, dark = tomopy.io.exchange.read_aps_32id(file_name,
exchange_rank,
sino=(slice_first, slice_first+4))
theta = tomopy.angles(data.shape[0])
# Xtomo object creation and pipeline of methods.
##d = tomopy.xtomo_dataset(log='debug')
##d.dataset(data, white, dark, theta)
#if perform_norm: d.normalize() # flat & dark field correction
if perform_norm: data = tomopy.normalize(data, white, dark)
##if drift_correct: d.correct_drift()
if drift_correct: data = tomopy.normalize_bg(data)
#d.median_filter(size=medfilt_size, axis=0) # Apply a median filter in the projection plane
data = tomopy.median_filter(data, size=medfilt_size, axis=0)
#if remove_stripe1: d.stripe_removal(level=stripe_lvl, sigma=sig, wname=Wname)
if remove_stripe1: data = tomopy.remove_stripe_fw(data, level=stripe_lvl, wname=Wname, sigma=sig)
# z = 3
# eng = 31
# pxl = 0.325e-4
# rat = 5e-03
# rat = 1e-03
#d.phase_retrieval(dist=z, energy=eng, pixel_size=pxl, alpha=rat,padding=True)
#data = tomopy.retrieve_phase(data, dist=z, energy=eng, pixel_size=pxl, alpha=rat,pad=True)
def preprocess_data(prj, flat, dark, FF_norm=flat_field_norm, remove_rings = remove_rings, medfilt_size=medfilt_size, FF_drift_corr=flat_field_drift_corr, downspling=binning):
if FF_norm:
# normalize the prj
print('\n*** Applying flat field correction:')
start_norm_time = time.time()
prj = tomopy.normalize(prj, flat, dark)
print(' done in %0.3f min' % ((time.time() - start_norm_time)/60))
if FF_drift_corr:
print('\n*** Applying flat field drift correction:')
start_norm_bg_time = time.time()
prj = tomopy.normalize_bg(prj, air=100)
print(' done in %0.3f min' % ((time.time() - start_norm_bg_time)/60))
# Applying -log
print('\n*** Applying -log:')
start_log_time = time.time()
prj = tomopy.minus_log(prj)
print(' done in %0.3f min' % ((time.time() - start_log_time)/60))
prj = tomopy.misc.corr.remove_neg(prj, val=0.000)
prj = tomopy.misc.corr.remove_nan(prj, val=0.000)
prj[np.where(prj == np.inf)] = 0.000
# prj[np.where(prj == 0)] = 0.000
print('\n*** Min and max val in prj before recon: %0.3f, %0.3f' % (np.min(prj), np.max(prj)))
if remove_rings:
# remove ring artefacts
tmp = prj[-1,:,:] # use to fixe the bug of remove_stripe_ti
print('\n*** Applying ring removal algo:')
start_ring_time = time.time()
prj = tomopy.remove_stripe_ti(prj,2)
# prj = tomopy.remove_stripe_sf(prj,10); prj = tomopy.misc.corr.remove_neg(prj, val=0.000) # remove the neg values coming from remove_stripe_sf
print(' done in %0.3f min' % ((time.time() - start_ring_time)/60))
prj[-1,:,:] = tmp # fixe the bug of remove_stripe_ti
if phase_retrieval:
# phase retrieval
prj = tomopy.prep.phase.retrieve_phase(prj,pixel_size=detector_pixel_size_x,dist=sample_detector_distance,energy=monochromator_energy,alpha=alpha,pad=True)
# Filtering data with 2D median filter before downsampling and recon
if medfilt_size>1:
start_filter_time = time.time()
print('\n*** Applying median filter')
#prj = tomopy.median_filter(prj,size=1)
prj = ndimage.median_filter(prj,footprint=np.ones((1, medfilt_size, medfilt_size)))
print(' done in %0.3f min' % ((time.time() - start_filter_time)/60))
# Downsampling data:
if downspling>0:
print('\n** Applying downsampling')
start_down_time = time.time()
prj = tomopy.downsample(prj, level=binning)
prj = tomopy.downsample(prj, level=binning, axis=1)
print(' done in %0.3f min' % ((time.time() - start_down_time)/60))
print('\n*** Shape of the data:'+str(np.shape(prj)))
print(' Dimension of theta:'+str(np.shape(theta)))
return prj
def main(arg):
parser = argparse.ArgumentParser()
parser.add_argument(
"top", help="top directory where the tiff images are located: /data/")
parser.add_argument("start",
nargs='?',
const=1,
type=int,
default=1,
help="index of the first image: 1000 (default 1)")
args = parser.parse_args()
top = args.top
index_start = int(args.start)
template = os.listdir(top)[0]
nfile = len(fnmatch.filter(os.listdir(top), '*.tif'))
index_end = index_start + nfile
ind_tomo = range(index_start, index_end)
fname = top + template
print(nfile, index_start, index_end, fname)
# Select the sinogram range to reconstruct.
start = 0
end = 512
sino = (start, end)
# Read the tiff raw data.
ndata = dxchange.read_tiff_stack(fname, ind=ind_tomo, slc=(sino, None))
print(ndata.shape)
binning = 8
ndata = tomopy.downsample(ndata, level=binning, axis=1)
print(ndata.shape)
# Normalize to 1 using the air counts
ndata = tomopy.normalize_bg(ndata, air=5)
## slider(ndata)
# Set data collection angles as equally spaced between 0-180 degrees.
theta = tomopy.angles(ndata.shape[0])
rot_center = 960
print("Center of rotation: ", rot_center)
ndata = tomopy.minus_log(ndata)
# Reconstruct object using Gridrec algorithm.
rec = tomopy.recon(ndata, theta, center=rot_center, algorithm='gridrec')
# Mask each reconstructed slice with a circle.
rec = tomopy.circ_mask(rec, axis=0, ratio=0.95)
# Write data as stack of TIFs.
dxchange.write_tiff_stack(rec, fname='/local/dataraid/mark/rec/recon')
