def main():
## Input file
filein = sys.argv[1]
fileout = sys.argv[2]
if len( sys.argv ) == 4:
color = sys.argv[3]
else:
color = 'green'
print('\nInput:\n', filein)
print('\nOutput:\n', fileout)
## Read files
y = io.readImage( filein ).astype( np.float32 )
#y = proc.select_resol_square( y )
y[:] = ( y - np.min( y ) ) / ( np.max( y ) - np.min( y ) )
dis.plot( y )
## Plot
plot_histo( y.reshape(-1) , fileout , color )
def __init__( self , npix , angles , ctr=0.0 , bspline_degree = 3 , proj_support_y=4 ,
nsamples_y=2048 , radon_degree=0 , filt='ramp' , back='False', plot=False ):
## Compute regridding look-up-table and deapodizer
self.plot = plot
nang = len( angles )
angles = np.arange( nang )
angles = ( angles * 180.0 )/myfloat( nang )
if back is False:
rd = radon_degree
else:
rd = 0
lut = bfun.init_lut_bspline( nsamples_y , angles ,
bspline_degree ,
rd ,
proj_support_y )
if plot is True:
dis.plot( lut , 'Look-up-table' )
## Assign parameters
self.lut = lut.astype( myfloat )
self.angles = angles.astype( myfloat )
self.nang = nang
self.bspline_degree = bspline_degree
self.param_spline = np.array( [ lut.shape[1] , proj_support_y ] , dtype=myfloat )
self.filt = filt
self.radon_degree = radon_degree
def fbp( self , x ):
## Option DPC
if self.radon_degree == 0:
dpc = False
else:
dpc = True
## Filtering projection
x[:] = fil.filter_proj( x , ftype=self.filt , dpc=dpc )
if self.plot is True:
dis.plot( x , 'Filtered sinogram' )
## Backprojection
reco = gr.backproj( x.astype( myfloat ) , self.angles , self.lut , self.param_spline )
## Normalization
if dpc is True:
reco *= np.pi / ( 1.0 * self.nang )
else:
reco *= np.pi / ( 2.0 * self.nang )
return reco
def main():
print('\n')
print('#########################################################')
print('#########################################################')
print('### ###')
print('### ANALYTICAL RADON TRANSFORM OF ###')
print('### RADIALLY SYMMETRIC FUNCTIONS ###')
print('### ###')
print('#########################################################')
print('#########################################################')
print('\n')
## Get arguments
args = getArgs()
## Get input parameters
npix = args.npix
nang = args.nang
deg = args.degree
dpc = args.dpc
print('\nNumber of pixels: ', npix)
print('Number of views: ', nang)
print('Function degree: ', deg)
print('Option DPC: ', dpc)
## Create LUT for the radially symmetric functions
lut = create_lut(npix)
## Create Shepp-Logan phantom
phantom = create_phantom(npix, deg, lut)
## Write phantom
write_output_file(phantom, 'image', args)
## Plot phantom
if args.plot is True:
dis.plot(phantom, 'Radially symm. phantom npix=' + str(npix))
## Compute analitically radon transform of the phantom
if args.nang is not None:
print('\nCalculating analytical radon transform of the phantom ....')
sinogram = radon_transform_analytical(lut, npix, nang, deg, dpc)
if args.dpc is False:
sinogram[:, :] = sinogram[:, ::-1]
sinogram[:, :] = np.roll(sinogram, 1, axis=1)
## Write sinogram
write_output_file(sinogram, 'sinogram', args)
## Plot Shepp-Logan phantom
if args.plot is True:
dis.plot(
sinogram,
'Sinogram ' + str(nang) + ' nang X ' + str(npix) + ' npix')
print('\n\n')
def main():
x = io.readImage( sys.argv[1] )
M = int( sys.argv[2] )
dis.plot( x , 'Input image' )
N , p = x.shape
d = N;
angles = np.arange( M )/myfloat( M ) * 180.0
angles = np.fft.fftshift( angles )
A = paralleltomo( angles , N , p , d )
#dis.plot( A.todense() , 'Matrix A' )
sinogram = A.dot( x.reshape(-1) )
sinogram = sinogram.reshape( M , N )
dis.plot( sinogram , 'Output sinogram' )
io.writeImage( sys.argv[1][:len(sys.argv[1])-4] + 'sino_par_tomo.DMP' ,
sinogram )
def main():
sino = io.readImage(sys.argv[1])
ctr = np.float32(sys.argv[2])
dis.plot(sino, 'Input sinogram')
sino_new = proc.sino_correct_rot_axis(sino, ctr)
'''
nang , npix = sino.shape
sino_out = sino.copy()
x = np.arange( npix )
x_out = x - shift
for i in range( nang ):
s = InterpolatedUnivariateSpline( x , sino[i,:] )
sino_out[i,:] = s( x_out )
'''
dis.plot(sino_new, 'Output sinogram')
filename = sys.argv[1][:len(sys.argv[1]) - 4] + '_interp.DMP'
io.writeImage(filename, sino_new)
def main():
sino = io.readImage( sys.argv[1] )
ctr = np.float32( sys.argv[2] )
dis.plot( sino , 'Input sinogram' )
sino_new = proc.sino_correct_rot_axis( sino , ctr )
'''
nang , npix = sino.shape
sino_out = sino.copy()
x = np.arange( npix )
x_out = x - shift
for i in range( nang ):
s = InterpolatedUnivariateSpline( x , sino[i,:] )
sino_out[i,:] = s( x_out )
'''
dis.plot( sino_new , 'Output sinogram' )
filename = sys.argv[1][:len(sys.argv[1])-4] + '_interp.DMP'
io.writeImage( filename , sino_new )
def main():
## Initial print
print('\n')
print('#######################################')
print('############# PY-FBP #############')
print('#######################################')
print('\n')
## Get the startimg time of the reconstruction
startTime = time.time()
## Get input arguments
args = getArgs()
## Get path to input reco
pathin = args.pathin
## Get input reco
## You assume the reco to be square
sino_name = pathin + args.sino
sino = io.readImage(sino_name).astype(myfloat)
npix = sino.shape[1]
nang = sino.shape[0]
print('\nInput sino:\n', sino_name)
print('Number of projection angles: ', nang)
print('Number of pixels: ', npix)
## Show reco
if args.plot is True:
dis.plot(sino, 'Sinogram')
## Get projection geometry
if args.geometry == '0':
angles = np.arange(nang)
angles = (angles * 180.0) / myfloat(nang)
print('\nDealing with equally angularly spaced projections in [0,180)')
else:
geometryfile = pathin + args.geometry
angles = np.fromfile(geometryfile, sep="\t")
nang = len(angles)
print('\nReading list of projection angles: ', geometryfile)
print('Number of projection angles: ', nang)
print('\nAngles:\n', angles)
## Get center of rotation
print('\nCenter of rotation placed at pixel: ', args.ctr)
if args.ctr is None:
ctr = npix * 0.5 + 1
else:
ctr = args.ctr
sino = proc.sino_correct_rot_axis(sino, ctr)
ctr = npix * 0.5
## Enable edge padding
if args.edge_padding is True:
npix_old = sino.shape[1]
sino = proc.sino_edge_padding(sino, 0.5)
npix = sino.shape[1]
i1 = int((npix - npix_old) * 0.5)
i2 = i1 + npix_old
ctr += i1
## Get filter type
filt = args.filt
print('\nSelected filter: ', filt)
## Get B-Spline setting
bspline_degree = args.bspline_degree
nsamples_y = args.lut_size
proj_support_y = bspline_degree + 1
if args.dpc is False:
rt_degree = 0
else:
rt_degree = 1
print('\nB-Spline degree selected: ', bspline_degree)
print('LUT density: ', nsamples_y)
print('B-Spline support: ', proj_support_y)
print('Radon transform degree: ', rt_degree)
## Compute iradon transform
print('\nPerforming Filtered Backprojection ....\n')
reco = fbp_bspline(sino[:, ::-1], angles, filt, bspline_degree, rt_degree,
args.plot)
## Remove edge padding
if args.edge_padding is True:
reco = reco[i1:i2, i1:i2]
## Show sino
if args.plot is True:
dis.plot(reco, 'Reconstruction')
## Save sino
save_reco(reco, args)
## Time elapsed for the computation of the radon transform
endTime = time.time()
print('\n\nTime elapsed: ', (endTime - startTime) / 60.0)
print('\n')
def main():
## Initial print
print('\n')
print('#####################################')
print('#####################################')
print('#### ####')
print('#### RADON TRANSFORM BASED ON ####')
print('#### A CUBIC B-SPLINE BASIS ####')
print('#### ####')
print('#####################################')
print('#####################################')
print('\n')
## Get the startimg time of the sinonstruction
time1 = time.time()
## Get input arguments
args = getArgs()
## Get path to input sino
pathin = args.pathin
## Get input image
## You assume the image to be square
image_name = pathin + args.image
image = io.readImage( image_name ).astype( myfloat )
npix = image.shape[1]
nang = args.nang
print('\nInput image:\n', image_name)
print('Number of projection angles: ', nang)
print('Number of pixels: ', npix)
## Check plot
if args.plot is True:
dis.plot( image , 'Input image' )
## Get projection geometry
angles = np.arange( nang )
angles = ( angles * np.pi )/myfloat( nang )
print('\nDealing with equally angularly spaced projections in [0,180)')
## Create projector class
if args.dpc is False:
rd = 0
else:
rd = 1
deg = args.bspline_degree
sup = deg + 1
print('\nSelected B-spline degree: ', deg)
print('Selected Radon degree: ', rd )
tp = cpb.projectors( npix , angles , bspline_degree=deg , proj_support_y=sup ,
nsamples_y=2048 , radon_degree=rd , filt='ramp' ,
back = False , plot=True )
image[:] = image[::-1,::-1]
sino = tp.A( image )
## Show sino
if args.plot is True:
dis.plot( sino , 'Sinogram' )
## Save sino
save_sino( sino , angles , args )
## Time elapsed for the computation of the radon transform
time2 = time.time()
print('\n\nTime elapsed to run the radon: ', (time2-time1)/60.0,' min.')
print('Time elapsed to run the radon: ', time2-time1,' sec.')
print('\n')
def main():
## Initial print
print('\n')
print('#######################################')
print('############# PY-FBP #############')
print('#######################################')
print('\n')
## Get the startimg time of the reconstruction
startTime = time.time()
## Get input arguments
args = getArgs()
## Get path to input reco
pathin = args.pathin
## Get input reco
## You assume the reco to be square
sino_name = pathin + args.sino
sino = io.readImage(sino_name).astype(myfloat)
npix = sino.shape[1]
nang = sino.shape[0]
print('\nInput sino:\n', sino_name)
print('Number of projection angles: ', nang)
print('Number of pixels: ', npix)
if args.plot is True:
dis.plot(sino, 'Sinogram')
## Get projection geometry
## 1) Case of equiangular projections distributed in [0,180)
if args.geometry == '0':
angles = np.arange(nang)
angles = (angles * np.pi) / myfloat(nang)
print('\nDealing with equally angularly spaced projections in [0,180)')
## 2) Case of list of projection angles in degrees
else:
geometryfile = pathin + args.geometry
angles = np.fromfile(geometryfile, sep="\t")
angles *= np.pi / 180.0
nang = len(angles)
print('\nReading list of projection angles: ', geometryfile)
print('Number of projection angles: ', nang)
## DPC reconstruction
dpc = args.dpc
print('DPC reconstruction: ', dpc)
## DPC reconstruction
if args.dbp is True:
dpc = args.dbp
sino[:, :] = proc.diff_sino(sino)
if args.plot is True:
dis.plot(sino, 'Differential sinogram')
print('DBP reconstruction: ', dpc)
## Get center of rotation
print('\nCenter of rotation placed at pixel: ', args.ctr)
if args.ctr is None:
ctr = npix * 0.5
else:
ctr = args.ctr
sino = proc.sino_correct_rot_axis(sino, ctr)
ctr = npix * 0.5
## Enable edge padding
if args.edge_padding is True:
npix_old = sino.shape[1]
sino = proc.sino_edge_padding(sino, 0.5)
npix = sino.shape[1]
i1 = int((npix - npix_old) * 0.5)
i2 = i1 + npix_old
ctr += i1
## Get filter type
filt = args.filt
print('Selected filter: ', filt)
## Get interpolation scheme
interp = args.interp
if interp == 'nn':
print('\nSelected interpolation scheme: nearest neighbour')
elif interp == 'lin':
print('\nSelected interpolation scheme: linear interpolation')
## Compute iradon transform
print('\nPerforming Filtered Backprojection ....\n')
reco = np.zeros((npix, npix), dtype=myfloat)
reco[:, :] = iradon(sino[:, ::-1], npix, angles, ctr, filt, interp, dpc,
args)
## Remove edge padding
if args.edge_padding is True:
reco = reco[i1:i2, i1:i2]
## Show reconstruction
if args.plot is True:
dis.plot(reco, 'Reconstruction')
## Save sino
save_reco(reco, args)
## Time elapsed for the computation of the radon transform
endTime = time.time()
print('\n\nTime elapsed: ', (endTime - startTime) / 60.0)
print('\n')
def main():
## Initial print
print('\n')
print('#####################################')
print('#####################################')
print('#### ####')
print('#### RADON TRANSFORM BASED ON ####')
print('#### A CUBIC B-SPLINE BASIS ####')
print('#### ####')
print('#####################################')
print('#####################################')
print('\n')
## Get the startimg time of the sinonstruction
time1 = time.time()
## Get input arguments
args = getArgs()
## Get path to input sino
pathin = args.pathin
## Get input image
## You assume the image to be square
image_name = pathin + args.image
image = io.readImage(image_name).astype(myfloat)
npix = image.shape[1]
nang = args.nang
print('\nInput image:\n', image_name)
print('Number of projection angles: ', nang)
print('Number of pixels: ', npix)
## Check plot
if args.plot is True:
dis.plot(image, 'Input image')
## Get projection geometry
angles = np.arange(nang)
angles = (angles * np.pi) / myfloat(nang)
print('\nDealing with equally angularly spaced projections in [0,180)')
## Create projector class
if args.dpc is False:
rd = 0
else:
rd = 1
deg = args.bspline_degree
sup = deg + 1
print('\nSelected B-spline degree: ', deg)
print('Selected Radon degree: ', rd)
tp = cpb.projectors(npix,
angles,
bspline_degree=deg,
proj_support_y=sup,
nsamples_y=2048,
radon_degree=rd,
filt='ramp',
back=False,
plot=True)
image[:] = image[::-1, ::-1]
sino = tp.A(image)
## Show sino
if args.plot is True:
dis.plot(sino, 'Sinogram')
## Save sino
save_sino(sino, angles, args)
## Time elapsed for the computation of the radon transform
time2 = time.time()
print('\n\nTime elapsed to run the radon: ', (time2 - time1) / 60.0,
' min.')
print('Time elapsed to run the radon: ', time2 - time1, ' sec.')
print('\n')
def main():
print('\n')
print('#######################################')
print('#######################################')
print('### ###')
print('### STRUCTURAL SIMILARITY INDEX ###')
print('### ###')
print('#######################################')
print('#######################################')
print('\n')
## Get input arguments
args = getArgs()
## Get oracle image
currDir = os.getcwd()
image1 = io.readImage( args.image1 )
image1 = image1.astype( myfloat )
print('\nReading reference image:\n', args.image1)
print('Image shape: ', image1.shape)
image_list = []
results = []
## CASE OF SINGLE IMAGE TO ANALYZE
if args.image2 is not None:
if args.image2.find( ':' ) == -1:
image_list.append( args.image2 )
image2 = io.readImage( args.image2 ) # image2 --> image to analyze
image2 = image2.astype(myfloat)
num_img = 1
print('\nReading image to analyze:\n', args.image2)
print('Image shape: ', image2.shape)
## Get time in which the prgram starts to run
time1 = time.time()
## Scale image to analyze with respect to the reference one
if args.scaling is True:
print('\nPerforming linear regression ....')
image2 = proc.linear_regression( image1 , image2 )
## Register images
if args.register is True:
print('\nPerforming registration of the image to analize ....')
image2 = proc.image_registration( image2 , image1 , 'ssd' )
## Crop resolution circle of the images
if args.resol_circle is True:
print('\nSelecting the resolution circle')
image1 = proc.select_resol_square( image1 )
image2 = proc.select_resol_square( image2 )
## Crop images if enabled
if args.roi is not None:
roi = args.roi
if roi.find( ':' ) != -1:
roi = roi.split(',')
p0 = [int(roi[0].split(':')[1]),int(roi[0].split(':')[0])]
p1 = [int(roi[1].split(':')[1]),int(roi[1].split(':')[0])]
print('Cropping rectangular ROI with vertices: ( ', \
p0[0],' , ', p0[1], ') ( ', p1[0],' , ',p1[1], ')')
image1 = proc.crop_image( image1 , p0 , p1 )
image2 = proc.crop_image( image2 , p0 , p1 )
else:
print('\nUsing pixels specified in file:\n', roi)
pixels = np.loadtxt( roi )
pixels = pixels.astype( int )
p0 = np.array([pixels[0,0],pixels[0,1]])
p1 = np.array([pixels[len(pixels)-1,0],pixels[len(pixels)-1,1]])
print('Cropping rectangular ROI with vertices: ( ', \
p0[0],' , ', p0[1], ') ( ', p1[0],' , ',p1[1], ')')
image1 = proc.crop_image( image1 , p0 , p1 )
image2 = proc.crop_image( image2 , p0 , p1 )
## Compute the gradient of the images, if enabled
if args.gradient is True:
image1 = compute_gradient_image( image1 )
image2 = compute_gradient_image( image2 )
## Check whether the 2 images have the same shape
if image1.shape != image2.shape:
sys.error('\nERROR: The input images have different shapes!\n')
## Plot to check whether the images have the same orientation
if args.plot is True:
print('\nPlotting images to check orientation ....')
img_list = [ image1 , image2 ]
title_list = [ 'Oracle image' , 'Image to analyze' ]
dis.plot_multi( img_list , title_list , 'Check plot' )
## Get window size
window_size = args.window
print('\nSize of the computation window: ', window_size)
if window_size % 2 != 0:
window_size += 1
print('Window size is even: window size changed to ', window_size)
## Get sigma of the gaussian kernel
sigma = SIGMA
print('Sigma of the gaussian kernel: ', sigma)
## Calculate map of SSIM values
map_ssim , MSSIM = compute_map_ssim( image1 , image2 , window_size , sigma )
results.append( MSSIM )
if args.plot is True:
print('\nPlotting images + map of ssim ....')
img_list = [ image1 , image2 , map_ssim ]
title_list = [ 'Oracle image' , 'Image to analyze' , 'Map of SSIM' ]
dis.plot_multi( img_list , title_list , 'Images and map of SSIM' , colorbar=True )
## Save SSIM map
filename = args.image2[:len(args.image2)-4] + '_ssim_map.png'
io.writeImage( filename , map_ssim )
## CASE OF MULTIPLE SPECIFIC IMAGES
else:
image_list = args.image2.split(':')
img_list = [ ]
title_list = [ ]
num_img = len( image_list )
for im in range( num_img ):
img_file = image_list[im]
image1 = io.readImage( args.image1 )
image2 = io.readImage( img_file ) # image2 --> image to analyze
image2 = image2.astype(myfloat)
print('\nReading image to analyze:\n', args.image2)
print('Image shape: ', image2.shape)
## Get time in which the prgram starts to run
time1 = time.time()
## Scale image to analyze with respect to the reference one
if args.scaling is True:
print('\nPerforming linear regression ....')
image2 = proc.linear_regression( image1 , image2 )
## Register images
if args.register is True:
print('\nPerforming registration of the image to analize ....')
image2 = proc.image_registration( image2 , image1 , 'ssd' )
## Crop resolution circle of the images
if args.resol_circle is True:
print('\nSelecting the resolution circle')
image1 = proc.select_resol_square( image1 )
image2 = proc.select_resol_square( image2 )
## Crop images if enabled
if args.roi is not None:
roi = args.roi
if args.roi.find(',') != -1:
roi = roi.split(',')
p0 = [int(roi[0].split(':')[1]),int(roi[0].split(':')[0])]
p1 = [int(roi[1].split(':')[1]),int(roi[1].split(':')[0])]
print('Cropping rectangular ROI with vertices: ( ', \
p0[0],' , ', p0[1], ') ( ', p1[0],' , ',p1[1], ')')
image1 = proc.crop_image( image1 , p0 , p1 )
image2 = proc.crop_image( image2 , p0 , p1 )
else:
print('\nUsing pixels specified in file:\n', roi)
pixels = np.loadtxt( roi )
pixels = pixels.astype( int )
p0 = np.array([pixels[0,0],pixels[0,1]])
p1 = np.array([pixels[len(pixels)-1,0],pixels[len(pixels)-1,1]])
print('Cropping rectangular ROI with vertices: ( ', \
p0[0],' , ', p0[1], ') ( ', p1[0],' , ',p1[1], ')')
image1 = proc.crop_image( image1 , p0 , p1 )
image2 = proc.crop_image( image2 , p0 , p1 )
## Compute the gradient of the images, if enabled
if args.gradient is True:
image1 = compute_gradient_image( image1 )
image2 = compute_gradient_image( image2 )
## Check whether the 2 images have the same shape
if image1.shape != image2.shape:
sys.exit('\nERROR: The input images have different shapes!\n')
## Plot to check whether the images have the same orientation
if args.plot is True:
print('\nPlotting images to check orientation ....')
img_list2 = [ image1 , image2 ]
title_list2 = [ 'Oracle image' , 'Image to analyze' ]
dis.plot_multi( img_list2 , title_list2 , 'Check plot' )
## Get window size
window_size = args.window
print('\nSize of the computation window: ', window_size)
if window_size % 2 != 0:
window_size += 1
print('Window size is even: window size changed to ', window_size)
## Get sigma of the gaussian kernel
sigma = SIGMA
print('Sigma of the gaussian kernel: ', sigma)
## Calculate map of SSIM values
map_ssim , MSSIM = compute_map_ssim( image1 , image2 , window_size , sigma )
results.append( MSSIM )
map_ssim[ map_ssim < 0 ] = 0.0
if args.plot is True:
img_list.append( map_ssim )
title_list.append( 'SSIM map n.' + str( im + 1 ) )
## Save SSIM map
filename = img_file[:len(img_file)-4] + '_ssim_map.png'
io.writeImage( filename , map_ssim )
if args.plot is True:
print('\nPlotting images + map of ssim ....')
dis.plot( img_list[0] )
dis.plot( img_list[1] )
dis.plot_multi_colorbar( img_list , title_list , 'Maps of SSIM' )
## CASE OF BUNCH OF IMAGES TO ANALYZE
else:
os.chdir(args.path)
image_list = sorted( glob.glob('*') )
num_images = len( image_list )
img_list.append( image1 )
title_list.append('Oracle image')
## Get time in which the prgram starts to run
time1 = time.time()
## Loop on all the images to analyze
for i in range( num_img ):
image1 = io.readImage( args.image1 )
image2 = io.readImage( image_list[i] )
image2 = image2.astype(myfloat)
print('\n\n\nIMAGE TO ANALYZE NUMBER: ', i)
print('\nReading image to analyze:\n', fileIn[i])
print('Image shape: ', image2.shape)
## Scale image to analyze with respect to the reference one
if args.scaling is True:
print('\nPerforming linear regression ....')
image2 = proc.linear_regression( image1 , image2 )
## Register images
if args.register is True:
print('\nPerforming registration of the image to analize ....')
image2 = proc.image_registration( image2 , image1 , 'ssd' )
## Crop resolution circle of the images
if args.resol_circle is True:
print('\nSelecting the resolution circle')
image1 = proc.select_resol_square( image1 )
image2 = proc.select_resol_square( image2 )
## Crop images if enabled
if args.roi is not None:
roi = args.roi
if args.roi.find(',') != -1:
roi = roi.split(',')
p0 = [int(roi[0].split(':')[1]),int(roi[0].split(':')[0])]
p1 = [int(roi[1].split(':')[1]),int(roi[1].split(':')[0])]
print('Cropping rectangular ROI with vertices: ( ', \
p0[0],' , ', p0[1], ') ( ', p1[0],' , ',p1[1], ')')
image1 = proc.crop_image( image1 , p0 , p1 )
image2 = proc.crop_image( image2 , p0 , p1 )
else:
print('\nUsing pixels specified in file:\n', roi)
pixels = np.loadtxt( roi )
pixels = pixels.astype( int )
p0 = np.array([pixels[0,0],pixels[0,1]])
p1 = np.array([pixels[len(pixels)-1,0],pixels[len(pixels)-1,1]])
print('Cropping rectangular ROI with vertices: ( ', \
p0[0],' , ', p0[1], ') ( ', p1[0],' , ',p1[1], ')')
image1 = proc.crop_image( image1 , p0 , p1 )
image2 = proc.crop_image( image2 , p0 , p1 )
## Compute the gradient of the images, if enabled
if args.gradient is True:
image1 = compute_gradient_image( image1 )
image2 = compute_gradient_image( image2 )
## Check whether the 2 images have the same shape
if image1.shape != image2.shape and args.roi is None:
sys.error('\nERROR: The input images have different shapes!\n')
## Plot to check whether the images have the same orientation
if args.plot is True:
print('\nPlotting images to check orientation ....')
img_list = [ image1 , image2 ]
title_list = [ 'Oracle image' , 'Image to analyze' ]
dis.plot_multi( img_list , title_list , 'Check plot' )
## Get window size
window_size = args.window
print('\nSize of the computation window: ', window_size)
if window_size % 2 != 0:
window_size += 1
print('Window size is even: window size changed to ', window_size)
## Get sigma of the gaussian kernel
sigma = SIGMA
print('Sigma of the gaussian kernel: ', sigma)
## Calculate map of SSIM values
map_ssim,MSSIM = compute_map_ssim( image1 , image2 , window_size , sigma )
results.append( MSSIM )
## Diplay map of SSIM
if args.plot is True:
fig = plt.figure()
plt.title('Map of SSIM indeces')
plt.imshow(map_ssim,cmap = cm.Greys_r)
plt.colorbar()
plt.show()
## Save SSIM map
filename = image_list[i][:len(image_list[i])-4] + '_ssim_map.png'
io.writeImage( filename , map_ssim )
os.chdir(currDir)
## Summary print of the results
print('\n\nSUMMARY OF THE RESULTS:\n')
print('\nReference image:\n', args.image1)
for i in range( num_img ):
print('\nTest image number ', i,'\n', image_list[i])
print('SSIM = ' , results[i])
## Get time elapsed for the run of the program
time2 = time.time() - time1
print('\n\nTime elapsed for the calculation: ', time2)
## Write log file
write_log_file( args , image_list , results )
print('\n\n')
def iradon(sino, npix, angles, ctr, filt, interp, dpc, args):
## Get number of angles
nang = len(angles)
## Pre-calculate sin and cos values
cos = np.cos(angles)
sin = np.sin(angles)
## Create grid of coordinates for the reconstruction
x = np.arange(-(npix * 0.5 - 1), npix * 0.5 + 1)
x = np.kron(np.ones((npix, 1)), x)
y = np.rot90(x)
## Filter projections
if filt is not None:
sino[:] = fil.filter_proj(sino, ftype=filt, dpc=dpc)
if args.plot is True:
dis.plot(sino, 'Filtered sinogram')
## Zero-pad projections to fit with the dimension of the
## reoconstructing grid diagonal
img_diag = 2 * int(np.ceil(npix / np.sqrt(2))) + 1
if npix < img_diag:
pad = 0.5 * (img_diag - npix)
i1 = int(np.ceil(pad))
i2 = npix + int(np.floor(pad))
sino_op = np.zeros((nang, i1 + i2), dtype=myfloat)
sino_op[:, i1:i1 + npix] = sino[:, :]
ctr += i1
else:
sino_op = np.zeros((nang, npix), dtype=myfloat)
sino_op[:, :] = sino[:, :]
ctr = int(ctr)
## Allocate memory for the reconstruction
reco = np.zeros((npix, npix), dtype=myfloat)
## Enable movie
if args.movie is True:
py.ion()
im = py.imshow(x, animated=True, cmap=cm.Greys_r)
folder = 'fbp_movie/'
if not os.path.exists(folder):
os.makedirs(folder)
else:
import shutil
shutil.rmtree(folder)
os.makedirs(folder)
## Filtered Backprojection
if interp == 'spl':
points = np.arange(i1 + i2) - ctr + 1
for i in range(nang):
sys.stdout.write('Backprojecting projection number %d\r' % (i + 1, ))
sys.stdout.flush()
t = x * cos[i] + y * sin[i]
if interp == 'nn':
t = np.round(t).astype(int)
reco += sino_op[i, t + ctr - 1]
elif interp == 'lin':
a = np.floor(t).astype(int)
reco += ( t - a ) * sino_op[ i , a + ctr ] + \
( a + 1 - t ) * sino_op[ i , a + ctr - 1 ]
if args.movie is True:
py.imshow(reco[::-1, :], animated=True, cmap=cm.Greys_r)
py.draw()
if i < 10:
num_proj = '000' + str(i)
elif i < 100:
num_proj = '00' + str(i)
elif i < 1000:
num_proj = '0' + str(i)
else:
num_proj = str(i)
sci.misc.imsave(folder + 'reco_' + num_proj + '.jpg',
reco[::-1, :])
if dpc is False:
reco *= np.pi / (2.0 * nang)
else:
reco *= np.pi / (1.0 * nang)
return reco
def main():
## Initial print
print('\n')
print('########################################################')
print('############# SKIMAGE RADON TRANSFORM #############')
print('########################################################')
print('\n')
## Get the startimg time of the sinonstruction
startTime = time.time()
## Get input arguments
args = getArgs()
## Get path to input sino
pathin = args.pathin
## Get input image
## You assume the image to be square
image_name = pathin + args.image
image = io.readImage(image_name)
npix = image.shape[1]
nang = args.nang
print('\nInput image:\n', image_name)
print('Number of projection angles: ', nang)
print('Number of pixels: ', npix)
## Check plot
if args.plot is True:
dis.plot(image, 'Input image')
## Get projection geometry
## 1) Case of equiangular projections distributed in [0,180)
if args.geometry == '0':
angles = np.arange(nang)
angles = (angles * 180.0) / myFloat(nang)
print('\nDealing with equally angularly spaced projections in [0,180)')
## 2) Case of equally sloped projections distributed in [0,180)
elif args.geometry == '1':
print('\n\nDealing with equally-sloped projections in [0,180)')
if nang % 4 != 0:
print('\n\nERROR: in case of equally-sloped projections',
' the number of angles has to be a multiple of 4')
angles = createPseudoPolarAngles(nang) * 180.0 / np.pi
## 3) Case of list of projection angles in degrees
else:
geometryfile = pathin + args.geometry
angles = np.fromfile(geometryfile, sep="\t")
nang = len(angles)
print('\nReading list of projection angles: ', geometryfile)
## Get interpolation scheme
interp = args.interp
if interp == 'nn':
print('\nSelected interpolation scheme: nearest neighbour')
elif interp == 'lin':
print('\nSelected interpolation scheme: linear interpolation')
else:
print('''\nWARNING: ', interp,' does not correspond to any available
interpolation scheme; nearest neighbour interpolation will
be adopted''')
interp = 'lin'
## Center of rotation axis
ctr = 0.5 * npix
## Enable zero-padding
if args.padding is True:
npix_old = npix
image = proc.zeroPaddingImg(image, 2)
npix = image.shape[0]
dis.plot(image, 'Image zero-padded')
## Compute iradon transform
print('\nPerforming Skimage Radon Transform ....\n')
sino = radon(image[:, ::-1], npix, angles, ctr, interp)
## Rotate sinogram
sino = np.rot90(sino)
## Remove edge_padding
if args.padding is True:
i1 = int((npix - npix_old) * 0.5)
i2 = i1 + npix_old
sino = sino[:, i1:i2]
## Show sino
if args.plot is True:
dis.plot(sino, 'Sinogram')
## Save sino
saveSino(sino, angles, args)
## Time elapsed for the computation of the radon transform
endTime = time.time()
print('\n\nTime elapsed: ', (endTime - startTime) / 60.0)
print('\n')
def main():
print('\n')
print('#############################################')
print('############ SPECTRUM ANALYSIS ############')
print('#############################################')
print('\n')
## Get input arguments
args = getArgs()
## Get number of pair of images
image_string = args.images
file_list = []
if image_string.find(':') != -1:
file_list = image_string.split(':')
num_img = len( file_list )
else:
file_list.append( image_string )
num_img = 1
print('Number of images to analyze: ', num_img)
print(file_list)
## Read input images and display them as check
images = []
for i in range(num_img):
image_name = file_list[i]
print('Reading image: ', image_name)
if args.resol_square :
print('Calculation enabled in the resol square')
images.append( proc.selectResolutionSquare( io.readImage( image_name ) ) )
else:
print('Calculation enabled on the whole image square')
images.append( io.readImage( image_name ) )
## Check plot
if args.plot is True:
dis.plot( images[i] , 'Input image ' + str( i ) )
'''
images.append( np.arange( 64 ).reshape( 8 , 8 ) )
images.append( np.arange( 64 ).reshape( 8 , 8 ) )
print( '\n\nInput images:\n', images[0] )
'''
## Get labels for plots
labels = None
if args.labels is not(None):
labels = args.labels
labels = labels.split(':')
if ( len(labels) ) != num_img:
sys.exit('\nERROR: Number of labels is not half number of input images!\n')
## Fourier ring correlation analysis
spectrum_curves = []
label_curves = []
resol_point_list = []
for i in range(num_img):
if args.labels is None:
label_curves.append('Spectrum image ' + str( i ) )
label = 'Spectrum analysis image ' + str( i )
else:
label_curves.append(labels[i])
label = 'Spectrum analysis image ' + labels[i]
print('\nCalculating ring-spectrum of image:\n', file_list[i])
spectrum , spatial_freq = analysis_spectrum( images[i] , args , i ,
'image '+ str(i) , label )
spectrum_curves.append( spectrum )
spectrum_curves = np.array( spectrum_curves ).reshape( num_img , len( spatial_freq ) )
## Plot FRC curves
title = 'Spectrum - comparison'
plot_name = 'spectrum_comparison_curves'
point = None
style = 'lines'
plot_spectrum_curves( spectrum_curves, spatial_freq, args, label_curves, title,
point, style )
## Write log file
if args.fileout is not None:
fileout = args.fileout
fout = open(fileout,'w')
print('Writing data in ',fileout,' ....')
today = datetime.datetime.now()
fout.write('######## SPECTRUM RESOLUTION ANALYSIS ########\n')
fout.write('Calculation performed on the ' + str(today))
fout.write('\nResults of images inside:\n '+str(path))
if args.resol_square :
fout.write('\nCalculation enabled in the resol square')
else:
fout.write('\nCalculation enabled on the whole image square')
fout.write('\nCalculation enabled on the whole image square')
for im in range( num_img ):
fout.write('\n\nSpectrum analysis performed for:\n')
fout.write( file_list[i] )
fout.write( file_list[i] )
if args.pixsize is None:
fout.write('Resolution = ' + str(resol_point_list[im] )+' (pixels)\n\n')
else:
fout.write('Resolution = ' + str( resol_point_list[im] )+' micro_meters\n\n')
fout.write('\n########## SPECTRUM ANALYSIS END ##########\n')
fout.close()
print('\n########## SPECTRUM ANALYSIS END ##########\n')
def main():
## Initial print
print('\n')
print('########################################################')
print('############# EQUALLY SLOPED TOMOGRAPHY #############')
print('########################################################')
print('\n')
## Get the startimg time of the reconstruction
time1 = time.time()
## Get input arguments
args = getArgs()
## Get input directory
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
if os.path.exists( pathin ) is False:
sys.exit('\nERROR: input directory ', pathin,' does not exist!')
print('\nInput directory:\n', pathin)
## Get input sinogram
sinofile = pathin + args.sino
sino = io.readImage( sinofile )
nang, npix = sino.shape
print('\nSinogram to reconstruct:\n', sinofile)
print('Number of projection angles: ', nang)
print('Number of pixels: ', npix)
## Display sinogram
if args.plot is True:
dis.plot( sino , 'Input sinogram' )
## Getting projection geometry
## Case of equiangular projections distributed in [0,180)
if args.geometry == '0':
print('\nDealing with equiangular views distributed in [0,180)')
angles = np.arange( nang ).astype( myfloat )
angles[:] = ( angles * 180.0 )/myfloat( nang )
## Case of pseudo polar views
elif args.geometry == '1':
print('\nDealing with equally sloped views in [0,180)')
angles , dump1 , dum2 = create_est_views( nang )
angles *= 180.0 / np.pi
## Case of list of projection angles in degrees
else:
geometryfile = pathin + args.geometry
print('\nReading list of projection angles: ', geometryfile)
angles = np.fromfile( geometryfile , sep="\t" )
print('\nProjection angles:\n', angles)
## Set center of rotation axis
if args.ctr == None:
ctr = 0.0
print('\nCenter of rotation axis placed at pixel: ', npix * 0.5)
elif args.ctr == -1:
ctr = proc.searchCtrRot( sino , None , 'a' )
print('\nCenter of rotation axis placed at pixel: ', ctr)
sino = proc.sinoRotAxisCorrect( sino , ctr )
else:
ctr = args.ctr
print('\nCenter of rotation axis placed at pixel: ', ctr)
sino = proc.sinoRotAxisCorrect( sino , ctr )
## Get inverse procedure
if args.reco_proc == 1:
proc = args.reco_proc
print('\nSelected inverse procedure: PCG-IPPFT')
elif args.reco_proc == 2:
proc = args.reco_proc
print('\nSelected inverse procedure: iterative procedure with constraints')
## Reconstruction with EQUALLY SLOPED TOMOGRAPHY
print('\nPerforming EST reconstruction ....')
time_rec1 = time.time()
reco = est_tomo( sino , angles , proc )
time_rec2 = time.time()
print('\n.... reconstruction done!')
## Display reconstruction
dis.plot( reco , 'Reconstruction' )
## Save reconstruction
saveReco( reco , pathin , args )
## Time elapsed for the reconstruction
time2 = time.time()
print('\nTime elapsed for the back-projection: ', time_rec2-time_rec1 )
print('Total time elapsed: ', time2-time1 )
print('\n')
print('##############################################')
print('#### EQUALLY SLOPED TOMOGRAPHY DONE ! ####')
print('##############################################')
print('\n')
def main():
## Initial print
print('\n')
print('########################################################')
print('############# SKIMAGE RADON TRANSFORM #############')
print('########################################################')
print('\n')
## Get the startimg time of the sinonstruction
startTime = time.time()
## Get input arguments
args = getArgs()
## Get path to input sino
pathin = args.pathin
## Get input image
## You assume the image to be square
image_name = pathin + args.image
image = io.readImage( image_name )
npix = image.shape[1]
nang = args.nang
print('\nInput image:\n', image_name)
print('Number of projection angles: ', nang)
print('Number of pixels: ', npix)
## Check plot
if args.plot is True:
dis.plot( image , 'Input image' )
## Get projection geometry
## 1) Case of equiangular projections distributed in [0,180)
if args.geometry == '0':
angles = np.arange( nang )
angles = ( angles * 180.0 )/myFloat( nang )
print('\nDealing with equally angularly spaced projections in [0,180)')
## 2) Case of equally sloped projections distributed in [0,180)
elif args.geometry == '1':
print('\n\nDealing with equally-sloped projections in [0,180)')
if nang % 4 != 0:
print('\n\nERROR: in case of equally-sloped projections',
' the number of angles has to be a multiple of 4')
angles = createPseudoPolarAngles( nang ) * 180.0 / np.pi
## 3) Case of list of projection angles in degrees
else:
geometryfile = pathin + args.geometry
angles = np.fromfile( geometryfile , sep="\t" )
nang = len( angles )
print('\nReading list of projection angles: ', geometryfile)
## Get interpolation scheme
interp = args.interp
if interp == 'nn':
print('\nSelected interpolation scheme: nearest neighbour')
elif interp == 'lin':
print('\nSelected interpolation scheme: linear interpolation')
else:
print('''\nWARNING: ', interp,' does not correspond to any available
interpolation scheme; nearest neighbour interpolation will
be adopted''')
interp = 'lin'
## Center of rotation axis
ctr = 0.5 * npix
## Enable zero-padding
if args.padding is True:
npix_old = npix
image = proc.zeroPaddingImg( image , 2 )
npix = image.shape[0]
dis.plot( image , 'Image zero-padded' )
## Compute iradon transform
print('\nPerforming Skimage Radon Transform ....\n')
sino = radon( image[:,::-1] , npix , angles , ctr , interp )
## Rotate sinogram
sino = np.rot90( sino )
## Remove edge_padding
if args.padding is True:
i1 = int( ( npix - npix_old ) * 0.5 )
i2 = i1 + npix_old
sino = sino[:,i1:i2]
## Show sino
if args.plot is True:
dis.plot( sino , 'Sinogram' )
## Save sino
saveSino( sino , angles , args )
## Time elapsed for the computation of the radon transform
endTime = time.time()
print('\n\nTime elapsed: ', (endTime-startTime)/60.0)
print('\n')
def main():
## Initial print
print("\n")
print("##########################################################")
print("############# HIERARCHICAL BACKPROJECTION #############")
print("##########################################################")
print("\n")
## Get the startimg time of the reconstruction
time1 = time.time()
## Get input arguments
args = getArgs()
## Get input directory
pathin = args.pathin
if pathin[len(pathin) - 1] != "/":
pathin += "/"
if os.path.exists(pathin) is False:
sys.exit("\nERROR: input directory ", pathin, " does not exist!")
print("\nInput directory:\n", pathin)
## Get input sinogram
sinofile = pathin + args.sino
sino = io.readImage(sinofile)
nang, npix = sino.shape
print("\nSinogram to reconstruct:\n", sinofile)
print("Number of projection angles: ", nang)
print("Number of pixels: ", npix)
## Display sinogram
if args.plot is True:
dis.plot(sino, "Input sinogram")
## Getting projection geometry
if args.geometry == "0":
print("\nDealing with equiangular projections distributed between 0 and" + " 180 degrees ---> [0,180)")
angles = np.arange(nang).astype(myfloat)
angles[:] = (angles * 180.0) / myfloat(nang)
else:
geometryfile = pathin + args.geometry
print("\nReading list of projection angles: ", geometryfile)
angles = np.fromfile(geometryfile, sep="\t")
if args.plot is True:
print("\nProjection angles:\n", angles)
## Enable edge padding
if args.edge_pad is True:
sino = proc.edgePadding(sino, 0.5)
i1 = int((sino.shape[1] - npix) * 0.5)
i2 = i1 + npix
npix = sino.shape[1]
if args.plot is True:
dis.plot(sino, "Edge padded sinogram")
## Set center of rotation axis
if args.ctr == -1:
ctr = proc.searchCtrRot(sino, None, "a")
elif args.ctr == 0:
ctr = 0.5 * npix
else:
ctr = args.ctr
sino[:, :] = proc.sinoRotAxisCorrect(sino, ctr)
print("Center of rotation axis placed at pixel: ", ctr)
print("Center of rotation correction done! ")
if args.edge_pad is True and ctr != 0.0:
ctr += i1
## External sinogram filtering
filt = args.filt
if filt not in filt_list:
print(
"\nERROR: filter named: ', filt,' does not exist!\n \
Use one of the following available filters:\n \
'none' , 'ramp' , 'shlo' , 'hann' , 'hamm' , \n \
'parz' , 'lancz' "
)
print("\nSelected filter: ", filt)
if filt == "none":
filter_name = "none"
elif filt == "ramp":
filter_name = "ramp"
elif filt == "hann":
filter_name = "hanning"
elif filt == "hamm":
filter_name = "hamming"
sino = fil.filter_fft(sino, filter_name, 0)
sino *= 4.0 / myfloat(npix)
if args.plot is True:
dis.plot(sino, "Filtered sinogram")
## Set number of pixels of the reconstructed image
if args.npix_im is None:
npix_im = npix
else:
npix_im = args.npix_im
if args.base_size == 0:
base_size = npix
else:
base_size = args.base_size
if args.down_size == 0:
down_size = npix
else:
down_size = args.down_size
## Set parameters
print("\nFHBP parameter setting:")
print("Number image pixels: ", npix_im)
print("Base size: ", base_size)
print("Downsampling size: ", down_size)
print("Ratio sinogram / image sampling: ", args.sampl_ratio)
param = np.array([npix_im, base_size, down_size, args.sampl_ratio])
## Reconstruction with regridding method
time_rec1 = time.time()
reco = fhbp.backproj(sino.astype(myfloat), angles.astype(myfloat), param.astype(myfloat))
time_rec2 = time.time()
## Crop reconstruction
if args.edge_pad:
reco = reco[i1:i2, i1:i2]
## Rotate and flip reconstruction
reco[:, :] = reco[:, ::-1]
## Display reconstruction
if args.plot is True:
dis.plot(reco, "Reconstruction")
## Save reconstruction
write_reconstruction(reco, pathin, args)
## Time elapsed and memory usage for the reconstruction
time2 = time.time()
print("\nTime elapsed for the back-projection: ", time_rec2 - time_rec1, " s")
print("Total time elapsed: ", time2 - time1, " s")
print("\n")
print("########################################")
print("#### FHBP BACKPROJECTION DONE ! ####")
print("########################################")
print("\n")
def main():
print('\n')
print('#########################################################')
print('#########################################################')
print('### ###')
print('### ANALYTICAL RADON TRANSFORM OF SHEPP-LOGAN ###')
print('### ###')
print('#########################################################')
print('#########################################################')
print('\n')
## Get arguments
args = getArgs()
## Get number of pixels
npix = args.npix
nang = args.nang
print('\nNumber of pixels: ', npix)
print('Number of views: ', nang)
## Create look-up-table of Shepp-Logan ellipses or read specifics from file
if args.filein is None:
LUT = lut_shepp_logan(npix, nang)
print('\nCreated LUT for Shepp-Logan phantom')
else:
lut_file = np.loadtxt(args.filein)
LUT = lut_generic_phantom(lut_file, npix, nang)
if args.filein.find('/') == -1:
name = args.filein.split('.')[0]
else:
tokens = args.filein.split('/')
name = tokens[len(tokens) - 1].split('.')[0]
print('\nReading LUT for phantom from file:\n', args.filein)
print('Label selected for the putput files: ', name)
## Create Shepp-Logan phantom
phantom = create_phantom(LUT, npix)
## Write phantom
path = args.path
if path[len(path) - 1] != '/':
path += '/'
if args.filein is None:
filename = path + 'shepp_logan_pix'
else:
filename = path + name + '_pix'
if npix < 10:
common = '000' + str(npix)
elif npix < 100:
common = '00' + str(npix)
elif npix < 1000:
common = '0' + str(npix)
else:
common = str(npix)
filename += common + args.file_format
io.writeImage(filename, phantom)
print('\nWriting sinogram in:\n', filename)
## Plot phantom
if args.plot is True:
dis.plot(phantom, 'Shepp-Logan phantom npix=' + str(npix))
## Compute analitically radon transform of the phantom
if args.nang is not None:
print('\nCalculating analytical radon transform of the phantom ....')
sinogram = radon_transform_analytical(phantom, LUT, npix, nang)
sinogram[:, :] = sinogram[:, ::-1]
sinogram[:, :] = np.roll(sinogram, 1, axis=1)
## Plot Shepp-Logan phantom
if args.plot is True:
dis.plot(
sinogram,
'Sinogram ' + str(nang) + ' nang X ' + str(npix) + ' npix')
## Write sinogram
if args.filein is None:
filename = path + 'shepp_logan_pix' + common + '_ang'
else:
filename = path + name + '_pix' + common + '_ang'
if nang < 10:
filename += '000' + str(nang) + '_rt_anal_sino' + '.DMP'
elif nang < 100:
filename += '00' + str(nang) + '_rt_anal_sino' + '.DMP'
elif nang < 1000:
filename += '0' + str(nang) + '_rt_anal_sino' + '.DMP'
else:
filename += str(nang) + '_rt_anal_sino' + args.file_format
io.writeImage(filename, sinogram)
print('\nWriting sinogram in:\n', filename)
print('\n\n')
def main():
print('\n')
print('#########################################################')
print('#########################################################')
print('### ###')
print('### ANALYTICAL RADON TRANSFORM OF ###')
print('### RADIALLY SYMMETRIC FUNCTIONS ###')
print('### ###')
print('#########################################################')
print('#########################################################')
print('\n')
## Get arguments
args = getArgs()
## Get input parameters
npix = args.npix
nang = args.nang
deg = args.degree
dpc = args.dpc
print('\nNumber of pixels: ', npix)
print('Number of views: ', nang)
print('Function degree: ', deg)
print('Option DPC: ', dpc)
## Create LUT for the radially symmetric functions
lut = create_lut( npix )
## Create Shepp-Logan phantom
phantom = create_phantom( npix , deg , lut )
## Write phantom
write_output_file( phantom , 'image' , args )
## Plot phantom
if args.plot is True:
dis.plot( phantom , 'Radially symm. phantom npix=' + str( npix ) )
## Compute analitically radon transform of the phantom
if args.nang is not None:
print('\nCalculating analytical radon transform of the phantom ....')
sinogram = radon_transform_analytical( lut , npix , nang , deg , dpc )
if args.dpc is False:
sinogram[:,:] = sinogram[:,::-1]
sinogram[:,:] = np.roll( sinogram , 1 , axis=1 )
## Write sinogram
write_output_file( sinogram , 'sinogram' , args )
## Plot Shepp-Logan phantom
if args.plot is True:
dis.plot( sinogram , 'Sinogram ' + str( nang ) + ' nang X ' + str( npix ) + ' npix' )
print('\n\n')
def main():
## Initial print
print('\n')
print('##############################################################')
print('############# KAISER-BESSEL RADON TRANSFORM #############')
print('##############################################################')
print('\n')
## Get the startimg time of the sinonstruction
startTime = time.time()
## Get input arguments
args = getArgs()
## Get path to input sino
pathin = args.pathin
## Get input image
## You assume the image to be square
image_name = pathin + args.image
image = io.readImage( image_name )
npix = image.shape[1]
nang = args.nang
print('\nInput image:\n', image_name)
print('Number of projection angles: ', nang)
print('Number of pixels: ', npix)
## Check plot
if args.plot is True:
dis.plot( image , 'Input image' )
## Get projection geometry
## 1) Case of equiangular projections distributed in [0,180)
if args.geometry == '0':
angles = np.arange( nang )
angles = ( angles * np.pi )/myFloat( nang )
print('\nDealing with equally angularly spaced projections in [0,180)')
## 2) Case of equally sloped projections distributed in [0,180)
elif args.geometry == '1':
print('\n\nDealing with equally-sloped projections in [0,180)')
if nang % 4 != 0:
print('\n\nERROR: in case of equally-sloped projections',
' the number of angles has to be a multiple of 4')
angles = createPseudoPolarAngles( nang )
## 3) Case of list of projection angles in degrees
else:
geometryfile = pathin + args.geometry
angles = np.fromfile( geometryfile , sep="\t" )
nang = len( angles )
angles = np.pi * angles / 180.0
print('\nReading list of projection angles: ', geometryfile)
## Get kaiser-bessel parameters
kb_radius = args.kb_radius
proj_support_y = 2.0 * kb_radius
kb_degree = args.kb_degree
print('\nKaiser-Bessel radius selected: ', kb_radius)
print('\nKaiser-Bessel degree selected: ', kb_degree)
## Flag to specify whether you want to perform the
## radon transform or its adjoint
flag_adj = 0
## Direct transformation on the pixel image into
## ita B-spline image
#kb_image = pixel_basis_to_kaiser_bessel( image , 0 )
kb_image = image.copy()
## Precalculate look-up-table for B-spline
nsamples_y = args.lut_size
LUT = init_lut_kaiser_bessel( nsamples_y , nang , kb_radius , kb_radius )
if args.plot is True:
dis.plot( LUT , 'Look-up-table' )
## Perform B-spline radon transform
LUT = LUT.astype( np.float32 )
angles = angles.astype( np.float32 )
sino = np.zeros( ( nang , npix ) , dtype=np.float32 )
exit = grt.radon( sino , kb_image , flag_adj , LUT , LUT.shape[1] ,
npix , angles , nang , proj_support_y )
sino[:,:] = np.roll( sino[:,::-1] , 1 , axis=1 )
## Convert sinogram from kaiser-bessel basis to the pixel one
#sino = kaiser_bessel_basis_to_pixel( sino , kb_radius )
## Show sino
if args.plot is True:
dis.plot( sino , 'Sinogram' )
## Save sino
saveSino( sino , angles , args )
## Time elapsed for the computation of the radon transform
endTime = time.time()
print('\n\nTime elapsed: ', (endTime-startTime)/60.0)
print('\n')
def main():
## Initial print
print('\n')
print('############################################################')
print('############# FORWARD HIERACHICAL PROJECTOR #############')
print('############################################################')
print('\n')
## Get the startimg time of the reconstruction
time1 = time.time()
## Get input arguments
args = getArgs()
## Get input directory
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
if os.path.exists( pathin ) is False:
sys.exit('\nERROR: input directory ', pathin,' does not exist!')
print('\nInput directory:\n', pathin)
## Get input image and number of views
imgfile = args.image
image = io.readImage( pathin + imgfile )
npix = image.shape[0]
print('\nSinogram to reconstruct:\n', imgfile)
print('Number of pixels: ', npix)
## Display image
if args.plot is True:
dis.plot( image , 'Input image' )
## Get projection angle range
if args.geometry == '0' or args.geometry == '1':
if args.angle_range.find( ':' ) == -1:
angle_start = myfloat( args.angle_range )
angle_end = angle_start + 180.0
else:
angle_aux = args.angle_range.find( ':' )
angle_start = myfloat( angle_aux[0] )
angle_end = myfloat( angle_aux[1] )
print( '\nSelected angle range: [ ', angle_start,' , ', angle_end,' ]' )
## Get projection geometry
print( 'args.geometry = ', args.geometry)
if args.geometry == '0':
nang = args.nang
print('\nDealing with equiangular projections distributed between 0 and'
+' 180 degrees ---> [0,180)')
angles = create_equally_spaced_angles( nang , angle_start , angle_end )
elif args.geometry == '1':
nang = args.nang
angles = create_pseudo_polar_angles( nang ) * 180.0 / np.pi
print('\nDealing with equally sloped projections in [0,180)')
else:
geometryfile = pathin + args.geometry
print('\nReading list of projection angles: ', geometryfile)
angles = np.fromfile( geometryfile , sep="\t" )
nang = len( angles )
print('Number of projection angles: ', nang)
if args.plot is True:
print('\nProjection angles:\n', angles)
## Pad image to reach number of required sinogram pixels
if args.npix_s is not None:
npix_s = args.npix_s
else:
npix_s = npix
if args.base_size == 0:
base_size = npix
else:
base_size = args.base_size
if args.down_size == 0:
down_size = npix
else:
down_size = args.down_size
## Set parameters
print( '\nFHBP parameter setting:' )
print( 'Number sinogram pixels: ' , npix_s )
print( 'Base size: ' , base_size )
print( 'Downsampling size: ' , down_size )
print( 'Ratio sinogram / image sampling: ' , args.sampl_ratio )
param = np.array( [ npix_s , base_size , down_size ,
args.sampl_ratio ] )
## Apply forward projection operator
time_rec1 = time.time()
sino = fhbp.forwproj( image.astype( myfloat ) , angles.astype( myfloat ) ,
param.astype( myfloat ) )
time_rec2 = time.time()
## Crop sinogram
if args.crop is True and npix_s > npix:
print( 'Sinogram cropping enabled')
i1 = int( 0.5 * ( npix_s - npix ) )
i2 = i1 + npix
sino = sino[::-1,i1:i2]
## Display sinogram
if args.plot is True:
dis.plot( sino , 'Sinogram' )
## Save sinogram
write_sinogram( sino , pathin , angles , args )
## Time elapsed to run the code
time2 = time.time()
print('\nTime elapsed to run the forward gridrec: ', time_rec2-time_rec1)
print('Total time elapsed for the run of the program: ', time2-time1)
print('\n')
print('#######################################')
print('#### FORWARD PROJECTION DONE ! ####')
print('#######################################')
print('\n')
def main():
print('\nCREATE PHANTOM WITH DIFFERENT CNR\n')
## Get input arguments
args = getArgs()
## Get input and output path
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
if args.pathout is None:
pathout = pathin
else:
pathout = args.pathout
if pathout[len(pathout)-1] != '/':
pathout += '/'
print('\nInput path:\n', pathin)
print('\nOutput path:\n', pathout)
## Get single image
filein = args.filein
img = io.readImage( pathin + filein ).astype( myfloat )
shape = np.array( img.shape )
print('\nReading image:\n', filein)
if len( shape ) == 2:
dim = 2
nrows , ncols = shape
print('Image size: ', nrows,' X ', ncols)
if args.plot is True:
dis.plot( img , 'Input image' )
else:
dim = 3
nz , nrows , ncols = shape
print('Image size: ', nz , ' X ' , nrows,' X ', ncols)
if args.plot is True:
dis.plot( img[0,:,:] , 'Input image' )
## Get list of CNR
cnr_str = args.cnr
if cnr_str.find( ':' ) == -1:
cnr = cnr_str
n_cnr = 1
print( 'Selected 1 factor: ' , cnr )
else:
cnr_str = np.array( cnr_str.split( ':' ) ).astype( myfloat )
cnr = np.linspace( cnr_str[0] , cnr_str[1] , np.int( cnr_str[2] ) )
n_cnr = len( cnr )
print( 'Selected 1 factor: ' , cnr )
print( '\n' )
## Loop on each CNR value
img_cnr = img.copy()
for i in range( n_cnr ):
img_cnr[:] = img
img_cnr *= cnr[i]
if n_cnr < 10:
n_str = 'cnr' + str( i )
elif n_cnr < 100:
if i < 10:
n_str = 'cnr0' + str( i )
else:
n_str = 'cnr' + str( i )
fileout = filein[:len(filein)-4] + '_' + n_str + '.DMP'
io.writeImage( pathout + fileout , img_cnr )
print( 'Created phantom factor: ' , cnr[i] , '\n', pathout + fileout)
print('\n\n')
def main():
## Initial print
print('\n')
print('##############################################')
print('############# RADON TRANSFORM #############')
print('##############################################')
print('\n')
## Get the startimg time of the reconstruction
startTime = time.time()
## Get input arguments
args = getArgs()
## Get path to input image
pathin = args.pathin
if pathin[len(pathin) - 1] != '/':
pathin += '/'
## Get input image
## You assume the image to be square
image_name = pathin + args.image
image = io.readImage(image_name)
npix = image.shape[0]
if image.shape[1] != image.shape[0]:
sys.exit('\nERROR: input image is not square!\n')
print('\nInput image:\n', image_name)
print('Number of pixels: ', npix)
## Show image
if args.plot is True:
dis.plot(image, 'Image')
## Get projection geometry
## 1) Case of equiangular projections distributed in [0,180)
if args.geometry == '0':
nang = args.nang
angles = np.arange(nang)
angles = (angles * np.pi) / myfloat(nang)
print('\nDealing with equally angularly spaced projections in [0,180)')
## 2) Case of equally sloped projections distributed in [0,180)
elif args.geometry == '1':
nang = args.nang
angles = create_pseudo_polar_angles(nang)
print('\nDealing with equally sloped projections in [0,180)')
## 3) Case of list of projection angles in degrees
else:
geometryfile = pathin + args.geometry
angles = np.fromfile(geometryfile, sep="\t")
angles *= np.pi / 180.0
nang = len(angles)
print('\nReading list of projection angles: ', geometryfile)
print('Number of projection angles: ', nang)
## Get interpolation scheme
interp = args.interp
if interp == 'nn':
print('\nSelected interpolation scheme: nearest neighbour')
elif interp == 'lin':
print('\nSelected interpolation scheme: linear interpolation')
else:
print('''\nWARNING: ', interp,' does not correspond to any available
interpolation scheme; nearest neighbour interpolation will
be adopted''')
interp = 'nn'
## Compute radon transform
sinogram = radon_transform(np.rot90(image), angles, interp)
## Show sinogram
if args.plot is True:
dis.plot(sinogram, 'Sinogram')
## Save sinogram
save_sinogram(sinogram, angles, args)
## Time elapsed for the computation of the radon transform
endTime = time.time()
print('Time elapsed: ', (endTime - startTime) / 60.0)
print('\n')
def main():
print('\nADD GAUSSIAN NOISE TO IMAGES\n')
## Get input arguments
args = getArgs()
## Get input and output path
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
if args.pathout is None:
pathout = pathin
else:
pathout = args.pathout
if pathout[len(pathout)-1] != '/':
pathout += '/'
print('\nInput path:\n', pathin)
print('\nOutput path:\n', pathout)
## Get single image
if args.image is not None:
## Reading image
filein = args.image
imagein = io.readImage( pathin + filein ).astype( myfloat )
shape = np.array( imagein.shape )
print('\nReading image:\n', filein)
if len( shape ) == 2:
dim = 2
nrows , ncols = shape
print('Image size: ', nrows,' X ', ncols)
if args.plot is True:
dis.plot( imagein , 'Input image' )
else:
dim = 3
nz , nrows , ncols = shape
print('Image size: ', nz , ' X ' , nrows,' X ', ncols)
if args.plot is True:
dis.plot( imagein[0,:,:] , 'Input image' )
## Compute standard deviation of the image
## and, subsequently, the gaussian sigmas
sigma = 0.5 * np.max( imagein )
sigma_list = args.sigma_list
sigma_list = np.array( sigma_list.split(':') , dtype=myfloat )
nimg = len( sigma_list )
sigma_arr = sigma * sigma_list / 100.0
print('\nSigma of the input image: ', sigma)
print('Sigma percentages: ', sigma_list)
print('\nNoise sigma values: ')
pp.printArray( sigma_arr , 4 , 'r' )
## Loop on each gaussian sigma
for im in range( nimg ):
## Add noise
if args.noise == 'gaussian':
image_noisy = add_gaussian_noise( imagein , sigma_arr[im] )
label = 'gauss'
elif args.noise == 'poisson':
image_noisy = add_poisson_noise( imagein , sigma_arr[im] )
label = 'poiss'
## Check noisy image
if args.plot is True:
if dim == 2:
if args.noise == 'gaussian':
dis.plot( image_noisy , 'Gaussian noisy image -- sigma: ' + str( sigma_list[im] ) )
elif args.noise == 'poisson':
dis.plot( image_noisy , 'Poisson noisy image -- sigma: ' + str( sigma_list[im] ) )
else:
if args.noise == 'gaussian':
dis.plot( image_noisy[0,:,:] , 'Gaussian noisy image -- sigma: ' + str( sigma_list[im] ) )
elif args.noise == 'poisson':
dis.plot( image_noisy[0,:,:] , 'Poisson noisy image -- sigma: ' + str( sigma_list[im] ) )
## Write noisy image to file
extension = filein[len(filein)-4:]
fileout = filein[:len(filein)-4] + '_' + label
if sigma_list[im] < 1:
fileout += '000' + str( int( sigma_list[im] * 10 ) ) + extension
elif sigma_list[im] < 10:
fileout += '00' + str( int( sigma_list[im] * 10 ) ) + extension
elif sigma_list[im] < 100:
fileout += '0' + str( int( sigma_list[im] * 10 ) ) + extension
else:
fileout += str( int( sigma_list[im] * 10 ) ) + extension
io.writeImage( pathout + fileout , image_noisy )
## Get bunch of input images
elif args.label is not None:
curr_dir = os.getcwd()
## Reading images
os.chdir( pathin )
files = sorted( glob.glob( '*' + args.label + '*' ) )
os.chdir( curr_dir )
num_im_input = len( files )
for i in range( num_im_input ):
imagein = io.readImage( pathin + files[i] ).astype( myfloat )
nrows , ncols = imagein.shape
print('\nReading image:\n', files[i])
print('Image size: ', nrows,' X ', ncols)
## Compute standard deviation of the image
## and, subsequently, the gaussian sigmas
sigma = np.mean( imagein )
sigma_list = args.sigma_list
sigma_list = np.array( sigma_list.split(':') , dtype=myfloat )
nimg = len( sigma_list )
sigma_arr = sigma * sigma_list / 100.0
print('\nSigma of the input image: ', sigma)
print('Sigma percentages: ', sigma_list)
print('Gaussian sigma values: ', sigma_arr)
## Loop on each gaussian sigma
for im in range( nimg ):
## Add noise
if args.noise == 'gaussian':
image_noisy = add_gaussian_noise( imagein , sigma_arr[im] )
label = 'gauss'
elif args.noise == 'poisson':
image_noisy = add_poisson_noise( imagein , sigma_arr[im] )
label = 'poiss'
## Write noisy image to file
extension = files[i][len(files[i])-4:]
fileout = files[i][:len(files[i])-4] + '_noise_' + label
if sigma_list[im] < 1:
fileout += '000' + str( int( sigma_list[im] * 10 ) ) + extension
elif sigma_list[im] < 10:
fileout += '00' + str( int( sigma_list[im] * 10 ) ) + '0' + extension
elif sigma_list[im] < 100:
fileout += '0' + str( int( sigma_list[im] * 10 ) ) + '0' + extension
else:
fileout += str( int( sigma_list[im] * 10 ) ) + '0' + extension
io.writeImage( pathout + fileout , image_noisy )
print('\n\n')
def main():
print('\n')
print('#########################################################')
print('#########################################################')
print('### ###')
print('### ANALYTICAL RADON TRANSFORM OF SHEPP-LOGAN ###')
print('### ###')
print('#########################################################')
print('#########################################################')
print('\n')
## Get arguments
args = getArgs()
## Get number of pixels
npix = args.npix
nang = args.nang
print('\nNumber of pixels: ', npix)
print('Number of views: ', nang)
## Create look-up-table of Shepp-Logan ellipses or read specifics from file
if args.filein is None:
LUT = lut_shepp_logan( npix , nang )
print('\nCreated LUT for Shepp-Logan phantom')
else:
lut_file = np.loadtxt( args.filein )
LUT = lut_generic_phantom( lut_file , npix , nang )
if args.filein.find( '/' ) == -1:
name = args.filein.split( '.' )[0]
else:
tokens = args.filein.split( '/' )
name = tokens[len(tokens)-1].split('.')[0]
print('\nReading LUT for phantom from file:\n', args.filein)
print('Label selected for the putput files: ', name)
## Create Shepp-Logan phantom
phantom = create_phantom( LUT , npix )
## Write phantom
path = args.path
if path[len(path)-1] != '/':
path += '/'
if args.filein is None:
filename = path + 'shepp_logan_pix'
else:
filename = path + name + '_pix'
if npix < 10:
common = '000' + str( npix )
elif npix < 100:
common = '00' + str( npix )
elif npix < 1000:
common = '0' + str( npix )
else:
common = str( npix )
filename += common + args.file_format
io.writeImage( filename , phantom )
print('\nWriting sinogram in:\n', filename)
## Plot phantom
if args.plot is True:
dis.plot( phantom , 'Shepp-Logan phantom npix=' + str( npix ) )
## Compute analitically radon transform of the phantom
if args.nang is not None:
print('\nCalculating analytical radon transform of the phantom ....')
sinogram = radon_transform_analytical( phantom , LUT , npix , nang )
sinogram[:,:] = sinogram[:,::-1]
sinogram[:,:] = np.roll( sinogram , 1 , axis=1 )
## Plot Shepp-Logan phantom
if args.plot is True:
dis.plot( sinogram , 'Sinogram ' + str( nang ) + ' nang X ' + str( npix ) + ' npix' )
## Write sinogram
if args.filein is None:
filename = path + 'shepp_logan_pix' + common + '_ang'
else:
filename = path + name + '_pix' + common + '_ang'
if nang < 10:
filename += '000' + str( nang ) + '_rt_anal_sino' + '.DMP'
elif nang < 100:
filename += '00' + str( nang ) + '_rt_anal_sino' + '.DMP'
elif nang < 1000:
filename += '0' + str( nang ) + '_rt_anal_sino' + '.DMP'
else:
filename += str( nang ) + '_rt_anal_sino' + args.file_format
io.writeImage( filename , sinogram )
print('\nWriting sinogram in:\n', filename)
print('\n\n')
def main():
print('\nADD GAUSSIAN BLURRING TO IMAGES\n')
## Get input arguments
args = getArgs()
## Get input and output path
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
if args.pathout is None:
pathout = pathin
else:
pathout = args.pathout
if pathout[len(pathout)-1] != '/':
pathout += '/'
print('\nInput path:\n', pathin)
print('\nOutput path:\n', pathout)
## Get single image
if args.image is not None:
## Reading image
filein = args.image
imagein = io.readImage( pathin + filein )
nrows , ncols = imagein.shape
print('\nReading image:\n', filein)
print('Image size: ', nrows,' X ', ncols)
## Check plot
if args.plot is True:
dis.plot( imagein , 'Input image' )
## Allocate memory for the noisy temporary image
image_noisy = np.zeros( ( nrows, ncols ) , dtype=myfloat )
## Compute standard deviation of the image
## and, subsequently, the gaussian sigmas
sigma = np.mean( imagein )
sigma_list = args.sigma_list
sigma_list = np.array( sigma_list.split(':') , dtype=myfloat )
nimg = len( sigma_list )
sigma_arr = sigma * sigma_list / 100.0
print('\nSigma of the input image: ', sigma)
print('Sigma percentages: ', sigma_list)
print('\nGaussian sigma values: ')
pp.printArray( sigma_arr , 4 , 'r' )
## Loop on each gaussian sigma
for im in range( nimg ):
## Add gaussian noise
image_noisy[:,:] = add_gaussian_blurring( imagein , sigma_arr[im] )
## Check noisy image
if args.plot is True:
dis.plot( image_noisy , 'Noisy image -- sigma: ' + str( sigma_list[im] ) )
## Write noisy image to file
fileout = filein[:len(filein)-4] + '_blur'
if sigma_list[im] < 10:
fileout += '00' + str( int( sigma_list[im] ) ) + '.DMP'
elif sigma_list[im] < 100:
fileout += '0' + str( int( sigma_list[im] ) ) + '.DMP'
else:
fileout += str( int( sigma_list[im] ) ) + '.DMP'
io.writeImage( pathout + fileout , image_noisy )
## Get bunch of input images
elif args.label is not None:
curr_dir = os.getcwd()
## Reading images
os.chdir( pathin )
files = sorted( glob.glob( '*' + args.label + '*' ) )
os.chdir( curr_dir )
num_im_input = len( files )
for i in range( num_im_input ):
imagein = io.readImage( pathin + files[i] )
nrows , ncols = imagein.shape
print('\nReading image:\n', files[i])
print('Image size: ', nrows,' X ', ncols)
## Compute standard deviation of the image
## and, subsequently, the gaussian sigmas
sigma = np.mean( imagein )
sigma_list = args.sigma_list
sigma_list = np.array( sigma_list.split(':') , dtype=myfloat )
nimg = len( sigma_list )
sigma_arr = sigma * sigma_list / 100.0
print('\nSigma of the input image: ', sigma)
print('Sigma percentages: ', sigma_list)
print('\nGaussian sigma values: ')
pp.printArray( sigma_arr , 4 , 'r' )
## Loop on each gaussian sigma
for im in range( nimg ):
## Add gaussian noise
image_noisy = add_gaussian_blurring( imagein , sigma_arr[im] )
## Write noisy image to file
fileout = files[i][:len(files[i])-4] + '_blur'
if sigma_list[im] < 10:
fileout += '00' + str( int( sigma_list[im] ) ) + '.DMP'
elif sigma_list[im] < 100:
fileout += '0' + str( int( sigma_list[im] ) ) + '.DMP'
else:
fileout += str( int( sigma_list[im] ) ) + '.DMP'
io.writeImage( pathout + fileout , image_noisy )
print('\n\n')
def compute_lir( args ):
## Get input images
inputs = args.inputs
file1 , file2 , file3 = inputs.split( ':' )
rec_ref = io.readImage( file1 )
rec_imp = io.readImage( file2 )
imp_pos = np.loadtxt( file3 ).astype( int )
npix = rec_ref.shape[0]
nimp = imp_pos.shape[0]
## Display input images
if args.plot is True:
image_imp = np.zeros( ( npix , npix ) )
image_list = [ rec_ref , rec_imp ]
title_list = [ 'Reference reconstruction' ,
'Impulsed reconstruction' ]
dis.plot_multi( image_list , title_list )
## Compute image difference
rec_diff = rec_imp - rec_ref
## Resize image
zoom_factor = args.zoom
rec_diff = zoom( rec_diff , zoom_factor )
if args.plot is True:
dis.plot( rec_diff , 'Difference image x' + str( zoom_factor ), ')')
## Compute FWHM for each impulse and get an average of them
fwhm = np.zeros( nimp , dtype=myfloat )
denom = zoom_factor
for i in range( nimp ):
x0 = int( zoom_factor * imp_pos[i,0] ); y0 = int( zoom_factor * imp_pos[i,1] )
square = rec_diff[x0-r:x0+r,y0-r:y0+r]
hh = np.max( square ) * 0.5
aux = np.argwhere( square >= hh )
fwhm[i] = np.sqrt( len( aux ) ) / denom
FWHM = np.sum( fwhm ) / myfloat( nimp )
print('\nFWHM values:\n')
pp.printArray( fwhm )
print('\nFWHM average: ', FWHM)
print('\n')
## Write log file of the results
namebase = file1
pathout = None
if namebase.find( '/' ) != -1:
namebase = namebase.split( '/' )
filename = namebase[len(namebase)-1]
filename = filename[:len(filename)-4]
for i in range( len(namebase)-1 ):
if i == 0:
pathout = '/' + namebase[i]
else:
pathout += namebase[i] + '/'
else:
filename = namebase
filename = filename[:len(filename)-4]
pathout = './'
print('\nWriting files ...')
fileout = pathout + filename + '_lir_diff.DMP'
io.writeImage( fileout , rec_diff )
print( fileout )
fileout = pathout + filename + '_lir_analysis.txt'
fp = open( fileout , 'w' )
fp.write('\n')
fp.write('\n###########################################')
fp.write('\n###########################################')
fp.write('\n### ###')
fp.write('\n### LOCAL IMPULSE RESPONSE ANALYSIS ###')
fp.write('\n### ###')
fp.write('\n###########################################')
fp.write('\n###########################################')
fp.write('\n')
today = datetime.datetime.now()
fp.write('\nLIR calculation performed on the ' + str( today ))
fp.write('\n\nNumbers of impulses: ' + str( nimp ))
fp.write('\n\nAverage FWHM: ' + str( FWHM ))
print( fileout )
print( '\n' )
def main():
print('\nRESCALE IMAGE\n')
## Get input arguments
args = getArgs()
## Get input and output path
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
if args.pathout is None:
pathout = pathin
else:
pathout = args.pathout
if pathout[len(pathout)-1] != '/':
pathout += '/'
print('\nInput path:\n', pathin)
print('\nOutput path:\n', pathout)
## Get single image
if args.image is not None:
## Reading image
filein = args.image
imagein = io.readImage( pathin + filein )
nrows , ncols = imagein.shape[0] , imagein.shape[1]
print('\nReading image:', filein)
print('Image size: ', nrows,' X ', ncols)
## Check plot
if args.plot is True:
dis.plot( imagein , 'Input image' )
## Make image square
if args.square is True:
if nrows < ncols:
imagein = imagein[:,:nrows]
else:
imagein = imagein[:ncols,:]
## Rescaled image
if args.rescale is not None:
rescale = args.rescale
nrows_new = int( nrows * rescale )
ncols_new = int( ncols * rescale )
else:
nrows_new = ncols_new = args.npix
rescale = nrows_new / myfloat( nrows )
image_rescale = rescale_image( imagein , rescale )
print('\nRescaled factor: ', rescale)
print('Rescaled-image size: ', image_rescale.shape)
## Check plot
if args.plot is True:
dis.plot( image_rescale , 'Rescaled image -- factor = '
+ str( rescale ) )
## Write noisy image to file
fileout = filein[:len(filein)-4] + '_pix'
if nrows_new < 100:
fileout += '00' + str( nrows_new ) + '.DMP'
elif nrows_new < 1000:
fileout += '0' + str( nrows_new ) + '.DMP'
else:
fileout += str( nrows_new ) + '.DMP'
io.writeImage( pathout + fileout , image_rescale )
print('\nWriting rescaled image:', fileout)
## Get bunch of input images
elif args.label is not None:
curr_dir = os.getcwd()
## Reading images
os.chdir( pathin )
files = sorted( glob.glob( '*' + args.label + '*' ) )
os.chdir( curr_dir )
num_im_input = len( files )
for i in range( num_im_input ):
imagein = io.readImage( pathin + files[i] )
nrows , ncols = imagein.shape[0] , imagein.shape[1]
print('\nReading image:\n', files[i])
print('\nImage size: ', nrows,' X ', ncols)
## Make image square
if args.square is True:
if nrows < ncols:
imagein = imagein[:,:nrows]
else:
imagein = imagein[:ncols,:]
## Rescaled image
if args.rescale is not None:
rescale = args.rescale
nrows_new = int( nrows * rescale )
ncols_new = int( ncols * rescale )
else:
nrows_new = ncols_new = args.npix
rescale = nrows_new / myfloat( nrows )
image_rescale = rescale_image( imagein , rescale )
print('\nRescaled factor: ', rescale)
print('Rescaled-image size: ', image_rescale.shape)
## Write noisy image to file
fileout = files[i][:len(files[i])-4] + '_pix'
if nrows_new < 100:
fileout += '00' + str( nrows_new ) + '.DMP'
elif nrows_new < 1000:
fileout += '0' + str( nrows_new ) + '.DMP'
else:
fileout += str( nrows_new ) + '.DMP'
io.writeImage( pathout + fileout , image_rescale )
print('\nWriting rescaled image:', fileout)
print('\n\n')
def main():
## Initial print
print('\n')
print('##############################################')
print('############# RADON TRANSFORM #############')
print('##############################################')
print('\n')
## Get the startimg time of the reconstruction
startTime = time.time()
## Get input arguments
args = getArgs()
## Get path to input image
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
## Get input image
## You assume the image to be square
image_name = pathin + args.image
image = io.readImage( image_name )
npix = image.shape[0]
if image.shape[1] != image.shape[0]:
sys.exit('\nERROR: input image is not square!\n')
print('\nInput image:\n', image_name)
print('Number of pixels: ', npix)
## Show image
if args.plot is True:
dis.plot( image , 'Image' )
## Get projection geometry
## 1) Case of equiangular projections distributed in [0,180)
if args.geometry == '0':
nang = args.nang
angles = np.arange( nang )
angles = ( angles * np.pi )/myfloat( nang )
print('\nDealing with equally angularly spaced projections in [0,180)')
## 2) Case of equally sloped projections distributed in [0,180)
elif args.geometry == '1':
nang = args.nang
angles = create_pseudo_polar_angles( nang )
print('\nDealing with equally sloped projections in [0,180)')
## 3) Case of list of projection angles in degrees
else:
geometryfile = pathin + args.geometry
angles = np.fromfile( geometryfile , sep="\t" )
angles *= np.pi/180.0
nang = len( angles )
print('\nReading list of projection angles: ', geometryfile)
print('Number of projection angles: ', nang)
## Get interpolation scheme
interp = args.interp
if interp == 'nn':
print('\nSelected interpolation scheme: nearest neighbour')
elif interp == 'lin':
print('\nSelected interpolation scheme: linear interpolation')
else:
print('''\nWARNING: ', interp,' does not correspond to any available
interpolation scheme; nearest neighbour interpolation will
be adopted''')
interp = 'nn'
## Compute radon transform
sinogram = radon_transform( np.rot90( image ) , angles , interp )
## Show sinogram
if args.plot is True:
dis.plot( sinogram , 'Sinogram' )
## Save sinogram
save_sinogram( sinogram , angles , args )
## Time elapsed for the computation of the radon transform
endTime = time.time()
print('Time elapsed: ', (endTime-startTime)/60.0)
print('\n')
