def function2( files_real , files_imag , nz , ny , i ): im = complex( 0 , 1 ) array2D = np.zeros( ( nz , ny ) , dtype=np.complex64 ) for j in range( nz ): aux_real = io.readImage( files_real[j] )[i,:] aux_imag = io.readImage( files_imag[j] )[i,:] array2D[j,:] = aux_real + im * aux_imag return np.fft.fft( array2D , axis=0 )
def test2(abbr): ## Read Shepp-Logan image in folder "../data/" image = io.readImage('../data/shepp_logan_pix0256.DMP') n = image.shape[0] ## Create array of 200 angularly equispaced angles in [0,180) (degrees) nang = 200 a = np.arange(nang) * 180.0 / nang ## Compute forward projection if abbr != 'bsp': tp = cpr.projectors(n, a, oper=abbr, filt='ramp') else: a *= np.pi / 180.0 tp = cpb.projectors(n, a, bspline_degree=3, proj_support_y=4, nsamples_y=2048, radon_degree=0, filt='ramp', back=False) sino = tp.A(image) return sino
def reconstr_nnfbp( target_path , output_path , filein , angles , ctr , weights , offsets , minIn , maxIn , NHidden , filters ): ## Read low-quality sinogram sino = io.readImage( target_path + filein ).astype( myfloat ) nang , npix = sino.shape ## Allocate array for reconstruction reco = np.zeros( ( npix , npix ) , dtype=myfloat ) ## Do the required multiple reconstructions for i in xrange( NHidden ): filt = filters[i,0:filters.shape[1]] hidRec = utils.fbp( sino , angles , [ctr,0.0] , filt ) reco += weights[i] * sigmoid( hidRec - offsets[i] ) ## Apply last sigmoid reco = sigmoid( reco - weights[-1] ) ## Adjust image range reco = 2 * ( reco - 0.25 ) * ( maxIn - minIn ) + minIn ## Save reconstruction ext = filein[len(filein)-4:] fileout = output_path + filein[:len(filein)-4] + '_nnreco' + ext io.writeImage( fileout , reco ) print( '\nSaving NN-FBP reconstruction in:\n' , fileout ) return
def main(): print('\nADD 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 filein = args.filein imagein = io.readImage(pathin + filein) nrows, ncols = imagein.shape print('\nReading image:\n', filein, '\n') 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_blur = np.zeros((nrows, ncols), dtype=myfloat) ## Get blurring radii if args.sigma_range is None: sigma_list = args.sigma_list sigma_arr = np.array(sigma_list.split(':'), dtype=myfloat) nimg = len(sigma_arr) else: sigma_list = args.sigma_range sigma_list = np.array(sigma_list.split('-'), dtype=myfloat) sigma_arr = np.linspace(sigma_list[0], sigma_list[1], sigma_list[2]) nimg = len(sigma_arr) ## Loop on each gaussian sigma for im in range(nimg): ## Add gaussian noise image_blur[:, :] = add_gaussian_blurring(imagein, sigma_arr[im]) ## Check noisy image if args.plot is True: dis.plot(image_blur, 'Blurred image -- sigma: ' + str(sigma_arr[im])) ## Write noisy image to file write_output_file(pathout, filein, image_blur, sigma_arr[im])
def main(): sino = io.readImage( sys.argv[1] ) ctr = np.float32( sys.argv[2] ) sino_new = proc.sino_correct_rot_axis( sino , ctr ) filename = sys.argv[1][:len(sys.argv[1])-4] + '_interp.DMP' io.writeImage( filename , sino_new )
def multi_thread(pathin, pathout, filein, args, ii): sino = io.readImage(pathin + filein).astype(myfloat) nang, npix = sino.shape angles = utils.create_projection_angles(nang) tp = cpj.projectors(npix, angles, args=args) reco = tp.fbp(sino) if args.edge_pad: i1 = ii[0] i2 = ii[2] reco = reco[i1:i2, i1:i2] save_reconstruction(pathout, filein, args, reco)
def test2(): ## Read Shepp-Logan image in folder "../data/" image = io.readImage("../data/shepp_logan_pix0256.DMP") n = image.shape[0] ## Create array of 200 angularly equispaced angles in [0,180) (degrees) nang = 402 a = np.arange(nang) * 180.0 / nang ## Compute forward projection tp = cpj.projectors(n, a, ctr=0.0) sino = tp.A(image) return sino
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 sinogram angles_down = None if args.nproj is not None: sino_down, angles_down = downsample_sinogram_angles(sino, angles, args) elif args.factor is not None: sino_down = downsample_sinogram_pixels(sino, 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 create_training_file( input_path , train_path , filein , angles , npix_train_slice , idx , nang_lq , ctr_hq , nfilt , filt_custom , filt , debug ): ## Read high-quality sinogram sino_hq = io.readImage( input_path + filein ).astype( myfloat ) ## Reconstruct high-quality sinogram with standard filter params = utils.select_filter( ctr_hq , filt ) reco_hq = utils.fbp( sino_hq , angles , params , None ) ## Debugging save high- and low-quality reconstructions if debug is True: filedbg = filein ext = filedbg[len(filedbg)-4:] filedbg += '_hq' + ext io.writeImage( train_path + filedbg , reco_hq ) ## Create output training array train_data = np.zeros( ( npix_train_slice , nfilt+1 ) , dtype=myfloat ) ## Randomly select training pixels picked = utils.getPickedIndices( idx , npix_train_slice ) ## Save validation data train_data[:,-1] = reco_hq[picked] ## Downsample sinogram sino_lq , angles_lq = utils.downsample_sinogram_angles( sino_hq , angles , nang_lq ) ## Reconstruct low-quality sinograms with customized filters for j in range( nfilt ): train_data[:,j] = reconstr_filter_custom( sino_lq , angles_lq , ctr_hq , filt_custom[j,:] , picked , debug , train_path , filein , j ) ## Save training data filename = filein fileout = train_path + filename[:len(filename)-4] + '_train.npy' np.save( fileout , train_data ) print( '\nTraining data saved in:\n', fileout )
def main(): print('') print('######################################') print('######################################') print('#### ####') print('#### CALCULATE IMAGE COMPLEXITY ####') print('#### ####') print('######################################') print('######################################') ## Get input arguments args = getArgs() ## Read input image filein = args.pathin + args.filein image = io.readImage( filein ) nx , ny = image.shape print('\nReading input image:\n', filein) print('Image size: ', nx, ' X ', ny) if args.jpeg_compr <= 0 and args.jpeg_compr >= 100: args.jpeg_compr = 75 if args.plot is True: dis.plot( image , 'Input image' ) ## Calculate image complexity index based on JPEG compression complexity_jpeg( image , args ) ## Calculate image complexity index based on spatial information (SI) complexity_struct_info( image )
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 = pyest.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 = pyest.est_tomo( sino , angles , proc ) time_rec2 = time.time() print('\n.... reconstruction done!') ## Display reconstruction dis.plot( reco , 'Reconstruction' ) ## Save reconstruction saveReco( reco , pathin , args ) ## Time elapsed for the reconstruction time2 = time.time() print('\nTime elapsed for the back-projection: ', time_rec2-time_rec1 ) print('Total time elapsed: ', time2-time1 ) print('\n') print('##############################################') print('#### EQUALLY SLOPED TOMOGRAPHY DONE ! ####') print('##############################################') print('\n')
def main(): ## Initial print print('\n') print('########################################################') print('############# REGRIDDING BACKPROJECTION #############') print('########################################################') print('\n') ## Get the startimg time of the reconstruction time1 = time.time() ## Get input arguments args = getArgs() ## Get input/output directory pathin, pathout = utils.get_io_path(args) print('\nInput path:\n', pathin) print('\nOutput path:\n', pathout) ## Get input files file_list, file1, nimg, ext = utils.get_input(args, pathin) print('\nNumber of input files: ', nimg) print('Extension of the files: ', ext) ## Read first sinogram sino = io.readImage(pathin + file1).astype(myfloat) nang, npix = sino.shape print('\nSinogram to reconstruct:\n', file1) print('Number of projection angles: ', nang) print('Number of pixels: ', npix) 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 = utils.create_projection_angles(nang) else: print('\nReading list of projection angles:\n', pathin + args.geometry) angles = utils.create_projection_angles(textfile=pathin + args.geometry) ## Set center of rotation axis if args.ctr == None: ctr = 0.0 print('Center of rotation axis placed at pixel: ', npix * 0.5) else: if args.ctr == -1: ctr = proc.search_rot_ctr(sino, None, 'a') print('Center of rotation axis placed at pixel: ', ctr) else: ctr = args.ctr print('Center of rotation axis placed at pixel: ', ctr) if args.dbp is True: sino[:, :] = proc.sino_correct_rot_axis(sino, ctr) print('Center of rotation corrected') ctr = 0.0 ## Enable edge padding if args.edge_pad is True: sino = proc.sino_edge_padding(sino, 0.5).astype(myfloat) i1 = int((sino.shape[1] - npix) * 0.5) i2 = i1 + npix npix = sino.shape[1] if ctr != 0.0: ctr += i1 if args.plot is True: dis.plot(sino, 'Edge padded sinogram') else: i1 = 0 i2 = npix ## External sinogram filtering if args.filt == 'ramp-ext' or args.filt == 'conv-ext': if filt == 'ramp-ext': sino = fil.filter_fft(sino, 'ramp') elif filt == 'conv-ext': sino = fil.filter_convolve(sino) sino *= 4.0 / myfloat(npix) args.filt = 0 ## Differential sinogram fo DBP if args.dbp is True: print('\nDifferential backprojection enabled') print( 'Computing differential sinogram by means of Savitzky-Golay method' ) print('Savizky-Golay window length: ', args.sg) sino[:, :] = proc.diff_sino_savitzky_golay(sino, window_size=args.sg) if args.plot is True: dis.plot(sino, 'Differential sinogram') ## Initialize projectior class tp = cpj.projectors(npix, angles, ctr=ctr, args=args) ## Apply forward projection operator time_rec1 = time.time() reco = tp.fbp(sino) time_rec2 = time.time() ## Crop reconstruction if args.edge_pad: reco = reco[i1:i2, i1:i2] ## Display reconstruction if args.plot is True: dis.plot(reco, 'Reconstruction') ## Save reconstruction save_reconstruction(pathout, file1, args, reco) ## Reconstruct sinograms from all the other images in the stack if args.filein is None: pool = mproc.Pool() for i in range(1, nimg): pool.apply_async( multi_thread, (pathin, pathout, file_list[0][i], args, [i1, i2])) pool.close() pool.join() time2 = time.time() print('\nTime elapsed to run the 1st backward gridrec: ', time_rec2 - time_rec1) print('Total time elapsed for the run of the program: ', time2 - time1) print('\n') print('##############################################') print('#### REGRIDDING BACKPROJECTION DONE ! ####') print('##############################################') 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') ## 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.linearRegression(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.selectResolutionSquare(image1) image2 = proc.selectResolutionSquare(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.linearRegression(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.selectResolutionSquare(image1) image2 = proc.selectResolutionSquare(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('\n\nTest image number ', i, '\n', image_list[i], '\n') 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('##########################################################') print('##### #####') print('##### ADMM Iterative Reconstruction #####') print('##### #####') print('##########################################################') print('##########################################################') print('\n') ## Get input arguments args = getArgs() ## Get input and output paths pathin, pathout = utils.get_io_path(args) print('\nInput path:\n', pathin) print('\nOutput path:\n', pathout) ## Get input sinogram sino_list = [] filein = [] if args.filein is not None: sinoname = pathin + args.filein sino = io.readImage(sinoname).astype(myfloat) if args.angle_pi is True: sino = sino[:sino.shape[0] - 1, :] nang, npix = sino.shape nz = 1 sino_list.append(sino) filein.append(args.filein) print('\nSinogram to reconstruct:\n', sinoname) else: print('\nReading stack of images\n') curr_dir = os.getcwd() os.chdir(pathin) for f in os.listdir('./'): if f.endswith('.DMP') is True: ext = '.DMP' break elif f.endswith('.tif') is True: ext = '.tif' break else: sys.exit('\nERROR: no .DMP or .tif file found in:\n' + pathin) filein.append(sorted(glob.glob('*' + ext))) nz = len(filein[0]) os.chdir(curr_dir) print('Stack extension: ', ext) print('Number of slices: ', nz) print('\nLoading images .... ') for i in range(nz): if i == 0: sino = io.readImage(pathin + filein[0][i]).astype(myfloat) nang, npix = sino.shape sino_list.append(sino) else: sino_list.append( io.readImage(pathin + filein[0][i]).astype(myfloat)) print(' done! ') print('\nNumber of projection angles: ', nang) print('Number of pixels: ', npix) ## Check plot if args.plot is True: if nz == 1: dis.plot(sino_list[0], 'Input sinogram') else: nzz = np.int(nz * 0.5) dis.plot(sino_list[nzz], 'Input sinogram') ## Center of rotation axis if args.ctr == -1: ctr = npix * 0.5 elif args.ctr != -1: ctr = args.ctr ## Enable edge padding if args.lt is True: edf = 0.87 elif args.lt is False and args.edge_padding != 0: edf = args.edge_padding else: edf = 0.0 if edf: npix_old = npix for i in range(nz): sino_list[i] = proc.sino_edge_padding(sino_list[i], edf) npix = sino_list[0].shape[1] i1 = myint((npix - npix_old) * 0.5) i2 = i1 + npix_old ctr += i1 print('\nEdge padding: ', edf) print('Number of edge-padded pixels: ', npix) print('Index start: ', i1, ' Index end: ', i2) print('Center of rotation axis new position: ', ctr) if args.plot is True: if nz == 1: dis.plot(sino_list[0], 'Sinogram with edge-padding') else: nzz = np.int(nz * 0.5) dis.plot(sino_list[nzz], 'Input sinogram') else: npix_old = npix i1 = 0 i2 = npix ## Compute differential sinogram if DBP option enabled if args.dbp is True: print('\nComputing differential sinogram ....') for i in range(nz): sino_list[i] = proc.diff_sino_savitzky_golay(sino_list[i], window_size=args.sg) if args.plot is True: dis.plot(sino_list[0], 'Differential sinogram') ## Correct for the center of rotation axis if args.ctr != -1: for i in range(nz): sino_list[i] = proc.sino_correct_rot_axis(sino_list[i], ctr) print('\nCenter of rotation axis position: ', ctr) print('Center of rotation corrected') ## Get geometry if args.geometry == '0': angles = utils.create_projection_angles(nang) else: angles = utils.create_projection_angles(textfile=pathin + args.geometry) ## Getting stopping criterion print('\nSetup of the iterative procedure:') if nz == 0: labelout = pathout + filein[0][:len(filein[0]) - 4] else: labelout = pathout + filein[0][0][:len(filein[0]) - 4] param = cap.admm_param(npix_old, nang, nz, ctr, labelout, args) print('Projectors enabled: ', args.projector) if args.dbp is True: print('DBP reconstruction enabled') if args.dpc is True: print('DPC reconstruction enabled') if args.n_iter is not None: print('Number of iterations: ', param.n_iter) if args.eps is not None: print('Stopping epsilon: ', param.eps) if args.n_iter_pcg is not None: print('Number of PCG iterations: ', param.n_iter_pcg) if args.plot is True: print('Interactive plot:', param.plot) if args.logfile is True: print('Interactive plot:', param.logfile) if param.reg is not None: if param.reg == 'cg': print('Conjugate gradient') if param.reg == 'lasso': print('Regularization type: Lasso L1') elif param.reg == 'lasso-tv': print('Regularization type: Lasso TV') elif param.reg == 'pp-breg': print('Regularization type: Plug and Play -- TV Bregman') elif param.reg == 'pp-chamb': print('Regularization type: Plug and Play -- TV Chambolle') elif param.reg == 'pp-nlmeans': print('Regularization type: Plug and Play -- Non Local Means') elif param.reg == 'pp-tgv': print( 'Regularization type: Plug and Play -- Total generalized variation' ) elif param.reg == 'pp-nltv': print( 'Regularization type: Plug and Play -- Non-local total variation' ) if param.reg != 'cg': print('\nLambda 1: ', param.lambd1) print('Lambda 2: ', param.lambd2) print('Mu: ', param.mu) if args.init_object is True: print('\nInitialization with FBP reconstruction:', param.init_object) if param.mask is not None: print('\nObject support enabled') if param.plot is True: dis.plot(param.mask, 'Object support') if param.mask_add is not None: print('\nAdditional supports provided') if param.plot is True: if param.mask_add_n == 1: dis.plot(param.mask_add[0]) else: dis.plot_multi(param.mask_add) if param.lt is True: print('\nLocal tomography mode enabled') ## Iterative reconstruction print('\n\nReconstructing with ADMM ....') time1 = time.time() reco_list, info = admm(sino_list, angles, param) time2 = time.time() print('.... reconstruction done!') for i in range(nz): ## Crop reconstruction if edge-padding enabled if edf != 0.0: reco = reco_list[i, i1:i2, i1:i2] else: reco = reco_list[i, :, :] ## Show reconstruction if args.plot is True and nz == 1 and args.reg != 'cg': dis.plot(reco, 'Reconstruction') plot_convergence_curves(info) elif args.plot is True and i == nzz and args.reg != 'cg': nzz = np.int(nz * 0.5) dis.plot(reco_list[nzz, :, :], 'Reconstruction of slice ' + str(nzz)) ## Save reconstruction if nz == 1: save_reco(pathout, filein[0], args, param, reco) else: save_reco(pathout, filein[0][i], args, param, reco) ## Time elapsed for the reconstruction time_tot = (time2 - time1) / 60.0 print('\nTime elapsed for the reconstruction: ', time_tot) ## Write log file if args.logfile is True: write_logfile(pathin, pathout, args, angles, ctr, param, time_tot, info) write_info(pathout, filein[0], info, param, args) ## Final print print('\n') print('\n') print('##########################################################') print('##########################################################') print('##### #####') print('##### ADMM Reconstruction done! #####') print('##### #####') print('##########################################################') print('##########################################################') print('\n')
def main(): print('\n') print('#############################################################') print('############ FOURIER RING CORRELATION ANALYSIS ############') print('#############################################################') print('\n') ## Get input arguments args = getArgs() ## Get output folder if args.pathout is not None: pathout = args.pathout if pathout[len(pathout) - 1] != '/': pathout += '/' if os.path.exists(pathout) is False: os.mkdir(pathout) else: pathout = None ## Get number of pair of images image_string = args.images file_list = [] if image_string.find(',') != -1: image_string = image_string.split(',') num_img_pair = len(image_string) for i in range(num_img_pair): file_list.append(image_string[i].split(':')) else: file_list.append(image_string.split(':')) num_img_pair = 1 num_img = num_img_pair * 2 print('Number of images to analyze: ', num_img) ## Read input images and display them as check images = [] prefix = [] for i in range(num_img_pair): for j in range(2): ## Read single image image_name = file_list[i][j] image = io.readImage(image_name) m, n = image.shape ## Crop it as a square image npix = np.min((m, n)) i1 = int(0.5 * (m - npix)) i2 = int(0.5 * (n - npix)) image = image[i1:i1 + npix, i2:i2 + npix] print('Reading image: ', image_name) ## Select resolution square if args.resol_square is True: print('Calculation enabled in the resol square') image = proc.select_resol_square(image) ## Apply hanning window if args.hanning is True: window = np.hanning(npix) window = np.outer(window, window) image *= window images.append(image) ## Get common prefix prefix.append(common_string([file_list[i][0], file_list[i][1]])) ## Check plot if args.plot is True: dis.plot_multi( [images[2 * i], images[2 * i + 1]], ['Input image ' + str(2 * i), 'Input image ' + str(2 * i + 1)]) ## Get labels for plots labels = None if args.labels is not (None): labels = args.labels labels = labels.split(':') if (2 * len(labels)) != num_img: sys.exit( '\nERROR: Number of labels is not half number of input images!\n' ) ## Fourier ring correlation analysis frc_curves = [] for i in range(num_img_pair): print('\nCalculating FRC between:\n1)', file_list[i][0],'\n2)',\ file_list[i][1]) FRC, spatial_freq = analysis_frc(images[2 * i], images[2 * i + 1], args, pathout, prefix[i], file_list[i], labels=None) frc_curves.append(FRC) frc_curves = np.array(frc_curves).reshape(num_img_pair, len(spatial_freq)) ## Plot FRC curves if num_img_pair > 1: title = 'FRC - Comparison' prefix = 'comparison_curves' plot_frc_curves(frc_curves, spatial_freq, args, pathout, prefix, title, labels, mode='multi') print('\n########## FOURIER RING CORRELATION ANALYSIS END ##########\n')
def main(): ## Initial print print('\n') print('########################################################') print('############# REGRIDDING BACKPROJECTION #############') print('########################################################') print('\n') ## Get the startimg time of the reconstruction time1 = time.time() ## Get input arguments args = getArgs() ## Get input and output 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!') if args.pathout is None: pathout = pathin else: pathout = args.pathout if pathout[len(pathout)-1] != '/': pathout += '/' 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 projections distributed between 0 and' +' 180 degrees ---> [0,180)') angles = np.arange( nang ).astype( myfloat ) angles[:] = ( angles * 180.0 )/myfloat( nang ) ## 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" ) if args.plot is True: print('\nProjection angles:\n', angles) ## Choose filtering function filt_list = [ 'none' , 'ramp' , 'shlo' , 'hann' , 'hamm' , 'parz' , 'lanc' ] filt = args.filt if filt not in filt_list: sys.exit("\nERROR: filter named: ', filt,' does not exist!\n \ Use one of the following available filters:\n \ 'none' , 'ramp' , 'shlo' , 'hann' , 'hamm' , 'parz' , 'lancz'") print('\nSelected filter: ', filt) param = np.zeros( 3 ) if filt == 'none': param[1] = 0 elif filt == 'ramp': param[1] = 1 elif filt == 'shlo': param[1] = 2 elif filt == 'hann': param[1] = 3 elif filt == 'hamm': param[1] = 4 elif filt == 'lanc': param[1] = 5 elif filt == 'parz': param[1] = 6 ## Set center of rotation axis if args.ctr == None: ctr = npix * 0.5 elif args.ctr == -1: ctr = proc.searchCtrRot( sino , None , 'a' ) else: ctr = args.ctr ## 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] ctr += i1 if args.plot is True: dis.plot( sino , 'Edge padded sinogram' ) param[0] = ctr print('Center of rotation axis placed at pixel: ', ctr) ## Reconstruction with regridding method time_rec1 = time.time() reco = grid.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] ## Display reconstruction if args.plot is True: dis.plot( reco , 'Reconstruction' ) ## Save reconstruction saveReco( reco , pathin , pathout , 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('#### REGRIDDING BACKPROJECTION DONE ! ####') print('##############################################') print('\n')
def main(): ## Initial print print('\n') print('##########################################################') print('##########################################################') print('##### #####') print('##### STATISTICAL ITERATIVE RECONSTRUCTION #####') print('##### #####') print('##########################################################') print('##########################################################') print('\n') ## Getting arguments args = getArgs() ## Get input & output paths pathin, pathout = utils.get_io_path(args) print('\nInput path: \n', pathin) print('\nOutput path:\n', pathout) ## Get input sinogram sino_list = [] filein = [] if args.filein is not None: sinoname = pathin + args.filein sino = io.readImage(sinoname).astype(myfloat) nang, npix = sino.shape nz = 1 sino_list.append(sino) filein.append(args.filein) print('\nSinogram to reconstruct:\n', sinoname) else: print('\nReading stack of images\n') curr_dir = os.getcwd() os.chdir(pathin) for f in os.listdir('./'): if f.endswith('.DMP') is True: ext = '.DMP' break elif f.endswith('.tif') is True: ext = '.tif' break else: sys.exit('\nERROR: no .DMP or .tif file found in:\n' + pathin) filein.append(sorted(glob.glob('*' + ext))) nz = len(filein[0]) os.chdir(curr_dir) print('Stack extension: ', ext) print('Number of slices: ', nz) print('\nLoading images .... ') for i in range(nz): if i == 0: sino = io.readImage(pathin + filein[0][i]).astype(myfloat) nang, npix = sino.shape sino_list.append(sino) else: sino_list.append( io.readImage(pathin + filein[0][i]).astype(myfloat)) print(' done! ') print('\nNumber of projection angles: ', nang) print('Number of pixels: ', npix) ## Check plot if args.plot is True: if nz == 1: dis.plot(sino_list[0], 'Input sinogram') else: nzz = np.int(0.5 * nz) dis.plot(sino_list[nzz], 'Input sinogram') ## Center of rotation axis if args.ctr == -1: ctr = npix * 0.5 elif args.ctr != -1: ctr = args.ctr ## Enable edge padding if args.lt is True: edf = 0.87 elif args.lt is False and args.edge_padding != 0: edf = args.edge_padding else: edf = 0.0 if edf: npix_old = npix for i in range(nz): sino_list[i] = proc.sino_edge_padding(sino_list[i], edf) npix = sino_list[0].shape[1] i1 = myint((npix - npix_old) * 0.5) i2 = i1 + npix_old ctr += i1 print('\nEdge padding: ', edf) print('Number of edge-padded pixels: ', npix) print('Index start: ', i1, ' Index end: ', i2) print('Center of rotation axis new position: ', ctr) if args.plot is True: dis.plot(sino_list[0], 'Sinogram with edge-padding') else: npix_old = npix i1 = 0 i2 = npix ## Correct for the center of rotation axis if args.ctr != -1: for i in range(nz): sino_list[i] = proc.sino_correct_rot_axis(sino_list[i], ctr) print('\nCenter of rotation axis position: ', ctr) print('Center of rotation corrected') ## Get geometry if args.geometry == '0': angles = utils.create_projection_angles(nang) else: angles = utils.create_projection_angles(textfile=pathin + args.geometry) ## Setup iterative procedure print('\nSetup of the iterative procedure:') if nz == 0: labelout = pathout + filein[0][:len(filein[0]) - 4] else: labelout = pathout + filein[0][0][:len(filein[0]) - 4] param = csp.sir_param(nang, npix_old, nz, ctr, labelout, args) print('Selected projector: ', args.projector) if args.eps is not None: print('Stopping threshold: ', param.eps) if args.n_iter is not None: print('Number of iterations: ', param.n_iter) if args.plot is True: print('Interactive plot:', param.plot) if args.logfile is True: print('Interactive plot:', param.logfile) if param.reg is not None: if param.reg == 'huber': print('Regularization type: Huber penalty') print('Huber constant ---> delta: ') elif param.reg == 'tikhonov': print('Regularization type: l2 penalty') elif param.reg == 'haar': print('Regularization type: l1 penalty') print('Regularization constant (beta): ', param.reg_cost) if args.init_object is True: print('Initialization with FBP reconstruction:', param.init_object) ## Reconstruction print('\n\nPerforming STASTICAL ITERATIVE RECONSTRUCTION ....') time1 = time.time() reco_list, info = sir(sino_list, angles, param) time2 = time.time() print('.... reconstruction done!') for i in range(nz): ## Crop reconstruction if edge-padding enabled if edf != 0.0: reco = reco_list[i, i1:i2, i1:i2] else: reco = reco_list[i, :, :] ## Show reconstruction if args.plot is True and nz == 1: dis.plot(reco, 'Reconstruction') elif args.plot is True and i == nzz: dis.plot(reco, 'Reconstruction') ## Save reconstruction if nz == 1: save_reco(pathout, filein[0], args, param, reco) else: save_reco(pathout, filein[0][i], args, param, reco) ## Time elapsed for the reconstruction time_tot = (time2 - time1) / 60.0 print('\nTime elapsed for the reconstruction: ', time_tot) ## Write log file if args.logfile is True: write_logfile(pathin, pathout, args, angles, ctr, param, time_tot, info) write_info(pathout, filein[0], info, param, args) ## Final print print('\n') print('\n') print('##########################################################') print('##########################################################') print('##### #####') print('##### STATISTICAL ITERATIVE RECONSTRUCTION DONE! #####') print('##### #####') print('##########################################################') print('##########################################################') print('\n')
def multi_thread(pathin, pathout, filein, angles, args): image = io.readImage(pathin + filein).astype(myfloat) npix = image.shape[0] tp = cpj.projectors(npix, angles, args=args) sino = tp.A(image) save_sinogram(pathout, filein, angles, args, sino)
def main(): ## Initial print print('\n') print('###########################################################') print('############# FORWARD REGRIDDING PROJECTOR #############') print('###########################################################') print('\n') ## Get the startimg time of the reconstruction time1 = time.time() ## Get input arguments args = getArgs() ## Get input/output directory pathin, pathout = utils.get_io_path(args) print('\nInput path:\n', pathin) print('\nOutput path:\n', pathout) ## Get input files file_list, file1, nimg, ext = utils.get_input(args, pathin) print('\nNumber of input files: ', nimg) print('Extension of the files: ', ext) ## Read first image image = io.readImage(pathin + file1).astype(myfloat) npix = image.shape[0] print('\nFirst image to forward project: ', file1) print('Number of pixels: ', npix) if args.plot is True: dis.plot(image, 'Input image') ## Get projection angles if args.geometry == '0' or args.geometry == '1': nang = args.nang angle_type = myint(args.geometry) if args.angle_range.find(':') == -1 or args.geometry == -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]) angles = utils.create_projection_angles(nang, angle_start, angle_end) else: angles = utils.create_projection_angles(pathin + args.geometry) nang = len(angles) print('\nNumber of views: ', nang) print('Selected angle range: [ ', angle_start, ' , ', angle_end, ' )') print('Angles:\n', angles) ## Initialize projectior class tp = cpj.projectors(npix, angles, args=args) ## Apply forward projection operator time_rec1 = time.time() sino = tp.A(image) time_rec2 = time.time() ## Display sinogram if args.plot is True: dis.plot(sino, 'Sinogram') ## Save sinogram save_sinogram(pathout, file1, angles, args, sino) ## Create sinograms from all the other images in the stack if args.filein is None: pool = mproc.Pool() for i in range(1, nimg): pool.apply_async(multi_thread, (pathin, pathout, file_list[0][i], angles, args)) pool.close() pool.join() time2 = time.time() print('\nTime elapsed to run the 1st forward gridrec: ', time_rec2 - time_rec1) print('Total time elapsed for the run of the program: ', time2 - time1) print('\n') print('#######################################') print('#### FORWARD PROJECTION DONE ! ####') print('#######################################') print('\n')
def main(): print('\nRESCALE IMAGE\n') ## Get input arguments args = getArgs() ## Get input and output path pathin = args.pathin if pathin[len(pathin) - 1] != '/': pathin += '/' if args.pathout is None: pathout = pathin else: pathout = args.pathout if pathout[len(pathout) - 1] != '/': pathout += '/' print('\nInput path:\n', pathin) print('\nOutput path:\n', pathout) ## Get single image if args.image is not None: ## Reading image filein = args.image imagein = io.readImage(pathin + filein) nrows, ncols = imagein.shape[0], imagein.shape[1] print('\nReading image:', filein) print('Image size: ', nrows, ' X ', ncols) ## Check plot if args.plot is True: dis.plot(imagein, 'Input image') ## Make image square if args.square is True: if nrows < ncols: imagein = imagein[:, :nrows] else: imagein = imagein[:ncols, :] ## Rescaled image if args.rescale is not None: rescale = args.rescale nrows_new = int(nrows * rescale) ncols_new = int(ncols * rescale) else: nrows_new = ncols_new = args.npix rescale = nrows_new / myfloat(nrows) image_rescale = rescale_image(imagein, rescale) print('\nRescaled factor: ', rescale) print('Rescaled-image size: ', image_rescale.shape) ## Check plot if args.plot is True: dis.plot(image_rescale, 'Rescaled image -- factor = ' + str(rescale)) ## Write noisy image to file fileout = filein[:len(filein) - 4] + '_pix' if nrows_new < 100: fileout += '00' + str(nrows_new) + '.DMP' elif nrows_new < 1000: fileout += '0' + str(nrows_new) + '.DMP' else: fileout += str(nrows_new) + '.DMP' io.writeImage(pathout + fileout, image_rescale) print('\nWriting rescaled image:', fileout) ## Get bunch of input images elif args.label is not None: curr_dir = os.getcwd() ## Reading images os.chdir(pathin) files = sorted(glob.glob('*' + args.label + '*')) os.chdir(curr_dir) num_im_input = len(files) for i in range(num_im_input): imagein = io.readImage(pathin + files[i]) nrows, ncols = imagein.shape[0], imagein.shape[1] print('\nReading image:\n', files[i]) print('\nImage size: ', nrows, ' X ', ncols) ## Make image square if args.square is True: if nrows < ncols: imagein = imagein[:, :nrows] else: imagein = imagein[:ncols, :] ## Rescaled image if args.rescale is not None: rescale = args.rescale nrows_new = int(nrows * rescale) ncols_new = int(ncols * rescale) else: nrows_new = ncols_new = args.npix rescale = nrows_new / myfloat(nrows) image_rescale = rescale_image(imagein, rescale) print('\nRescaled factor: ', rescale) print('Rescaled-image size: ', image_rescale.shape) ## Write noisy image to file fileout = files[i][:len(files[i]) - 4] + '_pix' if nrows_new < 100: fileout += '00' + str(nrows_new) + '.DMP' elif nrows_new < 1000: fileout += '0' + str(nrows_new) + '.DMP' else: fileout += str(nrows_new) + '.DMP' io.writeImage(pathout + fileout, image_rescale) print('\nWriting rescaled image:', fileout) print('\n\n')
def main(): ## Initial print print('\n') print('########################################################') print('#### CREATE VIRTUAL SINOGRAM ####') print('########################################################') print('\n') ## Get arguments args = getArgs() ## Get input/output directory pathin , pathout = utils.get_io_path( args ) print('\nInput path:\n', pathin) print('\nOutput path:\n', pathout) ## Get input files file_list , file1 , nimg , ext = utils.get_input( args , pathin ) print('\nNumber of input files: ' , nimg) print('Extension of the files: ', ext) ## Read first sinogram sino = io.readImage( pathin + file1 ).astype( myfloat ) nang , npix = sino.shape print('\nSinogram to reconstruct:\n', file1) print('Number of projection angles: ', nang) print('Number of pixels: ', npix) if args.plot is True: dis.plot( sino , 'Input sinogram' ) ## Set center of rotation axis if args.ctr == None: ctr = 0.0 print('Center of rotation axis placed at pixel: ', npix * 0.5) else: ctr = args.ctr print('Center of rotation axis placed at pixel: ', ctr) ## Enable edge-padding if args.edge_pad is True: sino = proc.sino_edge_padding( sino , 0.5 ).astype( myfloat ) i1 = int( ( sino.shape[1] - npix ) * 0.5 ) i2 = i1 + npix npix = sino.shape[1] if ctr != 0.0: ctr += i1 if args.plot is True: dis.plot( sino , 'Edge padded sinogram' ) else: i1 = 0 i2 = npix ## Prepare projectors ang = np.arange( nang ) * 180.0 / myfloat( nang ) tp = cpj.projectors( npix , ang , kernel='kb' , oversampl=2.32 , W=6.6 , errs=6.0e-6 , interp='lin' , radon_degree=0 , filt=args.filt , ctr=ctr ) ## Reconstruct reco = tp.fbp( sino ) if args.plot is True: dis.plot( reco , 'Reconstruction' ) #reco = reco[i1:i2,i1:i2] ## Zero-out pixels outside resolution circle reco_new = reco.copy(); reco_new[:] = 0.0 io.writeImage( 'reco.DMP' , reco[i1:i2,i1:i2] ) reco_new[i1:i2,i1:i2] = utils.resol_circle_constr( reco[i1:i2,i1:i2] ) reco[:] = reco_new[:] if args.plot is True: dis.plot( reco , 'Constrained reconstruction' ) io.writeImage( 'reco_circle.DMP' , reco ) ## Background equalization reco[:] = background_equalization( reco ) if args.plot is True: dis.plot( reco , 'Equalized reconstruction' ) io.writeImage( 'reco_equaliz.DMP' , reco ) ## Forward projection nang_new = np.int( npix * np.pi / 2.0 ) ang_new = np.arange( nang_new ) * 180.0 / np.float32( nang_new ) tp = cpj.projectors( npix , ang_new , kernel='kb' , oversampl=2.32 , W=6.6 , errs=6.0e-6 , interp='lin' , radon_degree=0 ) sino = tp.A( reco ) #sino = sino[:,i1:i2] if args.plot is True: dis.plot( sino , 'Forward projection' ) io.writeImage( 'sino_circle.DMP' , sino ) ## Save output file if args.fileout is None: filein = args.filein extension = filein[len(filein)-4:] fileout = filein[:len(filein)-4] + '_virt.tif' else: fileout = args.fileout io.writeImage( pathout + fileout , sino ) print( '\nWritten output file:\n' , pathout + fileout )
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.linearRegression(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.selectResolutionSquare(image1) image2 = proc.selectResolutionSquare(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.linearRegression(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.selectResolutionSquare(image1) image2 = proc.selectResolutionSquare(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('\n\nTest image number ', i, '\n', image_list[i], '\n') 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(): print('###################################################') print('###### SPLITTING SINOGRAM FOR FRC ANALYSIS ######') print('###################################################') ## Get input arguments args = getArgs() ## Get input and output paths 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) ## Case 1: one sinogram in input if args.sino is not None: ## Handle sinograms print('\nReading sinogram: ',args.sino) sino = io.readImage( pathin + args.sino ) nang = sino.shape[0] print('\nSplitting sinogram in the sinogram with odd- and with' + ' even-projections ....') sino_odd , sino_even = split_sino( sino ) sino_name = args.sino sino_name_odd = sino_name.replace( '.DMP' , '.proj_odd.DMP' ) sino_name_even = sino_name.replace( '.DMP' , '.proj_even.DMP' ) print('\nWriting ',sino_name_odd,' ....' ) io.writeImage( pathout + sino_name_odd , sino_odd ) print('Writing ',sino_name_even,' ....' ) io.writeImage( pathout + sino_name_even , sino_even ) ## Handle projection angle lists if args.geometry is not None: print('\nReading list of projection angles (degrees): ',args.geometry) angle_list = np.loadtxt( pathin + args.geometry ) angle_list_odd , angle_list_even = split_angle_list( angle_list ) list_name = args.geometry list_name_odd = list_name.replace( '.txt' , '.proj_odd.txt' ) list_name_even = list_name.replace( '.txt' , '.proj_even.txt' ) else: print('\nCreating lists of projection angles') angle_list_odd , angle_list_even = create_angle_list( nang ) list_name_odd = sino_name.replace( '.DMP' , '.proj_odd.txt' ) list_name_even = sino_name.replace( '.DMP' , '.proj_even.txt' ) print('Writing ',list_name_odd,' ....' ) np.savetxt( pathout + list_name_odd , angle_list_odd ) print('Writing ',list_name_even,' ....' ) np.savetxt( pathout + list_name_even , angle_list_even ) ## Case 2: all sinogram in input folder elif args.allin is True: curr_dir = os.getcwd() os.chdir( pathin ) sino_list = sorted( glob.glob( '*.DMP' ) ) if args.geometry == 'a': angle_file_list = sorted( glob.glob( '*.txt' ) ) os.chdir( curr_dir ) nsino = len( sino_list ) print('\nNumber of sinograms in input folder: ', nsino) for f in range( nsino ): print('\nReading sinogram: ', sino_list[f] ) sino = io.readImage( pathin + sino_list[f] ) nang = sino.shape[0] print('\nSplitting sinogram in the sinogram with odd- and with' + ' even-projections ....') sino_odd , sino_even = split_sino( sino ) sino_name = sino_list[f] sino_name_odd = sino_name.replace( '.DMP' , '.proj_odd.DMP' ) sino_name_even = sino_name.replace( '.DMP' , '.proj_even.DMP' ) print('\nWriting ',sino_name_odd,' ....' ) io.writeImage( pathout + sino_name_odd , sino_odd ) print('Writing ',sino_name_even,' ....' ) io.writeImage( pathout + sino_name_even , sino_even ) if args.geometry == 'a': print('\nReading list of projection angles (degrees): ', angle_file_list[f]) angle_list = np.loadtxt( pathin + angle_file_list[f] ) print('\nSplitting angle lists between odd-indexed and with' + ' even-indexed angles ....') angle_list_odd , angle_list_even = split_angle_list( angle_list ) list_name = angle_file_list[f] list_name_odd = list_name.replace( '.txt' , '.proj_odd.txt' ) list_name_even = list_name.replace( '.txt' , '.proj_even.txt' ) else: print('\nCreating lists of projection angles') angle_list_odd , angle_list_even = create_angle_list( nang ) list_name_odd = sino_name.replace( '.DMP' , '.proj_odd.txt' ) list_name_even = sino_name.replace( '.DMP' , '.proj_even.txt' ) print('Writing ',list_name_odd,' ....' ) np.savetxt( pathout + list_name_odd , angle_list_odd ) print('Writing ',list_name_even,' ....' ) np.savetxt( pathout + list_name_even , angle_list_even ) print('\n#######################################################\n') print('\n###### END SPLITTING SINOGRAM FOR FRC ANALYSIS ######\n') print('\n#######################################################\n')
def __init__(self, npix, nang, nz, ctr, labelout, args): ## Entries with no check self.ctr = ctr self.nang = nang self.nz = nz self.n_iter = args.n_iter self.n_iter_pcg = args.n_iter_pcg self.eps = args.eps self.plot = args.plot self.logfile = args.logfile self.init_object = args.init_object self.pc = args.pc self.mask = [] self.lt = args.lt self.num_cores = args.num_cores ## Tomographic projectors self.projector = args.projector ## Enable DPC reconstruction if args.dpc is True or args.dbp is True: self.radon_degree = 1 else: self.radon_degree = 0 ## Check point if self.radon_degree == 1: if self.projector == 'pix-driv' or self.projector == 'ray-driv' \ or self.projector == 'dist-driv': sys.exit( '\nERROR: selected projector ' + self.projector + \ ' cannot be used for differentiated tomography!!\n') ## Handling regularization if args.reg is not None: self.reg = args.reg if args.param is None: if self.reg == 'lasso' or self.reg == 'lasso-tv': param = '1.0:1.0:1.0' elif self.reg == 'pp-breg': param = '1.0:100.0:1.0' elif self.reg != 'cg': param = args.param ## Handling parameters if self.reg != 'cg': param = param.split(':') self.lambd1 = myfloat(param[0]) self.lambd2 = myfloat(param[1]) self.mu = myfloat(param[2]) self.relax = 1.0 self.z1 = args.inner_padding ## Handling edge padding if args.lt is True: pad_factor = 0.87 elif args.lt is False and args.edge_padding: pad_factor = args.edge_padding else: pad_factor = 0.0 if pad_factor == 0: self.index_start = 0 self.index_end = npix self.edge_padding = False self.npix_op = npix else: npad = int(pad_factor * npix) npix_new = npix + 2 * npad self.index_start = myint(0.5 * (npix_new - npix)) self.index_end = self.index_start + npix self.edge_padding = True self.npix_op = npix_new ## Output name root if self.reg != 'cg': root = '_admm' if self.reg == 'lasso': root += '_lasso' elif self.reg == 'lasso-tv': root += '_lassotv' elif self.reg == 'pp-breg': root += '_ppbreg' elif args.reg == 'pp-rof': root += '_pprof' elif args.reg == 'pp-breg': root += '_ppbreg' elif args.reg == 'pp-chamb': root += '_ppchamb' elif args.reg == 'pp-nlmeans': root += '_ppnlmeans' elif args.reg == 'pp-tgv': root += '_pptgv' elif args.reg == 'pp-nltv': root += '_ppnltv' string = '_lambd1_' + str( self.lambd1 ) + \ '_lambd2_' + str( self.lambd2 ) + \ '_mu_' + str( self.mu ) root += string else: root = '_cgls' if self.projector == 'grid-kb': root += '_grid_kb' elif self.projector == 'grid-pswf': root += '_grid_pswf' elif self.projector == 'bspline': root += '_bspline' elif self.projector == 'radon': root += '_radon' elif self.projector == 'pix-driv': root += '_pd' elif self.projector == 'ray-driv': root += '_rd' elif self.projector == 'dist-driv': root += '_dd' self.root = root ## Saving each iteration result for analysis if args.checkit is not None: self.checkit = True path_rmse = '_rmse_folder' path_rmse = args.checkit + path_rmse + '/' if not os.path.exists(path_rmse): os.makedirs(path_rmse) else: shutil.rmtree(path_rmse) os.makedirs(path_rmse) self.path_rmse = path_rmse else: self.checkit = False ## Object support if args.mask is not None: self.mask = io.readImage(args.mask).astype(np.uint8) else: self.mask = None ## Additional masks if args.mask_add is not None: if args.mask_add.find(',') != -1: files = args.mask_add.split(',') nfiles = len(files) self.mask_add = [] for i in range(nfiles): self.mask_add.append( io.readImage(files[i]).astype(np.uint8)) self.mask_add_n = nfiles else: files = args.mask_add nfiles = 1 self.mask_add = [] self.mask_add.append(io.readImage(files).astype(np.uint8)) self.mask_add_n = nfiles else: self.mask_add = None
def main(): ## Initial print print('\n') print('########################################################') print('### NN-FBP RECONSTRUCTION ###') print('########################################################') print('\n') ## Read config file if len( sys.argv ) < 2: sys.exit( '\nERROR: Missing input config file .cfg!\n' ) else: cfg_file = open( sys.argv[1] , 'r' ) exec( cfg_file ) cfg_file.close() ## Get trained filters train_path = utils.analyze_path( train_path , mode='check' ) ft = np.load( train_path + file_trained_filters ) print( '\nRead file of trained filters:\n' , train_path + file_trained_filters ) ## Get low-quality sinograms cwd = os.getcwd() target_path = utils.analyze_path( target_path , mode='check' ) os.chdir( target_path ) file_list = [] file_list.append( sorted( glob.glob( '*' + input_files_lq + '*' ) ) ) os.chdir( cwd ) nfiles = len( file_list ) if nfiles == 0: sys.exit( '\nERROR: No file *' + input_files_lq + '* found!\n' ) ## Check/create output path output_path = utils.analyze_path( output_path , mode='create' ) ## Read one sinogram sino = io.readImage( target_path + file_list[0][0] ) nang , npix = sino.shape ## Create angles angles = utils.create_projection_angles( nang=nang ) ## Create filters fW = ft['filters'] weights = ft['weights'] offsets = ft['offsets'] minIn = ft['minIn'] maxIn = ft['maxIn'] fsize = 2 * ( 2**int( np.ceil( np.log2( npix ) ) ) ) basis = utils.generateFilterBasis( fsize , 2 ).astype( myfloat ) NHidden = fW.shape[0] filters = np.zeros( ( NHidden , fsize )) for i in xrange( NHidden ): for j in xrange( basis.shape[0] ): filters[i] += basis[j] * fW[i,j] ## Reconstruct low-quality sinograms print( '\nNN-FBP reconstruction ....' ) ncores_avail = mproc.cpu_count if ncores > ncores_avail: ncores = ncores_avail pool = mproc.Pool( processes=ncores ) for i in range( nfiles ): pool.apply_async( reconstr_nnfbp , ( target_path , output_path , file_list[0][i] , angles , ctr_lq , weights , offsets , minIn , maxIn , NHidden , filters ) ) pool.close() pool.join() #for i in range( nfiles ): # reconstr_nnfbp( target_path , output_path , file_list[0][i] , angles , ctr_lq , # weights , offsets , minIn , maxIn , NHidden , filters ) print( '\n' )
def main(): ## Initial print print('\n') print('########################################################') print('### CREATING TRAINING DATASET ###') print('########################################################') print('\n') ## Read config file if len(sys.argv) < 2: sys.exit('\nERROR: Missing input config file .cfg!\n') else: cfg_file = open(sys.argv[1], 'r') exec(cfg_file) cfg_file.close() ## Get list of input files cwd = os.getcwd() input_path = utils.analyze_path(input_path, mode='check') os.chdir(input_path) file_list = [] file_list.append(sorted(glob.glob('*' + input_files_hq + '*'))) os.chdir(cwd) nfiles = len(file_list[0]) if nfiles == 0: sys.exit('\nERROR: No file *' + input_files_hq + '* found!\n') train_path = utils.analyze_path(train_path, mode='create') print('\nInput data folder:\n', input_path) print('\nTrain data folder:\n', train_path) print('\nInput high-quality sinograms: ', nfiles) ## Read one file sino = io.readImage(input_path + file_list[0][0]) nang, npix = sino.shape print('\nSinogram(s) with ', nang, ' views X ', npix, ' pixels') ## Create array of projection angles angles = utils.create_projection_angles(nang=nang) ## Compute number of views for low-quality training sinograms factor = nang / (nang_lq * 1.0) print('\nDownsampling factor for training sinograms: ', factor) ## Create customized filters print('\nCreating customized filters ....') filt_size = 2 * (2**int(np.ceil(np.log2(npix)))) filt_custom = utils.generateFilterBasis(filt_size, 2) nfilt = filt_custom.shape[0] ## Region of interest to select training data idx = utils.getIDX(npix, roi_l, roi_r, roi_b, roi_t) nh = np.int(npix * 0.5) l = np.abs(roi_l) ## Create training dataset print('\nCreating training dataset ....', end='') ncores_avail = mproc.cpu_count if ncores > ncores_avail: ncores = ncores_avail for i in range(nfiles): ## Read high-quality sinogram sino_hq = io.readImage(input_path + file_list[0][i]).astype(myfloat) ## Reconstruct high-quality sinogram with standard filter reco_hq = utils.fbp(sino_hq, angles, [ctr_hq, 1.0], None) ## Create output training array train_data = np.zeros((npix_train_slice, nfilt + 1), dtype=myfloat) ## Randomly select training pixels picked = utils.getPickedIndices(idx, npix_train_slice) ## Save validation data #train_data[:,-1] = reco_hq[picked] train_data[:, -1] = reco_hq[nh - l:nh + l, nh - l:nh + l].reshape(-1) ## Downsample sinogram sino_lq, angles_lq = utils.downsample_sinogram_angles( sino_hq, angles, nang_lq) ## Reconstruct low-quality sinograms with customized filters #pool = mproc.Pool( processes=ncores ) #results = [ pool.apply_async( reconstr_filter_custom , # args=( sino_lq , angles_lq , ctr_hq , filt_custom[j,:] , picked ) ) \ # for j in range( nfilt ) ] #train_data[:,:nfilt] = np.array( [ res.get() for res in results ] ).reshape( npix_train_slice , nfilt ) #pool.close() #pool.join() for j in range(nfilt): train_data[:, j] = reconstr_filter_custom(sino_lq, angles_lq, ctr_hq, filt_custom[j, :], picked, nh, l) ## Save training data filename = file_list[0][i] fileout = train_path + filename[:len(filename) - 4] + '_train.npy' np.save(fileout, train_data) print('\nTraining data saved in:\n', fileout) #filename = file_list[0][i] #fileout = train_path + filename[:len(filename)-4] + '_reco.DMP' #io.writeImage( fileout , reco_hq ) print('\n')
def main(): ## Initial print print('\n') print('##################################################################') print('############# TOMOGRAPHIC GRIDDING RECONSTRUCTION #############') print('##################################################################') print('\n') ## Get the startimg time of the reconstruction time1 = time.time() ## Get input arguments args = getArgs() ## Get input/output directory pathin, pathout = utils.get_io_path(args) print('\nInput path:\n', pathin) print('\nOutput path:\n', pathout) ## Get input files file_list, file1, nimg, ext = utils.get_input(args, pathin) print('\nNumber of input files: ', nimg) print('Extension of the files: ', ext) ## Read first sinogram sino = io.readImage(pathin + file1).astype(myfloat) nang, npix = sino.shape print('\nSinogram to reconstruct:\n', file1) print('Number of projection angles: ', nang) print('Number of pixels: ', npix) if args.plot is True: dis.plot(sino, 'Input sinogram') ## Enable edge padding if args.edge_pad is True: sino = proc.sino_edge_padding(sino, 0.5).astype(myfloat) i1 = int((sino.shape[1] - npix) * 0.5) i2 = i1 + npix npix = sino.shape[1] ctr = args.ctr if ctr != 0.0: ctr += i1 if args.plot is True: dis.plot(sino, 'Edge padded sinogram') else: i1 = 0 i2 = npix ctr = args.ctr ## Getting projection geometry if args.geometry == '0': print( '\nDealing with equiangular projections distributed between 0 and' + ' 180 degrees ---> [0,180)') angles = utils.create_projection_angles(nang) else: print('\nReading list of projection angles:\n', pathin + args.geometry) angles = utils.create_projection_angles(textfile=pathin + args.geometry) if args.plot is True: print('\nProjection angles:') pp.printArray(angles) ## Enable object support calculation if args.object_support is True: print('\nObject support calculation enabled') mask = ob.object_support(sino) if args.plot is True: dis.plot(mask, 'Object support mask') ## Differential sinogram fo DBP if args.dbp is True: print('\nDifferential backprojection enabled') print( 'Computing differential sinogram by means of Savitzky-Golay method' ) sino[:, :] = proc.diff_sino_savitzky_golay(sino, window_size=11) if args.plot is True: dis.plot(sino, 'Differential sinogram') ## Initialize projectior class tp = cpj.projectors(npix, angles, ctr=ctr, args=args) ## Apply forward projection operator time_rec1 = time.time() reco = tp.fbp(sino) time_rec2 = time.time() ## Crop reconstruction if args.edge_pad: reco = reco[i1:i2, i1:i2] ## Apply object support mask if args.object_support is True: reco[mask == 0] = 0.0 ## Display reconstruction if args.plot is True: dis.plot(reco, 'Reconstruction') ## Save reconstruction save_reconstruction(pathout, file1, args, reco) ## Reconstruct sinograms from all the other images in the stack if args.filein is None: pool = mproc.Pool() for i in range(1, nimg): pool.apply_async( multi_thread, (pathin, pathout, file_list[0][i], args, [i1, i2])) pool.close() pool.join() time2 = time.time() print('\nTime elapsed to run the 1st backward gridrec: ', time_rec2 - time_rec1) print('Total time elapsed for the run of the program: ', time2 - time1) print('\n') print('##############################################') print('#### GRIDDING RECONSTRUCTION DONE ! ####') print('##############################################') print('\n')
def main(): ## Initial print print('\n') print('########################################################') print('### CREATING TRAINING DATASET ###') print('########################################################') print('\n') ## Read config file if len( sys.argv ) < 2: sys.exit( '\nERROR: Missing input config file .cfg!\n' ) else: cfg_file = open( sys.argv[1] , 'r' ) exec( cfg_file ) cfg_file.close() ## Get list of input files cwd = os.getcwd() input_path = utils.analyze_path( input_path , mode='check' ) os.chdir( input_path ) file_list = [] file_list.append( sorted( glob.glob( '*' + input_files_hq + '*' ) ) ) os.chdir( cwd ) nfiles = len( file_list[0] ) if nfiles == 0: sys.exit( '\nERROR: No file *' + input_files_hq + '* found!\n' ) if train_path == input_path: train_path = utils.analyze_path( train_path , mode='check' ) else: train_path = utils.analyze_path( train_path , mode='create_new' ) print( '\nInput data folder:\n' , input_path ) print( '\nTrain data folder:\n' , train_path ) print( '\nInput high-quality sinograms: ' , nfiles ) ## Read one file sino = io.readImage( input_path + file_list[0][0] ) nang , npix = sino.shape print( '\nSinogram(s) with ' , nang ,' views X ' , npix, ' pixels' ) ## Create array of projection angles angles = utils.create_projection_angles( nang=nang ) ## Compute number of views for low-quality training sinograms factor = nang / ( nang_lq * 1.0 ) print( '\nDownsampling factor for training sinograms: ' , factor ) ## Create customized filters print( '\nCreating customized filters ....' ) filt_size = 2 * ( 2**int( np.ceil( np.log2( npix ) ) ) ) filt_custom = utils.generateFilterBasis( filt_size , 2 ) nfilt = filt_custom.shape[0] ## Region of interest to select training data idx = utils.getIDX( npix , roi_l , roi_r , roi_b , roi_t ) nh = np.int( npix * 0.5 ); l = np.abs( roi_l ) ## Create training dataset print( '\nCreating training dataset ....' ) ncores_avail = mproc.cpu_count() if ncores > ncores_avail: ncores = ncores_avail print( 'Working with ncores: ' , ncores ) if slice_ind_1 > 0 and slice_ind_1 <= nfiles: ind_1 = slice_ind_1 else: ind_1 = 0 if slice_ind_2 > 0 and slice_ind_2 <= nfiles: ind_2 = slice_ind_2 else: ind_2 = nfiles if take_every <= 0 or take_every >= (ind_2-ind_1): take_every = 1 print( 'Start slice index: ' , ind_1 ) print( 'End slice index: ' , ind_2 ) print( 'Use 1 slice every ', take_every,' slices' ) pool = mproc.Pool( processes=ncores ) for i in range( ind_1 , ind_2 , take_every ): pool.apply_async( create_training_file , ( input_path , train_path , file_list[0][i] , angles , npix_train_slice , idx , nang_lq , ctr_hq , nfilt , filt_custom , filt , debug ) ) pool.close() pool.join()
def main(): ## Get input arguments args = get_args() ## Start print if args.analysis == 'frc': print('\n') print('#############################################################') print('############ FOURIER RING CORRELATION ANALYSIS ############') print('#############################################################') print('\n') else: print('\n') print('##############################################################') print('############ FOURIER SHELL CORRELATION ANALYSIS ############') print('##############################################################') print('\n') ## Get input and output folder pathin = args.pathin if pathin[len(pathin)-1] != '/': pathin += '/' pathout = args.pathout if pathout[len(pathout)-1] != '/': pathout += '/' if os.path.exists( pathout ) is False: os.mkdir( pathout ) print('\nInput folder:\n', pathin) print('\nOutput folder:\n', pathout) ## Check whether you are working with .tif or .DMP images extension = None for root, dirs, files in os.walk( pathin ): for file in files: if file.endswith( '.tif' ): extension = '.tif' elif file.endswith( '.DMP' ): extension = '.DMP' if extension is None: sys.exit( 'ERROR: No .tif or .DMP file found in:\n ' + pathin ) else: print('\nWorking with ', extension,' images') ## Get stack of input even and odd images files_even = sorted( glob.glob( pathin + '*even*' + extension ) ) files_odd = sorted( glob.glob( pathin + '*odd*' + extension ) ) if len( files_even ) != len( files_odd ): sys.exit( '\nNumber of "even" images (' + str( len( files_even ) ) + ')' \ ' the number od odd images (' + str( len( files_odd ) ) + ')' ) else: n_img = len( files_even ) #n_img = 1 print('\nNumber of input image pair: ', n_img) stack_even = []; stack_odd = [] print('\nReading stacks of images ....') progress = pb.AnimatedProgressBar(end=n_img, width=50) for i in range( n_img ): stack_even.append( io.readImage( files_even[i] ).astype( myfloat ) ) stack_odd.append( io.readImage( files_odd[i] ).astype( myfloat ) ) progress + 1 progress.show_progress() print('.... done!') nrows = stack_even[0].shape[0] ncols = stack_even[0].shape[1] print('\nNumber of input image pair: ', n_img) print('Size of each image: ', nrows,' X ', ncols ) ## Select resolution square for each image if args.resol_square is True: print('\nCalculation enabled in the resolution square') print('Cropping images ....') progress = pb.AnimatedProgressBar( end=n_img , width=50 ) for i in range( n_img ): aux_even = stack_even[i] aux_odd = stack_odd[i] aux_even = proc.selectResolutionSquare( aux_even ) aux_odd = proc.selectResolutionSquare( aux_odd ) stack_even[i] = aux_even stack_odd[i] = aux_odd progress + 1 progress.show_progress() print('.... done!') ## Select resolution square for each image if args.hanning is True: print('\nOption hanning pre-filter activated') progress = pb.AnimatedProgressBar( end=n_img , width=50 ) window = np.hanning( stack_even[i].shape[0] ) window = np.outer( window , window ) for i in range( n_img ): aux_even = stack_even[i] aux_odd = stack_odd[i] aux_even *= window aux_odd *= window stack_even[i] = aux_even stack_odd[i] = aux_odd progress + 1 progress.show_progress() ## Do analysis print('\nAnalysis with ring thickness: ', args.width_ring) if args.analysis == 'frc': prefix = sb.get_prefix( files_even , files_odd ) pool = mproc.Pool() for i in range( n_img ): #pool.apply_async( analysis , ( stack_even[i] , stack_odd[i] , # args , pathout , prefix[i] ) ) analysis( stack_even[i] , stack_odd[i] , args , pathout , prefix[i] ) pool.close() pool.join() elif args.analysis == 'fsc': prefix = sb.get_prefix_stack( files_even , files_odd ) stack_even = np.array( stack_even ) stack_odd = np.array( stack_odd ) analysis( stack_even , stack_odd , args , pathout , prefix ) ## End print if args.analysis == 'frc': print('\n') print('#################################################################') print('############ FOURIER RING CORRELATION ANALYSIS END ############') print('#################################################################') print('\n') else: print('\n') print('##################################################################') print('############ FOURIER SHELL CORRELATION ANALYSIS END ############') print('##################################################################') print('\n')
def main(): print('\nADD 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, '\n') 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 if args.noise == 'gaussian': 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) elif args.noise == 'poisson': nimg = 1 else: sys.exit('\nERROR: Noise type "' + args.noise + '" is not an option available with this routine!\n') ## 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' write_output_image(pathout, filein, image_noisy, label, sigma=sigma_list[im]) elif args.noise == 'poisson': image_noisy = add_poisson_noise(imagein) label = 'poiss' write_output_image(pathout, filein, image_noisy, label) ## 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') 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') ## 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) if sigma == 0: sigma = 1.0 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) ## Add noise ## Loop on each gaussian sigma if args.noise == 'gaussian': for im in range(nimg): ## Loop on each gaussian sigma image_noisy = add_gaussian_noise(imagein, sigma_arr[im]) label = 'gauss' write_output_file(pathout, files[i], image_noisy, label, sigma=sigma_arr[im]) elif args.noise == 'poisson': image_noisy = add_poisson_noise(imagein) label = 'poiss' write_output_file(pathout, files[i], image_noisy, label) print('\n\n')