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 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('############# 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(): ## 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(): ## 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 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(): ## 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(): ## 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')