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 main():
print('\n')
print('##############################################')
print('##############################################')
print('#### ####')
print('#### DOWNSAMPLE SINOGRAM ####')
print('#### ####')
print('##############################################')
print('##############################################')
print('\n')
## Get input arguments
args = getArgs()
## Read input sinogram
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
filename = args.sino
sino = io.readImage( pathin + filename )
nang , npix = sino.shape
print('\nInput path:\n', pathin)
print('\nInput sinogram:\n', filename)
print('Sinogram size: ', nang,' ang X ', npix,' pixels')
## Get input sinogram
factor = int( args.factor )
print('\nDownsampling factor: ', factor)
## Downsample in pixels
sino_down = sino[:,::factor]
if args.plot is True:
sino_list = [ sino , sino_down ]
title_list = [ 'Original sinogram' , 'Undersampled sinogram' ]
dis.plot_multi( sino_list , title_list )
## Write image
if args.pathout is None:
pathout = pathin
else:
pathout = args.pathout
fileout = filename[:len(filename)-4] + '_downsampl' + str( factor ) + '.DMP'
io.writeImage( pathout + fileout , sino_down )
print('\n')
def main():
print('\n')
print('##############################################')
print('##############################################')
print('#### ####')
print('#### DOWNSAMPLE SINOGRAM ####')
print('#### ####')
print('##############################################')
print('##############################################')
print('\n')
## Get input arguments
args = getArgs()
## Read input sinogram
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
filename = args.sino
sino = io.readImage( pathin + filename )
nang , npix = sino.shape
print('\nInput path:\n', pathin)
print('\nInput sinogram:\n', filename)
print('Sinogram size: ', nang,' ang X ', npix,' pixels')
## Getting projection geometry
angles = create_projection_angles( args , nang )
## Downsample in angles
sino_down , angles_down = downsample_sinogram_angles( sino , angles , args )
## Display check plot
if args.plot is True:
sino_list = [ sino , sino_down ]
title_list = [ 'Original sinogram' , 'Undersampled sinogram' ]
dis.plot_multi( sino_list , title_list )
## Write image & angle list
write_output_files( sino_down , angles_down , args , pathin , filename )
print('\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():
path_rec = "/home/arcusfil/tomcat/Data/benchmark_gridrec_beatty/recs/"
curr_dir = os.getcwd()
os.chdir(path_rec)
reco_list = sorted(glob.glob("*.DMP"))
num_reco = len(reco_list)
os.chdir(curr_dir)
print("\nNumber of reconstructions: ", num_reco, "\n")
count = 0
for i in range(num_reco):
image = io.readImage(path_rec + reco_list[i])
mean = np.mean(image)
if np.isnan(mean) == True:
count += 1
print("Analyzed images: %d" % i)
print("\nNumber of Nan images: ", count)
def main():
filename = sys.argv[1]
image = io.readImage( filename )
limits = sys.argv[2]
if len( limits.split(':') ) == 4:
x1 = int( limits.split(':')[0] )
x2 = int( limits.split(':')[1] )
y1 = int( limits.split(':')[2] )
y2 = int( limits.split(':')[3] )
image_out = image[x1:x2,y1:y2]
elif len( limits.split(':') ) == 3:
x1 = int( limits.split(':')[0] )
y1 = int( limits.split(':')[1] )
w = int( limits.split(':')[2] )
image_out = image[x1:x1+w,y1:y1+w]
fileout = filename[:len(filename)-4] + '.crop.DMP'
io.writeImage( fileout, image_out )
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():
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():
print('\n')
print('############################################################')
print('############################################################')
print('#### ####')
print('#### RESOLUTION WITH ERROR FUNCTION ####')
print('#### FITTING OF THE LINE PROFILE ####')
print('#### ####')
print('############################################################')
print('############################################################')
## Get input arguments
args = getArgs()
## Get filenames
filenames = args.images
if filenames.find( ':' ) != -1:
filenames = filenames.split( ':' )
nimg = len( filenames )
else:
filenames = [ filenames , filenames ]
nimg = 1
print('\nNumber of input images: ', nimg)
## Get delimiting points
aux = args.delimiters.split( ',' )
p1 = np.array( [ myint( aux[0].split( ':' )[0] ) ,
myint( aux[0].split( ':' )[1] ) ] )
p2 = np.array( [ myint( aux[1].split( ':' )[0] ) ,
myint( aux[1].split( ':' )[1] ) ] )
print('\nDelimiting points: (', p1[0],',', p1[1],')',' ',
'(', p2[0],',', p2[1],')')
num = myint( np.sqrt( ( p1[0] - p2[0] )**2 + ( p1[1] - p2[1] )**2 ) )
x = np.linspace( p1[0] , p2[0] , num )
y = np.linspace( p1[1] , p2[1] , num )
## Get output path
if args.pathout is not None:
pathout = args.pathout
if pathout[len(pathout)-1] != '/':
pathout += '/'
else:
pathout = None
## Calculate resolution with error function fitting
for i in range( nimg ):
print( '\n\nReading image:\n' , filenames[i] )
if filenames[i].find( '/' ) != -1:
prefix = filenames[i].split( '/' )
prefix = prefix[len(prefix)-1]
prefix = prefix[:len(prefix)-4]
else:
prefix = filenames[i][:len(filenames[i])-4]
image = io.readImage( filenames[i] )
line_profile = image[ y.astype( myint ) , x.astype( myint ) ]
if args.plot is True:
dis.plot_line( image , line_profile , [ p1 , p2 ] )
calc_resol( line_profile , filenames[i] , prefix , pathout , [ p1 , p2 ] , args )
print('\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('############# 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('############# PY-SART #############')
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
if pathin[len(pathin)-1] != '/':
pathin += '/'
## Get input reco
## You assume the reco to be square
sino_name = pathin + args.sino
sino = io.readImage( sino_name )
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:
checkPlot( sino , 'Sinogram' )
## 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 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)
print('Number of projection angles: ', nang)
## Get center of rotation
if args.ctr is None:
ctr = npix * 0.5
else:
ctr = args.ctr
print('\nCenter of rotation placed at pixel: ', ctr)
## Apply edge padding
if args.edgepad != 0:
npix_old = npix
sino = edgepad( sino , args.edgepad )
sino = sino.astype( myFloat )
npix = sino.shape[1]
print('\nEdge padded sinogram size: ', sino.shape[0],' X ', sino.shape[1])
## Compute iradon transform
print('\nPerforming SART iradon ....\n')
niter = args.niter
print('\nNumber of iterations:', niter)
print('\nIter number 1 ....')
reco = iradon_sart( np.rot90( sino ).astype(np.float64) ,
angles.astype(np.float64) )
for i in range( niter - 1 ):
print('\nIter number ', i +2,' ....')
reco[:,:] = iradon_sart( np.rot90( sino ).astype(np.float64) ,
angles.astype(np.float64) ,
image=reco )
## Crop image
if args.edgepad:
i1 = int( 0.5 * ( npix - npix_old ))
i2 = i1 + npix_old
reco = reco[i1:i2,i1:i2]
## Show sino
if args.plot is True:
checkPlot( reco , 'SART reconstruction' )
## Save sino
saveReco( reco , args )
## Time elapsed for the computation of the radon transform
endTime = time.time()
print('\n\nTime elapsed: ', (endTime-startTime)/60.0,' min')
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 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('############# RADON TRANSFORM #############')
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 )
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:
checkPlot( 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)
## 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'
## Get center of rotation
if args.ctr is None:
ctr = npix * 0.5
else:
ctr = args.ctr
print('\nCenter of rotation placed at pixel: ', ctr)
## Apply edge padding
if args.edgepad != 0:
npix_old = npix
sino = edgepad( sino , args.edgepad )
sino = sino.astype( myFloat )
npix = sino.shape[1]
ctr += int( 0.5 * ( npix - npix_old ))
print('\nEdge padded sinogram size: ', sino.shape[0],' X ', sino.shape[1])
## Compute radon transform
reco = np.zeros( ( npix , npix ) , dtype=myFloat )
reco[:,:] = iradonTransform( sino , angles , interp )
## Crop image
if args.edgepad != 0:
i1 = int( 0.5 * ( npix - npix_old ))
i2 = i1 + npix_old
print('\nnpix = ', npix,' npix_old = ', npix_old,' i1 = ', i1,
' i2 = ', i2)
reco = reco[i1:i2,i1:i2]
## Show sino
if args.plot is True:
checkPlot( reco , 'Sinogram' )
## Save sino
saveReco( reco , 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('\n')
print('###############################################')
print('###############################################')
print('#### ####')
print('#### RUN ANALYSIS OF THE RECONSTRUCTIONS ####')
print('#### ####')
print('###############################################')
print('###############################################')
print('\n')
## Get input arguments
args = getArgs()
## Get input path
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
print('\nInput path:\n', pathin)
## Get analisys type
analisys = args.analisys
print('\nSelected analisys: ', analisys)
## Get roi files
if analisys == 'snr':
roi_file = args.roi_fiji
if roi_file.find(':') != -1:
sys.exit('\nERROR: for the SNR analisys only 1 roi file is needed!')
else:
#fd = open( roi_file , 'r' )
print('\nReading ROI file:\n', roi_file)
pixels = np.loadtxt( roi_file )
x = pixels[:,1].astype( np.int )
y = pixels[:,0].astype( np.int )
elif analisys == 'cnr':
roi_file = args.roi_fiji
if roi_file.find(':') == -1:
sys.exit('\nERROR: for the CNR analisys 2 roi files are needed!')
else:
#fd = open( roi_file , 'r' )
roi_file = roi_file.split(':')
print('\nReading ROI file:\n', roi_file[0])
pixels = np.loadtxt( roi_file[0] )
x1 = pixels[:,1].astype( np.int )
y1 = pixels[:,0].astype( np.int )
print('\nReading ROI file:\n', roi_file[1])
pixels = np.loadtxt( roi_file[1] )
x2 = pixels[:,1].astype( np.int )
y2 = pixels[:,0].astype( np.int )
## Get reconstruction files
label = args.label
curr_dir = os.getcwd()
os.chdir( pathin )
rec_file_list = sorted( glob.glob( '*' + label + '*' ) )
num_files = len( rec_file_list )
os.chdir( curr_dir )
if num_files == 0:
sys.exit('\nNo file labelled with ', label ,' found in the folder:\n',
pathin)
else:
print('\nNumber of input files: ', num_files)
## Organize input files
plot_axis = args.plot_axis
axes = []
file_label = []
if plot_axis.find(',') == -1:
plot_axis_aux = args.plot_axis
plot_axis_aux = plot_axis_aux.split(':')
file_label.append( plot_axis_aux[0] )
for j in range( 1 , len( plot_axis_aux ) ):
axes.append( plot_axis_aux[j] )
print('\nPlot 2D selected using file label: ', file_label)
print('Axis x values: ', axes )
xlen = len( axes )
xaxis = np.array( axes ).astype( myFloat )
result = np.zeros( xlen , dtype=myFloat )
axis_label = args.axis_label
## Perform analisys
f = 0
for i in range( xlen ):
filein = rec_file_list[f]
imagein = io.readImage( pathin + filein )
print('\nInput image:\n', filein)
## Perform analysis
if analisys == 'snr':
snr = an.snr_roi( imagein , x , y )
if args.check_plot is True:
imagein[x[:],y[:]] = 2.0
plt.imshow( imagein , cmap=cm.Greys_r ); plt.show()
result[i] = snr
print('SNR = ', snr)
if analisys == 'cnr':
cnr = an.cnr_roi( imagein , x1 , y1 , x2 , y2 )
if args.check_plot is True:
imagein[x1[:],y1[:]] = 2.0
imagein[x2[:],y2[:]] = -2.0
plt.imshow( imagein , cmap=cm.Greys_r ); plt.show()
result[i] = cnr
print('CNR = ', cnr)
f += 1
## Write output file
fileout = args.fileout
if os.path.isfile( fileout ) is True:
sys.exit('\nERROR: output file:\n' + fileout + '\nalready exists!')
print('\nWriting data for bar plot 3D to file:\n', fileout)
fout = open( args.fileout , 'w' )
fout.write('x:' + axis_label.upper() + ':' + str( len( xaxis ) ) )
for i in range( len( xaxis ) ):
fout.write('\n%4f' % xaxis[i])
fout.write('\ny:' + analisys.upper() + ':' + str( len( result ) ) )
for i in range( len( result ) ):
fout.write('\n%4f' % result[i])
fout.close()
#print( xaxis )
#print( result )
## Check plot
fig = plt.figure()
plt.plot( xaxis , result , linewidth=3.0 )
plt.xlabel( 'Number of views' , fontsize=18 )
plt.ylabel( analisys.upper() , fontsize=18 )
plt.show()
print('\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('\n')
print('###############################################')
print('###############################################')
print('#### ####')
print('#### RUN ANALYSIS OF THE RECONSTRUCTIONS ####')
print('#### ####')
print('###############################################')
print('###############################################')
print('\n')
## Get input arguments
args = getArgs()
## Get input path
pathin = args.pathin
if pathin.find(':') == -1:
sys.exit('\nERROR: path to input reconstructions with odd indeces' +
' must be separated with a ":" from the reconstructions with' +
' even indeces')
else:
pathin = pathin.split(':')
if pathin[0][len(pathin[0])-1] != '/':
pathin[0] += '/'
if pathin[1][len(pathin[1])-1] != '/':
pathin[1] += '/'
print('\nInput paths:\n', pathin[0],'\n', pathin[1])
## Get reconstruction files
label = args.label
curr_dir = os.getcwd()
os.chdir( pathin[0] )
rec_list1 = sorted( glob.glob( '*' + label + '*' ) )
num_files1 = len( rec_list1 )
os.chdir( curr_dir )
os.chdir( pathin[1] )
rec_list2 = sorted( glob.glob( '*' + label + '*' ) )
num_files2 = len( rec_list2 )
os.chdir( curr_dir )
if num_files1 != num_files2:
sys.exit('\nERROR: number of files in path1 = ' + str( num_files1 )
+ ' differ from number of files in path2 = ' + str( num_files2 ) )
else:
num_files = num_files1
print('\nNumber of input files in both paths: ', num_files)
## Organize input files
plot_axes = args.plot_axes
axes = []
file_label = []
if plot_axes.find(',') == -1:
flag_plot3d = 0
plot_axes_aux = plot_axes_aux.split(':')
file_label.append( plot_axes_aux[0] )
for j in range( 1 , len( plot_axes_aux ) ):
axes.append( plot_axes_aux[j] )
print('\nPlot 2D selected using file label: ', file_label)
print('Axis x values: ', axes )
else:
plot_axes = plot_axes.split(',')
flag_plt3d = 1
for i in range( len( plot_axes ) ):
plot_axes_aux = plot_axes[i]
plot_axes_aux = plot_axes_aux.split(':')
file_label.append( plot_axes_aux[0] )
axes_values = []
for j in range( 1 , len( plot_axes_aux ) ):
axes_values.append( plot_axes_aux[j] )
axes.append( axes_values )
print('\nPlot 3D selected using file labels: ', file_label)
print('Axis x values: ', axes[0])
print('Axis y values: ', axes[1])
xlen = len( axes[0] )
ylen = len( axes[1] )
x = np.array( axes[0] ).astype( myFloat )
y = np.array( axes[1] ).astype( myFloat )
result = np.zeros( ( xlen , ylen ) , dtype=myFloat )
axes_label = args.axes_label
if axes_label.find(':') == -1:
flag_plot3d = 0
print('\nPlot 2D selected using file label: ', axes_label)
else:
flag_plot3d = 1
axes_label = axes_label.split(':')
print('\nPlot 3D selected using file labels: ', axes_label)
## Perform analisys
if args.resol_square is True:
print('Enabled analisys inside resolution square')
print('\n\n')
f = 0
for i in range( xlen ):
for j in range( ylen ):
filein = rec_list1[f]
image1 = io.readImage( pathin[0] + filein )
print('\n\nInput image 1:\n', filein)
filein = rec_list2[f]
image2 = io.readImage( pathin[1] + filein )
print('\nInput image 2:\n', filein)
print('\n')
## Preprocess input image and oracle
if args.resol_square is True:
image1 = an.select_resolution_square( image1 )
image2 = an.select_resolution_square( image2 )
## Perform analysis
frc , resol = an.fourier_ring_corr( image1 , image2 )
result[i,j] = resol
#x = np.arange( len( frc ) )
#plt.plot( x , frc )
#plt.show()
f += 1
## Write data for bar plot 3D to text file
if result.shape[0] * result.shape[1] != len( x ) * len( y ):
sys.exit('\nERROR: number of results = ' + str( len( result ) ) +
' does not match the product between number of x values = '
+ str( len( x ) ) + ' and the number of the y values = '
+ str( len( y ) ) + '\n')
fileout = args.fileout
if os.path.isfile( fileout ) is True:
sys.exit('\nERROR: output file:\n' + fileout + '\nalready exists!')
print('\nWriting data for bar plot 3D to file:\n', fileout)
fout = open( args.fileout , 'w' )
fout.write('x:' + axes_label[0].upper() + ':' + str( len( x ) ) )
for i in range( len( x ) ):
fout.write('\n%4f' % x[i])
fout.write('\ny:' + axes_label[1].upper() + ':' + str( len( y ) ) )
for i in range( len( y ) ):
fout.write('\n%4f' % y[i])
fout.write('\nz:FRC:' + str( len( result.flatten() ) ) )
for j in range( result.shape[1] ):
for i in range( result.shape[0] ):
fout.write('\n%4f' % result[i,j])
fout.close()
#print( x )
#print( y )
#print( result )
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = Axes3D(fig)
lx= len(result[0]) # Work out matrix dimensions
ly= len(result[:,0])
xpos = np.arange(0,lx,1) # Set up a mesh of positions
ypos = np.arange(0,ly,1)
xpos, ypos = np.meshgrid(xpos+0.25, ypos+0.25)
xpos = xpos.flatten() # Convert positions to 1D array
ypos = ypos.flatten()
zpos = np.zeros(lx*ly)
dx = 0.5 * np.ones_like(zpos)
dy = dx.copy()
dz = result.flatten()
ax.bar3d(xpos,ypos,zpos, dx, dy, dz, color='b', alpha=0.8)
column_names = axes[1]
row_names = axes[0]
ax.w_xaxis.set_ticklabels(column_names)
ax.w_yaxis.set_ticklabels(row_names)
ax.set_xlabel( axes_label[1].upper() )
ax.set_ylabel( axes_label[0].upper() )
ax.set_zlabel( 'FRC' )
plt.show()
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():
## 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('\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():
print('\n')
print('################################################')
print('################################################')
print('############ ############')
print('############ MY IMAGE TRANSFORM ############')
print('############ ############')
print('################################################')
print('################################################')
print('\n')
## Get arguments
args = getArgs()
## Get input path
pathin = args.pathin
if pathin[len(pathin) - 1] != '/':
pathin += '/'
print('\nInput path:\n', pathin)
## Get output path
if args.pathout is None:
pathout = pathin
flag_rename = 1
else:
pathout = args.pathout
if pathout == pathin:
flag_rename = 1
else:
flag_rename = 0
if pathout[len(pathout) - 1] != '/':
pathout += '/'
print('\nOutput path:\n', pathout)
## Get single input image and apply array of actions
if args.input is not (None):
fileinput = args.input
flag_single = 1
## Get group of images and apply array of actions
elif args.label is not (None):
curr_dir = os.getcwd()
os.chdir(pathin)
label = args.label
fileinput = sorted(glob.glob('*' + label + '*'))
flag_single = 0
os.chdir(curr_dir)
## Get list of actions to be performed
if args.action is not (None):
actionArray = getListOfActions(args.action)
## Loop on all the listed actions and the listed inputs
if flag_single:
print('\nReading image: ', fileinput)
imageArray = io.readImage(pathin + fileinput)
for action in actionArray:
if action == 'rc':
print('Applying clockwise rotation of 90 degrees')
imageArray = rotate90Clockwise(imageArray)
if action == 'ra':
print('Applying counter-clockwise rotation of 90 degrees')
imageArray = rotate90Counterclockwise(imageArray)
if action == 'fv':
print('Applying vertical flip')
imageArray = flipVertically(imageArray)
if action == 'fh':
print('Applying horizontal flip')
imageArray = flipHorizontally(imageArray)
if action == 'tr':
print('Applying transpose')
imageArray = transposeImage(imageArray)
if flag_rename and args.overwrite is False:
newFileName = createOutputName(fileinput, action)
else:
newFileName = fileinput
print('Output file = ', newFileName)
io.writeImage(pathout + newFileName, imageArray)
else:
for index in range(len(fileinput)):
print('Reading image: ', fileinput[index])
imageArray = io.readImage(pathin + fileinput[index])
for action in actionArray:
if action == 'rc':
print('Applying clockwise rotation of 90 degrees')
imageArray = rotate90Clockwise(imageArray)
if action == 'ra':
print(
'Applying counter-clockwise rotation of 90 degrees'
)
imageArray = rotate90Counterclockwise(imageArray)
if action == 'fv':
print('Applying vertical flip')
imageArray = flipVertically(imageArray)
if action == 'fh':
print('Applying horizontal flip')
imageArray = flipHorizontally(imageArray)
if action == 'tr':
print('Applying transpose')
imageArray = transposeImage(imageArray)
if flag_rename and args.overwrite is False:
newFileName = createOutputName(fileinput[index],
action)
else:
newFileName = fileinput[index]
print('Output file = ', newFileName)
io.writeImage(pathout + newFileName, imageArray)
print('\n')
## Change dynamic range of grey levels
elif args.dynRange is not (None):
dynRange = args.dynRange
[minValue, maxValue] = [
myFloat(dynRange.split(':')[0]),
myFloat(dynRange.split(':')[1])
]
print('Selected dynamic range interval: [', minValue, ',', maxValue,
']')
# loop on all the listed actions and the listed inputs
if flag_single:
print('\nReading image: ', fileinput)
imageArray = io.readImage(pathin + fileinput)
print('Changing dynamic range')
imageArray = changeDynamicRange(imageArray, minValue, maxValue)
if flag_rename and args.overwrite is False:
newFileName = createOutputName(fileinput, 'dr')
else:
newFileName = fileinput
io.writeImage(pathout + newfileName, imageArray)
else:
for index in range(len(fileinput)):
print('\nReading image: ', fileinput[index])
imageArray = io.readImage(pathin + fileinput[index])
print('Changing dynamic range')
imageArray = changeDynamicRange(imageArray, minValue, maxValue)
if flag_rename and args.overwrite:
newFileName = createOutputName(fileinput[index], 'dr')
else:
newFileName = fileinput[index]
io.writeImage(pathout + newFileName, imageArray)
print('\n')
## Change dynamic range of grey levels
elif args.crop is not (None):
roiEdges = args.crop
if roiEdges.find(':') == -1:
roiEdges = int(roiEdges)
flag_square = 1
print('\nCrop center square of side: ', roiEdges)
else:
roiEdges = roiEdges.split(':')
flag_square = 0
if len(roiEdges) == 4:
edge1 = np.array([int(roiEdges[0]), int(roiEdges[1])])
edge2 = np.array([int(roiEdges[2]), int(roiEdges[3])])
elif len(roiEdges) == 3:
edge1 = np.array([int(roiEdges[0]), int(roiEdges[1])])
width_x = int(roiEdges[2])
width_y = int(roiEdges[3])
edge2 = np.array([edge1[0] + width_x, edge1[1] + width_y])
print('\nEdges of the ROI to crop: edge1 = ( ', edge1[0], ' , ',
edge1[1], ') edge2 = ( ', edge2[0], ' , ', edge2[1], ' )')
## Loop on all the listed actions and the listed inputs
if flag_single:
print('\nReading image: ', fileinput)
imageArray = io.readImage(pathin + fileinput)
if flag_square:
nrows, ncols = imageArray.shape
edge1 = np.array([
int((nrows - roiEdges) * 0.5),
int((nrows - roiEdges) * 0.5)
],
dtype=int)
edge2 = np.array([edge1[0] + roiEdges, edge1[0] + roiEdges],
dtype=int)
print('\nCropping selected ROI')
imageArray = cropROI(imageArray, edge1, edge2)
plt.imshow(imageArray, cmap=cm.Greys_r)
plt.show()
if flag_rename and args.overwrite is False:
newFileName = createOutputName(fileinput[index], 'cr')
else:
newFileName = fileinput[index]
io.writeImage(pathout + newFileName, imageArray)
else:
for index in range(len(fileinput)):
print('\nReading image: ', fileinput[index])
imageArray = io.readImage(pathin + fileinput[index])
if flag_square:
nrows, ncols = imageArray.shape
edge1 = np.array([
int((nrows - roiEdges) * 0.5),
int((nrows - roiEdges) * 0.5)
],
dtype=int)
edge2 = np.array(
[edge1[0] + roiEdges, edge1[0] + roiEdges], dtype=int)
print('\nCropping selecting ROI')
imageArray = cropROI(imageArray, edge1, edge2)
if flag_rename and args.overwrite is False:
newFileName = createOutputName(fileinput[index], 'cr')
else:
newFileName = fileinput[index]
io.writeImage(pathout + newFileName, imageArray)
print('\n')
print('\n')
print('################################################')
print('################################################')
print('############ ############')
print('############ MY IMAGE TRANSFORM ############')
print('############ ############')
print('################################################')
print('################################################')
print('\n')
def main():
print('')
print('############################################')
print('############################################')
print('#### ####')
print('#### PROGRESSIVE DILATION OF AN IMAGE ####')
print('#### ####')
print('############################################')
print('############################################')
## Get input arguments
args = getArgs()
## Get input path
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
print('\nInput path:\n', pathin)
## Get output path
if args.pathout is None:
pathout = pathin
else:
pathout = args.pathout
if pathout[len(pathout)-1] != '/':
pathout += '/'
print('\nOutput path:\n', pathout)
## Read input image
image = io.readImage( pathin + args.input )
filein = args.input
nrows , ncols = image.shape
## Open log file
logfile = args.log
flog = open( pathout + logfile , 'w' )
print('\nInput path:\n', pathin)
print('\nOutput path:\n', pathout)
print('\nInput image:\n', pathin + args.input)
print('Image size: ', nrows,' X ', ncols)
print('\nLog file:\n', pathout + logfile)
flog.write('######## CREATE DILATED VERSIONS OF AN IMAGE ########')
today = datetime.datetime.now()
flog.write('\nCalculation performed on the ' + str(today))
flog.write('\nInput image:\n' + pathin + args.input )
flog.write('Image size: ' + str( nrows ) + ' X ' + str( ncols ) )
## Allocate memory for array hosting the dilated images
image_dil = np.zeros( ( nrows , ncols ) , dtype=myFloat )
## Get dilation factors
dilate_factors = args.dilate_factors
dilate_factors = np.array( dilate_factors.split(':') ).astype( int )
nimg = len( dilate_factors )
print('\nNumber of dilated images to create: ', nimg)
print('\nDilation factors: ', dilate_factors)
print('\n')
flog.write('\nNumber of dilated images to create: ' + str( nimg ) + '\n')
flog.write('\nDilation factors: ' + str( dilate_factors ) + '\n')
print('Original image')
meanSI , gsiIndex = complx_indeces( image )
ind1 = round( meanSI , 4 )
ind2 = round( gsiIndex , 4 )
if args.plot:
plot_image( image , 'Input image' , [ ind1 , ind2 ] )
## Create dilated version of the original image
for im in dilate_factors:
print('Dilation of size: ', im,' X ', im)
flog.write('\nDilation of size ' + str( im ) + ' X ' + str( im ) )
## Dilation
image_dil[:,:] = ndimage.grey_dilation( image , size=( im , im ) )
## Calculate image complexity index based on spatial information (SI)
## and gradient sparsity index
meanSI , gsiIndex = complx_indeces( image_dil )
ind1 = round( meanSI , 4 )
ind2 = round( gsiIndex , 4 )
print('meanSI ', meanSI,' gsiIndex = ', gsiIndex)
flog.write('\nmeanSI ' + str( meanSI ) + ' gsiIndex = ' + str( gsiIndex ) )
## Plot result
if args.plot:
plot_image( image_dil , 'Dilation ' + str( im ) , [ ind1 , ind2 ] )
## Write image
filename = pathout + filein[:len(filein)-4]
if im < 10:
filename += '.dil0' + str(im) + '.DMP'
else:
filename += '.dil' + str(im) + '.DMP'
io.writeImage( filename , image_dil )
print('Writing:\n', filename)
print('\n')
flog.write('\n\n')
flog.close()
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('#### DOWNSAMPLE SINOGRAM ####')
print('#### ####')
print('##############################################')
print('##############################################')
print('\n')
## Get input arguments
args = getArgs()
## Read input sinogram
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
filename = args.sino
sino = io.readImage( pathin + filename )
nang , npix = sino.shape
print('\nInput path:\n', pathin)
print('\nInput sinogram:\n', filename)
print('Sinogram size: ', nang,' ang X ', npix,' pixels')
## Calculate downsampling factors
factors = calc_downsampl_factors( nang )
nfact = len( factors )
print('\nNumber of downsampling factors: ', nfact)
## 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':
angles = create_pseudo_polar_angles( nang ) * 180.0 / np.pi
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" )
nang = len( angles )
print('\nReading list of projection angles: ', geometryfile)
## Additional label for output downsampled sinogram
label_base = '.angle_downsampl.'
## Get output directory
if args.pathout is None:
pathout = pathin
else:
pathout = args.pathout
if pathout[len(pathout)-1] != '/':
pathout += '/'
print('\nOutput directory:\n', pathout)
## Loop on each downsampling factor
for i in range( nfact ):
## Create downsampled version of the original sinogram
print('\n########################################')
print('\nDownsampling with factor: ', factors[i])
sino_down , anglist_new , nang_new = discard_proj( sino , angles , factors[i] )
## Naming conventions for ordering purpose
if nang_new < 100:
label_add = '00' + str( nang_new )
elif nang_new < 1000:
label_add = '0'+str( nang_new )
else:
label_add = str( nang_new )
## Create name for the output sinogram and the corresponding
## list of projection angles
filename_out = filename + label_base + label_add + '.sin.DMP'
fileang = filename + label_base + label_add + '.txt'
print('\nCreating files:\n', filename_out,'\n', fileang)
## Save downsampled sinogram
io.writeImage( pathout + filename_out , sino_down )
## Save list of projection angles
fw = open( pathout + fileang , 'w' )
for i in range( nang_new ):
fw.write("%.4f\n" % anglist_new[i] )
fw.close()
print('\n')
def calcResol(path,nameImage,startPoint,endPoint,args,indexIm):
# get number of lines around the reference line to use for computing
# the fourier spectrum; this number shoud be even to have the same
# number of lines before and after the reference line
nLines = args.nLines
if nLines % 2 != 2:
nLines += 1
# open image
imarray = myImageIO.readImage(path+nameImage)
imarray = imarray.astype(myFloat)
# check image before starting the analysis of the Fourier spectrum
checkPlot_images(nameImage,imarray,[startPoint,endPoint],args)
# get image dimensions
width,height = imarray.shape
# check if the line points define a line inside the image and if
# the line is horizontal or vertical and which point comes before
# and which after
flag,first,last = checkLinePoints(startPoint,endPoint,width,height)
# initialize array aimed at storing the line profile
lineLength = ((startPoint[0]-endPoint[0])**2+(startPoint[1]-endPoint[1])**2)**0.5
numFreq = int(np.ceil(lineLength))
lineProfile = np.zeros(numFreq,dtype=myComplex)
fourierSpectrum = np.zeros(numFreq,dtype=myComplex)
# compute the fourier spectrum of the reference line and of the
# other nLines lines around it and then compute the mean fourier
# spectrum
for n in range(nLines):
# case of vertical lines
if flag == 'v':
line = int(startPoint[0]+n-nLines/2.0)
if line >= 0 and line < height:
lineProfile[:] = imarray[line,first:last]
lineProfile[:] = np.abs(np.fft.fft(lineProfile))
fourierSpectrum += lineProfile*lineProfile/float(nLines)
else:
print("Warning: discarded line number ",n," , because it is out of the image")
# case of horizontal lines
elif flag == 'h':
line = startPoint[1]+n
if line >= 0 and line < height:
lineProfile[:] = imarray[line,first:last]
lineProfile[:] = np.abs(np.fft.fft(lineProfile))
fourierSpectrum += lineProfile*lineProfile/float(nLines)
else:
print("Warning: discarded line number ",n," , because it is out of the image")
# center the component at frequency null
fourierSpectrum[:] = np.fft.fftshift(fourierSpectrum)
# convert the spectrum values to log10 scale and add min value
# of the converted spectrum to go on working with positive values
fourierSpectrumTmp = np.empty(numFreq,dtype=myFloat)
for freq in range(numFreq):
fourierSpectrumTmp[freq] = math.log(np.real(fourierSpectrum[freq]),10)
fourierSpectrum = fourierSpectrumTmp + np.abs(np.min(fourierSpectrumTmp))
# get horizontal stripe along the fourier spectrum, representing
# the contribution of the noise to the signal; "thres" establishes
# the width of this stripe
thres = args.thres
baseLineMean = 6*np.sum(fourierSpectrum[int(5*numFreq/6.0):])/myFloat(numFreq)
baseLineSigma = np.sqrt(6.0/myFloat(numFreq)*np.sum((fourierSpectrum[int(5*numFreq/6.0):]-\
baseLineMean)*(fourierSpectrum[int(5*numFreq/6.0):]-baseLineMean)))
thresMin = baseLineMean - baseLineSigma
thresMax = baseLineMean + baseLineSigma
# get noise spectrum height
indexAux1 = np.asarray(np.where(fourierSpectrum>=thresMin)).reshape(-1)
indexAux2 = np.asarray(np.where(fourierSpectrum<=thresMax)).reshape(-1)
indexArr = np.sort(list(set(indexAux1) & set(indexAux2)))
baseLine = np.sum(fourierSpectrum[indexArr])
baseLine /= float(len(indexArr))
noiseHeight = min(thresMax-baseLine,baseLine-thresMin)+baseLine
# subtract noise spectrum to the line profile spectrum
fourierSpectrumNew = fourierSpectrum-noiseHeight
# find indeces where the signal spectrum is positive and choose the
# the first occurence above the abscissa of the half spectrum
indexResol = None
aboveThres = args.aboveThres
boolArr = fourierSpectrumNew>=0
frequencies = np.fft.fftshift(np.fft.fftfreq(numFreq))
index = None
for freq in range(int(numFreq/2.0),numFreq):
if boolArr[freq]:
if index is not(None):
indexResol = index
if np.abs(freq-index) > 1:
break
index = freq
# correct the resolution estimation manually with a list
# of preciser spatial frequencies corresponding to the
# searched intersection point.
if args.correct is not(None):
fixSpatialFreq = np.loadtxt(args.correct)
if fixSpatialFreq[indexIm] != -1:
minDist = 10000
for freq in range(numFreq):
if(minDist > np.abs(fixSpatialFreq[indexIm]-frequencies[freq])):
indexResol = freq
minDist = np.abs(fixSpatialFreq[indexIm]-frequencies[freq])
# check fourier spectrum in case indexResol is not found
if indexResol == None:
checkPlot_fourierSpectrum(nameImage,fourierSpectrum,numFreq,thresMin,thresMax,baseLine,
noiseHeight,indexResol,indexIm,args)
raise Exception('Spatial frequency of resolution not found!')
# resolution in pixels or in units
if args.pixsize is None:
resol = numFreq/float(indexResol-1)
print('Resolution: ', resol,' pixel')
else:
resol = numFreq/float(indexResol-1)*args.pixsize
print('Resolution: ', resol,' micro_meters')
# plot to check whether the fourier spectrum, the thresholding lines and the
# position of the "resolution point" are reasonable
if args.plot:
checkPlot_fourierSpectrum(nameImage,fourierSpectrum,numFreq,thresMin,thresMax,baseLine,
noiseHeight,indexResol,indexIm,args)
return resol
def main():
print('\n')
print('#######################################')
print('#######################################')
print('### ###')
print('### MEAN SQUARE ERROR ###')
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 = 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 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)
file_roi = open( roi , 'r' )
pixels = np.loadtxt( file_roi )
image1 = image1[pixels[:,0],pixels[:,1]]
image2 = image2[pixels[:,0],pixels[:,1]]
num_pix = len( image1 )
fact = factors( num_pix )
image1 = image1.reshape( fact[0] , int( num_pix/fact[0] ) )
image2 = image2.reshape( fact[0] , int( num_pix/fact[0] ) )
## 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' )
## Compute figures of merit
SNR = calc_snr( image1 , image2 )
PSNR = calc_psnr( image1 , image2 )
RMSE = calc_rmse( image1 , image2 )
MAE = calc_rmse( image1 , image2 )
results.append( np.array( [ SNR , PSNR , RMSE , MAE ] ) )
## 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)
file_roi = open( roi , 'r' )
pixels = np.loadtxt( file_roi )
pixels = pixels.astype( int )
image1 = image1[pixels[:,0],pixels[:,1]]
image2 = image2[pixels[:,0],pixels[:,1]]
num_pix = len( image1 )
fact = factors( num_pix )
image1 = image1.reshape( fact[0] , int( num_pix/fact[0] ) )
image2 = image2.reshape( fact[0] , int( num_pix/fact[0] ) )
## 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' )
## Compute figures of merit
SNR = calc_snr( image1 , image2 )
PSNR = calc_psnr( image1 , image2 )
RMSE = calc_rmse( image1 , image2 )
MAE = calc_rmse( image1 , image2 )
results.append( np.array( [ SNR , PSNR , RMSE , MAE ] ) )
## CASE OF BUNCH OF IMAGES TO ANALYZE
else:
os.chdir(args.path)
image_list = sorted(glob.glob('*'))
num_img = len(fileIn)
## 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', image_list[i])
print('Image shape: ', image2.shape)
if args.fileout is not None:
fileout.write('\nReading image to analyze:\n' + fileIn[i])
## 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)
file_roi = open( roi , 'r' )
pixels = np.loadtxt( file_roi )
pixels = pixels.astype( int )
image1 = image1[pixels[:,0],pixels[:,1]]
image2 = image2[pixels[:,0],pixels[:,1]]
num_pix = len( image1 )
fact = factors( num_pix )
image1 = image1.reshape( fact[0] , int( num_pix/fact[0] ) )
image2 = image2.reshape( fact[0] , int( num_pix/fact[0] ) )
## Check whether the 2 images have the same shape
if image1.shape != image2.shape:
sys.exit('\nERROR: The input images have different shapes!\n')
## Compute the gradient of the images, if enabled
if args.gradient is True:
image1 = compute_gradient_image( image1 )
image2 = compute_gradient_image( image2 )
## Plot to check whether the images have the same orientation
if args.plot is True and args.roi.find(',') != -1:
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' )
## Compute figures of merit
SNR = calc_snr( image1 , image2 )
PSNR = calc_psnr( image1 , image2 )
RMSE = calc_rmse( image1 , image2 )
MAE = calc_rmse( image1 , image2 )
results.append( np.array( [ SNR , PSNR , RMSE , MAE ] ) )
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('SNR = ' , results[i][0])
print('PSNR = ' , results[i][1])
print('MRSE = ' , results[i][2])
print('MAE = ' , results[i][3])
## 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 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('############# RADON TRANSFORM #############')
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)
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:
checkPlot(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)
## 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'
## Get center of rotation
if args.ctr is None:
ctr = npix * 0.5
else:
ctr = args.ctr
print('\nCenter of rotation placed at pixel: ', ctr)
## Apply edge padding
if args.edgepad != 0:
npix_old = npix
sino = edgepad(sino, args.edgepad)
sino = sino.astype(myFloat)
npix = sino.shape[1]
ctr += int(0.5 * (npix - npix_old))
print('\nEdge padded sinogram size: ', sino.shape[0], ' X ',
sino.shape[1])
## Compute radon transform
reco = np.zeros((npix, npix), dtype=myFloat)
reco[:, :] = iradonTransform(sino, angles, interp)
## Crop image
if args.edgepad != 0:
i1 = int(0.5 * (npix - npix_old))
i2 = i1 + npix_old
print('\nnpix = ', npix, ' npix_old = ', npix_old, ' i1 = ', i1,
' i2 = ', i2)
reco = reco[i1:i2, i1:i2]
## Show sino
if args.plot is True:
checkPlot(reco, 'Sinogram')
## Save sino
saveReco(reco, args)
## Time elapsed for the computation of the radon transform
endTime = time.time()
print('Time 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():
## 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('############# 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():
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():
## 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 create_dataset( args ):
## Get input image
image_ref = io.readImage( args.inputs )
npix = image_ref.shape[0]
## Create impulsed image
nimp = int( np.floor( npix / nimp_factor ) )
c = npix * 0.5
ind_imp = np.zeros( ( nimp , 2 ) , dtype=int )
i = 0
print('\nSelecting impulse locations ...')
while i < nimp:
x = int( np.round( np.random.rand() * npix ) )
y = int( np.round( np.random.rand() * npix ) )
dist1 = np.ceil( np.sqrt( ( x - c )**2 + ( y - c )**2 ) )
if dist1 < c:
if i != 0:
for j in range( i + 1 ):
x0 = ind_imp[j,0]; y0 = ind_imp[j,1]
dist2 = np.ceil( np.sqrt( ( x - x0 )**2 + ( y - y0 )**2 ) )
if dist2 <= r:
break
elif dist2 > r and j < i:
continue
elif dist2 > r and j == i:
ind_imp[i,0] = x; ind_imp[i,1] = y
i += 1
else:
ind_imp[i,0] = x; ind_imp[i,1] = y
i += 1
print('... locations selected!')
print('\nImpulse locations:')
pp.printArray2D( ind_imp )
image_imp = image_ref.copy()
imp_factor = args.imp_factor
for i in range( len( ind_imp ) ):
x0 = ind_imp[i][0]; y0 = ind_imp[i][1]
image_imp[x0,y0] += image_imp[x0,y0] * imp_factor
## Create sinograms
nang = int( np.ceil( npix * np.pi * 0.5 ) )
angles = myfloat( np.arange( nang ) / myfloat( nang ) * 180.0 )
image_ref = myfloat( image_ref ); image_imp = myfloat( image_imp )
sino_ref = grid.forwproj( image_ref , angles )
sino_imp = grid.forwproj( image_imp , angles )
## Check plots
if args.plot is True:
image_list = [ image_ref , image_imp ]
title_list = [ 'Reference image' , 'Impulsed image' ]
dis.plot_multi( image_list , title_list )
image_list = [ sino_ref , sino_imp ]
title_list = [ 'Sinogram of reference image' , 'Sinogram of impulsed image' ]
dis.plot_multi( image_list , title_list )
## Write output files
namebase = args.inputs
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 output files ...')
fileout = pathout + filename + '_lir.DMP'
io.writeImage( fileout , image_imp )
print( fileout )
fileout = pathout + filename + '_sin.DMP'
io.writeImage( fileout , sino_ref )
print( fileout )
fileout = pathout + filename + '_lir_sin.DMP'
io.writeImage( fileout , sino_imp )
print( fileout )
fileout = pathout + filename + '_lir.txt'
np.savetxt( fileout , ind_imp , newline= '\n' )
print( fileout )
print('\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():
print('\n')
print('###############################################')
print('###############################################')
print('#### ####')
print('#### RUN ANALYSIS OF THE RECONSTRUCTIONS ####')
print('#### ####')
print('###############################################')
print('###############################################')
print('\n')
## Get input arguments
args = getArgs()
## Get input path
pathin = args.pathin
if pathin[len(pathin)-1] != '/':
pathin += '/'
print('\nInput path:\n', pathin)
## Get reconstruction files
if args.imagein is not None:
imagein = args.imagein
image_file1 = imagein.split(':')[0]
image_file2 = imagein.split(':')[1]
num_pair = 1
elif args.allin:
curr_dir = os.getcwd()
os.chdir( pathin )
image_file1 = sorted( glob.glob( '*odd*' ) )
image_file2 = sorted( glob.glob( '*even*' ) )
if len( image_file1 ) != len( image_file2 ):
sys.exit('\nERROR: number of labelled "odd" = ' + str( len( image_file1 ) )
+ ' dies not correspond to the number of labelled "even" = '
+ str( len( image_file1 ) ) )
num_pair = len( image_file1 )
## Create output names
if num_pair == 1:
fileout = args.fileout
else:
aux_out = args.fileout
aux_out = aux_out.split(':')
pathout = aux_out[0]
if pathout[len(pathout)-1] != '/':
pathout += '/'
alg = aux_out[1]
nproj = aux_out[2:]
base_name = 'data_plot2d_frc_' + alg + '_proj_'
if len( nproj ) != num_pair:
sys.exit('\nERROR: number of image pair = ' + str( num_pair )
+ ' does not match with number of labels = ' +
+ str( nproj ) )
## Perform analisys
if args.resol_square is True:
print('Enabled analisys inside resolution square')
print('\n\n')
for i in range( num_pair ):
## Read images
if num_pair == 1:
image1 = io.readImage( pathin + image_file1 )
print('\n\nInput image 1:\n', image_file1 )
image2 = io.readImage( pathin + image_file2 )
print('\nInput image 2:\n', image_file2 )
else:
image1 = io.readImage( pathin + image_file1[i] )
print('\n\nInput image 1:\n', image_file1[i] )
image2 = io.readImage( pathin + image_file2[i] )
print('\nInput image 2:\n', image_file2[i] )
print('\n')
## Preprocess input image and oracle
if args.resol_square is True:
image1 = an.select_resolution_square( image1 )
image2 = an.select_resolution_square( image2 )
## Perform analysis
frc , resol , x = an.fourier_ring_corr( image1 , image2 )
## Write output file
if num_pair > 1:
fileout = pathout + base_name + nproj[i] + '.txt'
if os.path.isfile( fileout ) is True:
sys.exit('\nERROR: output file:\n' + fileout + '\nalready exists!')
print('\nWriting data for bar plot 3D to file:\n', fileout)
fout = open( fileout , 'w' )
fout.write('x:' + ':' + str( len( x ) ) )
for i in range( len( x ) ):
fout.write('\n%4f' % x[i])
fout.write('\ny:FRC:' + str( len( frc ) ) )
for i in range( len( frc ) ):
fout.write('\n%4f' % frc[i])
fout.close()
#print( x )
#print( resol )
#print( frc )
## Plot FRC curve
if num_pair == 1:
fig = plt.figure()
plt.plot( x , frc , 'o' , color='b' , markersize=12 )
plt.xlabel( 'Spatial frequencies' , fontsize=20 , position=(0.5,-0.2) )
plt.ylabel( 'FRC' , fontsize=20 , position=(0.5,0.5) )
plt.show()
print('\n')