def save_sinogram(pathout, filein, angles, args, sino): nang = len(angles) if args.fileout is None or args.filein is None: filename = filein extension = filename[len(filename) - 4:] filename = filename[:len(filename) - 4] nang = args.nang if nang < 10: str_nang = '000' + str(nang) elif nang < 100: str_nang = '00' + str(nang) elif nang < 1000: str_nang = '0' + str(nang) else: str_nang = str(nang) filename += '_ang' + str_nang if args.dpc is True: filename += '_dpc' if args.full_output is True: if args.geometry == '0': filename += '_polar' elif args.geometry == '1': filename += '_pseudo' else: filename += '_text' filename += '_' + args.kernel + '_' + args.kernel_interp oversampl = int(np.round(args.zero_pad * 1000)) filename += '_oversampl' + str(oversampl) filename += '_sino' + extension else: filename = args.fileout filename = pathout + filename print('\nWriting sinogram in:\n', filename) io.writeImage(filename, sino) ## Save list of projection angles if args.list_ang is True: listang = filename[:len(filename) - 4] listang += '_ang' + str(nang) + '_list.txt' print('\nWriting list of projection angles:\n', listang) fd = open(listang, 'w') for i in range(len(angles)): fd.write('%.8f\n' % angles[i]) fd.close()
def save_sinogram(pathout, filein, angles, args, sino): nang = len(angles) if args.fileout is None or args.filein is None: filename = filein extension = filename[len(filename) - 4:] filename = filename[:len(filename) - 4] nang = args.nang if nang < 10: str_nang = "000" + str(nang) elif nang < 100: str_nang = "00" + str(nang) elif nang < 1000: str_nang = "0" + str(nang) else: str_nang = str(nang) filename += "_ang" + str_nang if args.dpc is True: filename += "_dpc" if args.full_output is True: if args.geometry == "0": filename += "_polar" else: filename += "_text" filename += "_" + args.kernel + "_" + args.kernel_interp oversampl = int(np.round(args.zero_pad * 1000)) filename += "_oversampl" + str(oversampl) filename += "_sino" + extension else: filename = args.fileout filename = pathout + filename print("\nWriting sinogram in:\n", filename) io.writeImage(filename, sino) ## Save list of projection angles if args.list_ang is True: listang = filename[:len(filename) - 4] listang += "_ang" + str(nang) + "_list.txt" print("\nWriting list of projection angles:\n", listang) fd = open(listang, "w") for i in range(len(angles)): fd.write("%.8f\n" % angles[i]) fd.close()
def write_output_file(pathout, filein, image_blur, sigma): ext = filein[len(filein) - 4:] fileout = filein[:len(filein) - 4] + '_blur' if sigma < 10: fileout += '00' + str(int(sigma)) elif sigma < 100: fileout += '0' + str(int(sigma)) else: fileout += str(int(sigma_arr[im])) fileout = pathout + fileout + ext io.writeImage(fileout, image_blur) print('\nOutput image written in:\n', fileout, '\n')
def function1( array2D , n_slice , path ): fft_array = np.fft.fft2( array2D ) if n_slice < 10: string = '000' + str( n_slice ) elif n_slice < 100: string = '00' + str( n_slice ) elif n_slice < 1000: string = '0' + str( n_slice ) else: string = str( n_slice ) io.writeImage( path + string + '_real.DMP' , np.real( fft_array ) ) io.writeImage( path + string + '_imag.DMP' , np.imag( fft_array ) )
def save_reco(pathout, filein, args, param, reco): if args.reco is not None: filename = pathout + args.reco else: filename = filein extension = filename[len(filename) - 4:] filename = filename[:len(filename) - 4] filename += param.root filename += extension filename = pathout + filename io.writeImage(filename, reco) print('\nReconstruction saved in:\n', filename)
def saveReco( reco , pathin , pathout , args ): ## Get output directory if os.path.exists( pathout ) is False: print('\nOutput directory ', pathout,' does not exist ---> created!') os.makedirs( pathout ) print('\nOutput directory:\n', pathout) ## Save output file filename = args.sino filename = filename[:len(filename)-4] filename += '_grid_rec.DMP' filename = pathout + filename io.writeImage( filename , reco )
def write_output_image(pathout, filein, image_noisy, label, sigma=None): ext = filein[len(filein) - 4:] fileout = filein[:len(filein) - 4] + '_noise_' + label if label == 'gaussian': if sigma < 1: fileout += '000' + str(int(sigma * 10)) elif sigma < 10: fileout += '00' + str(int(sigma * 10)) + '0' elif sigma < 100: fileout += '0' + str(int(sigma * 10)) + '0' else: fileout += str(int(sigma * 10)) + '0' fileout += ext fileout = pathout + fileout io.writeImage(fileout, image_noisy) print('\nOutput image written in:\n', fileout)
def saveReco( reco , pathin , args ): ## Get output directory if args.pathout is None: pathout = pathin else: pathout = args.pathout if os.path.exists( pathout ) is False: print('\nOutput directory ', pathout,' does not exist ---> created!') os.makedirs( pathout ) print('\nOutput directory:\n', pathout) ## Save output file filename = args.sino filename = filename[:len(filename)-4] filename += '_est_rec.DMP' filename = pathout + filename io.writeImage( filename , reco )
def reconstr_filter_custom( sino , angles , ctr , filt_custom , picked , debug , train_path , filein , ind ): ## Prepare filter n = len( filt_custom ) nh = np.int( 0.5 * n ) filt = np.zeros( len( filt_custom ) , dtype=myfloat ) filt[::2] = filt_custom[:nh] ## Reconstruction reco = utils.fbp( sino , angles , [ctr,0.0] , filt ) ## Debugging save high- and low-quality reconstructions if debug is True: filedbg = filein ext = filedbg[len(filedbg)-4:] filedbg += '_lq0' + str( ind ) + ext io.writeImage( train_path + filedbg , reco ) ## Pick up only selected pixels reco = reco[ picked ] return reco
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 save_reconstruction(pathout, filein, args, reco): if args.fileout is None: filename = filein extension = filename[len(filename) - 4:] filename = filename[:len(filename) - 4] if args.full_output is True: filename += '_' + args.kernel + '_' + args.kernel_interp oversampl = int(np.round(args.zero_pad * 1000)) filename += '_oversampl' + str(oversampl) if args.dbp is True: filename += '_dbp' filename += '_reco' + extension else: filename = args.fileout filename = pathout + filename print('\nWriting reconstruction in:\n', filename) io.writeImage(filename, reco)
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('### 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 write_output_file(array, mode, args): ## Get path path = args.path if path[len(path) - 1] != '/': path += '/' ## Get degree deg = args.degree str_deg = '_deg' + str(deg) ## String for number of pixels npix = args.npix if npix < 10: common = '000' + str(npix) elif npix < 100: common = '00' + str(npix) elif npix < 1000: common = '0' + str(npix) else: common = str(npix) ## Save phantom if mode == 'image': if args.fileout is None: filename = path + 'radial_phantom' else: name = args.fileout filename = path + name + '_pix' filename += common + str_deg + args.file_format io.writeImage(filename, array) print('\nWriting sinogram in:\n', filename) ## Save sinogram elif mode == 'sinogram': nang = args.nang if args.fileout is None: filename = path + 'radial_phantom' + common + '_ang' else: name = args.fileout filename = path + name + '_pix' + common + '_ang' string = '_rt_anal_sino' if args.dpc is True: string += '_dpc' if nang < 10: filename += '000' + str(nang) elif nang < 100: filename += '00' + str(nang) elif nang < 1000: filename += '0' + str(nang) else: filename += str(nang) filename += string + str_deg + args.file_format io.writeImage(filename, array) print('\nWriting sinogram in:\n', filename)
def plug_and_play(x, b, tp, param): ## Parameters n = param.npix_op nz = param.nz lambd1 = param.lambd1 lambd2 = param.lambd2 mu = param.mu n2 = param.n_iter_pcg it = 0 err = 1e20 info = [] ## Set stopping criterion if param.eps is None: eps = 1e-10 else: eps = param.eps if param.n_iter is None: n1 = 200 else: n1 = param.n_iter ## Reconstruction indices if param.edge_padding != 0.0: i1 = param.index_start i2 = param.index_end else: i1 = 0 i2 = n u = np.zeros((nz, n, n), dtype=myfloat) ## Initialize plot if param.plot is True: fig = plt.figure() ax = fig.add_subplot(111) if nz == 1: Ln = ax.imshow(x[0, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) else: nzz = np.int(nz * 0.5) Ln = ax.imshow(x[nzz, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) plt.ion() ## Start main loop while it < n1 and err > eps: print('\nADMM-PP --- iteraz. n.: ', it) # --- step 0 if it == 0: #u = np.zeros( ( nz , n , n ) , dtype=myfloat ) alpha = u.copy() x_old = x.copy() ## --- step 1 x_old[:] = x.copy() if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( cg.cg_plug_and_play , args=( x[i,:,:] , b[i,:,:] , tp , n2 , ( u - alpha )[i,:,:] , lambd1 , mu , i , ) ) \ for i in range( nz ) ] x[:] = np.array([res.get() for res in results]) pool.close() pool.join() if param.mask is True: for i in range(nz): x[i, param.mask[i] == 0.0] = 0.0 elif param.pc >= 0.0: if param.pc >= 0.0: if param.pc == 1.0: x[:, i1:i2, i1:i2] = utils.phys_constr(x[:, i1:i2, i1:i2], 0.0) x[:, i1:i2, i1:i2] = utils.resol_circle_constr(x[:, i1:i2, i1:i2]) if param.pc == 2.0: x[:, i1:i2, i1:i2] = utils.resol_circle_constr(x[:, i1:i2, i1:i2]) else: x[:, i1:i2, i1:i2] = utils.phys_constr(x[:, i1:i2, i1:i2], param.pc) ## --- step 2 if nz > 1: if param.reg == 'pp-breg': u[:, i1:i2, i1:i2] = den.tv_breg( x[:, i1:i2, i1:i2] + alpha[:, i1:i2, i1:i2], lambd2 / mu) elif param.reg == 'pp-chamb': u[:, i1:i2, i1:i2] = den.tv_chamb( x[:, i1:i2, i1:i2] + alpha[:, i1:i2, i1:i2], lambd2 / mu) elif param.reg == 'pp-nlmeans': u[:, i1:i2, i1:i2] = den.nl_means( x[:, i1:i2, i1:i2] + alpha[:, i1:i2, i1:i2], lambd2 / mu) elif param.reg == 'pp-tgv': x_aux = x + alpha param1 = lambd2 / mu param2 = beta = lambd2 / mu if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( plug_and_play_tgv_fast , args=( x_aux[i,:,:] , param1 , param2 ) ) \ for i in range( nz ) ] x[:] = np.array([res.get() for res in results]) pool.close() pool.join() elif param.reg == 'pp-nltv': x_aux = x + alpha if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( plug_and_play_nltv , args=( x_aux[i,:,:] , lambd2 , mu ) ) \ for i in range( nz ) ] x[:] = np.array([res.get() for res in results]) pool.close() pool.join() elif nz == 1: if param.reg == 'pp-breg': u[0, i1:i2, i1:i2] = den.tv_breg((x + alpha)[0, i1:i2, i1:i2], lambd2 / mu) elif param.reg == 'pp-chamb': u[0, i1:i2, i1:i2] = den.tv_chamb((x + alpha)[0, i1:i2, i1:i2], lambd2 / mu) elif param.reg == 'pp-nlmeans': u[0, i1:i2, i1:i2] = den.nl_means((x + alpha)[0, i1:i2, i1:i2], h=lambd2 / mu) elif param.reg == 'pp-tgv': u[0, i1:i2, i1:i2] = den.tgv_fast((x + alpha)[0, i1:i2, i1:i2], alpha=lambd2 / mu, beta=lambd2 / mu, niter=5) elif param.reg == 'pp-nltv': u[0, i1:i2, i1:i2] = den.nltv_sb((x + alpha)[0, i1:i2, i1:i2], lambd=1.0, ps=5, ws=11, h=lambd2 / mu, nn=10, icn=1, mu=1.0, niter1=4, niter2=2) ## --- step 3 r = x - u diff = x - x_old alpha += r ## --- step 4 diff = np.linalg.norm(x[0, :, :] - x_old[0, :, :]) err = np.linalg.norm(r) tmp = np.sqrt(cg.G(x[0, :, :])[0]**2 + cg.G(x[0, :, :])[1]**2) obj_0 = np.linalg.norm(tmp.reshape(-1), 0) obj_1 = np.linalg.norm(tp.A(x[0, :, :]) - b[0, :, :])**2 obj_2 = np.linalg.norm(x[0, :, :]) obj_3 = np.linalg.norm(tmp, 1) obj = 0.5 * obj_1 + 0.5 * lambd1 * obj_2 + lambd2 * obj_3 if param.checkit is True: if param.projector == 'grid-pswf' or param.projector == 'grid-kb': x_aux = x[0, i1:i2, i1:i2].copy() elif param.projector == 'radon': x_aux = x[0, i2:i1:-1, i2:i1:-1].copy() elif param.projector == 'bspline': x_aux = bfun.convert_from_bspline_to_pixel_basis( x[0, i2:i1:-1, i2:i1:-1], 3) if it < 10: niter = '00' + str(it) elif it < 100: niter = '0' + str(it) else: niter = str(it) io.writeImage(param.path_rmse + 'reco_iter' + niter + '.DMP', x_aux) info.append([err, diff, obj]) print('Multiplier update: %.4e' % err) print('Relative difference: %.4e' % diff) print('Fidelity term: %.4e' % obj_1, ' Second term: %.4e' % obj_2, ' TV term: %.4e' % obj_3, ' || G(x) ||_{0}: %.4e' % obj_0) print('Function score: %.4e' % obj) ## Plot intermediate reconstruction as check if param.plot is True: if nz == 1: ax.imshow(x[0, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) else: nzz = np.int(nz * 0.5) ax.imshow(x[nzz, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) plt.draw() plt.pause(1) it += 1 if param.plot is True: py.ioff() return x, info
def lasso_tv(x, b, tp, param): ## Parameters n = param.npix_op nz = param.nz lambd1 = param.lambd1 lambd2 = param.lambd2 mu = param.mu n2 = param.n_iter_pcg it = 0 err = 1e20 info = [] ## Set stopping criterion if param.eps is None: eps = 1e-10 else: eps = param.eps if param.n_iter is None: n1 = 200 else: n1 = param.n_iter ## Reconstruction indices if param.edge_padding != 0.0: i1 = param.index_start i2 = param.index_end else: i1 = 0 i2 = n ## Initialize plot if param.plot is True: fig = plt.figure() ax = fig.add_subplot(111) if nz == 1: Ln = ax.imshow(x[0, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) else: nzz = np.int(nz * 0.5) Ln = ax.imshow(x[nzz, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) plt.ion() ## Start main loop while it < n1 and err > eps: print('\nADMM Lasso TV --- iteraz. n.: ', it) # --- step 0 if it == 0: u = np.zeros((nz, 2, n, n), dtype=myfloat) alpha = u.copy() x_old = x.copy() ## --- step 1 x_old[:] = x.copy() if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( cg.cg_lasso_tv , args=( x[i,:,:] , b[i,:,:] , tp , n2 , mu * u[i,:,:] - alpha[i,:,:] , lambd1 , mu , i , ) ) \ for i in range( nz ) ] x[:] = np.array([res.get() for res in results]) pool.close() pool.join() if param.mask is not None: for i in range(nz): x[i, i1:i2, i1:i2] = utils.supp_constr(x[i, i1:i2, i1:i2], param.mask) if param.mask_add is not None: for i in range(nz): aux = x[i, i1:i2, i1:i2].copy() for j in range(param.mask_add_n): aux[:] = utils.mask_constr(aux, param.mask_add[j]) x[i, i1:i2, i1:i2] = aux if param.pc >= 0.0: if param.pc >= 0.0: if param.pc == 1.0: x[:, i1:i2, i1:i2] = utils.phys_constr(x[:, i1:i2, i1:i2], 0.0) x[:, i1:i2, i1:i2] = utils.resol_circle_constr(x[:, i1:i2, i1:i2]) if param.pc == 2.0: x[:, i1:i2, i1:i2] = utils.resol_circle_constr(x[:, i1:i2, i1:i2]) else: x[:, i1:i2, i1:i2] = utils.phys_constr(x[:, i1:i2, i1:i2], param.pc) ## --- step 2 if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( hard_thres_multi , args=( x[i,:,:] , alpha[i,:,:,:] , lambd2 , mu ) ) \ for i in range( nz ) ] u[:] = np.array([res.get() for res in results]) pool.close() pool.join() ## --- step 3 r = u.copy() if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( update_lasso_tv , args=( x[i,:,:] , u[i,:,:,:] ) ) \ for i in range( nz ) ] r[:] = np.array([res.get() for res in results]) pool.close() pool.join() diff = x - x_old alpha += r ## --- step 4 diff = np.linalg.norm(x[0, :, :] - x_old[0, :, :]) err = np.linalg.norm(r) tmp = np.sqrt(cg.G(x[0, :, :])[0]**2 + cg.G(x[0, :, :])[1]**2) obj_0 = np.linalg.norm(tmp.reshape(-1), 0) obj_1 = np.linalg.norm(tp.A(x[0, :, :]) - b[0, :, :])**2 obj_2 = np.linalg.norm(x[0, :, :]) obj_3 = np.linalg.norm(tmp, 1) obj = 0.5 * obj_1 + 0.5 * lambd1 * obj_2 + lambd2 * obj_3 if param.checkit is True: if param.projector == 'grid-pswf' or param.projector == 'grid-kb': x_aux = x[0, i1:i2, i1:i2].copy() elif param.projector == 'radon': x_aux = x[0, i2:i1:-1, i2:i1:-1].copy() elif param.projector == 'bspline': x_aux = bfun.convert_from_bspline_to_pixel_basis( x[0, i2:i1:-1, i2:i1:-1], 3) if it < 10: niter = '00' + str(it) elif it < 100: niter = '0' + str(it) else: niter = str(it) io.writeImage(param.path_rmse + 'reco_iter' + niter + '.DMP', x_aux) info.append([err, diff, obj]) print('Multiplier update: %.4e' % err) print('Relative difference: %.4e' % diff) print('Fidelity term: %.4e' % obj_1, ' Second term: %.4e' % obj_2, ' TV term: %.4e' % obj_3, ' || G(x) ||_{0}: %.4e' % obj_0) print('Function score: %.4e' % obj) ## Plot intermediate reconstruction as check if param.plot is True: if nz == 1: ax.imshow(x[0, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) else: nzz = np.int(nz * 0.5) ax.imshow(x[nzz, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) plt.draw() plt.pause(1) it += 1 if param.plot is True: py.ioff() return x, info
def main(): print('\n') print('#########################################################') print('#########################################################') print('### ###') print('### CREATE SHEPP-LOGAN AND ITS ANALYTICAL SINOGRAM ###') print('### ###') print('#########################################################') print('#########################################################') print('\n') ## Get arguments args = getArgs() ## Get number of pixels npix = args.npix nang = args.nang print('\nNumber of pixels: ', npix) print('Number of views: ', nang) ## Create look-up-table of Shepp-Logan ellipses or read specifics from file if args.filein is None: LUT = lut_shepp_logan( npix , nang ) print('\nCreated LUT for Shepp-Logan phantom') else: lut_file = np.loadtxt( args.filein ) LUT = lut_generic_phantom( lut_file , npix , nang ) if args.filein.find( '/' ) == -1: name = args.filein.split( '.' )[0] else: tokens = args.filein.split( '/' ) name = tokens[len(tokens)-1].split('.')[0] print('\nReading LUT for phantom from file:\n', args.filein) print('Label selected for the putput files: ', name) ## Create Shepp-Logan phantom phantom = create_phantom( LUT , npix ) ## Write phantom path = args.path if path[len(path)-1] != '/': path += '/' if args.filein is None: filename = path + 'shepp_logan_pix' else: filename = path + name + '_pix' if npix < 10: common = '000' + str( npix ) elif npix < 100: common = '00' + str( npix ) elif npix < 1000: common = '0' + str( npix ) else: common = str( npix ) filename += common + args.file_format io.writeImage( filename , phantom ) print('\nWriting sinogram in:\n', filename) ## Plot phantom if args.plot is True: dis.plot( phantom , 'Shepp-Logan ' + str( npix ) + ' X ' + str( npix ) + ' pixels' ) ## Compute analitically radon transform of the phantom if args.nang is not None: print('\nCalculating analytical radon transform of the phantom ....') sinogram = radon_transform_analytical( phantom , LUT , npix , nang ) sinogram[:,:] = sinogram[:,::-1] sinogram[:,:] = np.roll( sinogram , 1 , axis=1 ) ## Plot Shepp-Logan phantom if args.plot is True: dis.plot( sinogram , 'Sinogram ' + str( nang ) + ' views X ' + str( npix ) + ' pixels' ) ## Write sinogram if args.filein is None: filename = path + 'shepp_logan_pix' + common + '_ang' else: filename = path + name + '_pix' + common + '_ang' if nang < 10: filename += '000' + str( nang ) + '_rt_anal_sino' + args.file_format elif nang < 100: filename += '00' + str( nang ) + '_rt_anal_sino' + args.file_format elif nang < 1000: filename += '0' + str( nang ) + '_rt_anal_sino' + args.file_format else: filename += str( nang ) + '_rt_anal_sino' + args.file_format io.writeImage( filename , sinogram ) print('\nWriting sinogram in:\n', filename) print('\n\n')
def sps(x, b, tp, param): ## Get number pixels, views, ctr, stopping criterion nz, m, n = b.shape eps = param.eps n_iter = param.n_iter b = b.astype(myfloat) ## Regularization parameters beta = param.reg_cost if param.reg == 'huber': delta = param.huber_cost ## Pre-compute weights b_max = np.max(b) b_den = np.sum(b**2) w = np.exp(-b / b_max).astype(myfloat) ## Pre-compute deninator: ## d = ( y * gamma )^{T} * A aux = tp.A(np.ones((n, n), dtype=myfloat)) aux = w * np.kron(np.ones((nz, 1, 1), dtype=myfloat), aux) if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( backward , args=( tp , aux[i,:,:] ) ) \ for i in range( nz ) ] den = np.array([res.get() for res in results]) pool.close() pool.join() ## Initialize useful arrays b_diff = b.copy() num = den.copy() R_num = np.zeros((nz, n, n), dtype=myfloat) R_den = np.zeros((nz, n, n), dtype=myfloat) g = np.zeros((nz, n, n), dtype=myfloat) err_list = [] ## Reconstruction indices if param.edge_padding != 0.0: i1 = param.index_start i2 = param.index_end else: i1 = 0 i2 = n ## Initialize plot if nz == 1: nzz = 0 else: nzz = np.int(nz * 0.5) if param.plot is True: fig = plt.figure() ax = fig.add_subplot(111) Ln = ax.imshow(x[nzz, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) plt.ion() ## Start reconstruction loop it = 0 err = 1e20 b_aux = b.copy() while it < n_iter and err > eps: ## Compute forward projection of new iterate if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( forward , args=( tp , x[i,:,:] ) ) \ for i in range( nz ) ] b_aux[:] = np.array([res.get() for res in results]) pool.close() pool.join() b_diff[:] = b_aux - b ## Compute numerator b_diff *= w if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( backward , args=( tp , b_diff[i,:,:] ) ) \ for i in range( nz ) ] num[:] = np.array([res.get() for res in results]) pool.close() pool.join() ## Regularization gamma = 0 if param.reg == 'huber': if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( sobel , args=( x[i,:,:] , gamma ) ) \ for i in range( nz ) ] g[:] = np.array([res.get() for res in results]) pool.close() pool.join() if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( reg.huber_num , args=( g[i,:,:] , delta ) ) \ for i in range( nz ) ] R_num[:] = np.array([res.get() for res in results]) pool.close() pool.join() if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( reg.huber_den , args=( g[i,:,:] , delta ) ) \ for i in range( nz ) ] R_den[:] = np.array([res.get() for res in results]) pool.close() pool.join() elif param.reg == 'tikhonov': if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( reg.tikhonov_num , args=( x[i,:,:] , gamma ) ) \ for i in range( nz ) ] R_num[:] = np.array([res.get() for res in results]) pool.close() pool.join() if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( reg.tikhonov_den , args=( x[i,:,:] , gamma ) ) \ for i in range( nz ) ] R_den[:] = np.array([res.get() for res in results]) pool.close() pool.join() elif param.reg == 'haar': if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( reg.haar_num , args=( x[i,:,:] , gamma ) ) \ for i in range( nz ) ] R_num[:] = np.array([res.get() for res in results]) pool.close() pool.join() if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( reg.haar_den , args=( x[i,:,:] , gamma ) ) \ for i in range( nz ) ] R_den[:] = np.array([res.get() for res in results]) pool.close() pool.join() ## Update reconstruction x_old = x.copy() x[:] -= (num + beta * R_num) / (den + beta * R_den + np.spacing(1)) ## Enforce positivity if param.edge_padding is False: x[:] = np.clip(x, 0, np.max(x)) ## Compute step improvement if param.reg == 'huber': gc = g[0, :, :].copy() R = gc.copy() R[gc <= delta] = 0.5 * gc[gc <= delta]**2 R[gc > delta] = delta * gc[gc > delta] - 0.5 * delta**2 R = np.sum(R) elif param.reg == 'tikhonov': R = np.linalg.norm(x[0, :, :])**2 else: R = 0 err = np.sum((b_diff[nzz, :, :])**2) / b_den err1 = np.linalg.norm(x[nzz, :, :] - x_old[nzz, :, :]) err2 = 0.5 * np.linalg.norm(tp.A(x[nzz, :, :]) - b[nzz, :, :]) + beta * R err_list.append([err1, err2]) it += 1 print('\nSPS-iteration: ', it, ' error: ', err) ## Plot intermediate reconstruction as check if param.plot is True: ax.imshow(x[nzz, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) plt.draw() plt.pause(1) ## Write iterate for further analysis of the algorithm if param.checkit is True: if param.projector == 'grid-pswf' or param.projector == 'grid-kb': x_aux = x[0, i1:i2, i1:i2].copy() elif param.projector == 'radon': x_aux = x[0, i2:i1:-1, i2:i1:-1].copy() elif param.projector == 'bspline': x_aux = bfun.convert_from_bspline_to_pixel_basis( x[0, i2:i1:-1, i2:i1:-1], 3) if it < 10: niter = '00' + str(it) elif it < 100: niter = '0' + str(it) else: niter = str(it) io.writeImage(param.path_rmse + 'reco_iter' + niter + '.DMP', x_aux) ## Conversion for bspline reconstruction and rotate if param.projector == 'bspline': for i in range(nz): x[i, :, :] = bfun.convert_from_bspline_to_pixel_basis( x[i, :, :], 3) x[:, :, :] = x[:, ::-1, ::-1] info = np.array(err_list) if param.plot is True: py.ioff() return x, info
def em(x, b, tp, param): ## Get number pixels, views, ctr, stopping criterion nz, m, n = b.shape eps = param.eps n_iter = param.n_iter b = b.astype(myfloat) ## Pre-compute constant part of the denominator ## ( A^{T} 1 )^{T} ones = np.ones((m, n), dtype=myfloat) d_cost = tp.At(ones) d_cost[d_cost == 0] = d_cost[d_cost == 0] + 1e-10 ## Initialize useful arrays b_new = b.copy() err_list = [] ## Reconstruction indices if param.edge_padding != 0.0: i1 = param.index_start i2 = param.index_end else: i1 = 0 i2 = n ## Initialize plot if nz == 1: nzz = 0 else: nzz = np.int(nz * 0.5) if param.plot is True: fig = plt.figure() ax = fig.add_subplot(111) Ln = ax.imshow(x[nzz, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) plt.ion() ## Start reconstruction loop it = 0 err = 1e20 x_aux = x.copy() while it < n_iter and err > eps: ## Compute forward projection of new iterate x_old = x.copy() if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( forward , args=( tp , x[i,:,:] ) ) \ for i in range( nz ) ] b_new[:] = np.array([res.get() for res in results]) pool.close() pool.join() b_new[b_new == 0] = b_new[b_new == 0] + np.spacing(1) b_aux = b / b_new if param.num_cores == -1: pool = mproc.Pool() else: pool = mproc.Pool(param.num_cores) results = [ pool.apply_async( backward , args=( tp , b_aux[i,:,:] ) ) \ for i in range( nz ) ] x_aux[:] = np.array([res.get() for res in results]) pool.close() pool.join() x[:] *= (1.0 / d_cost) * x_aux ## Compute step improvement err = np.sum( (b_new[nzz, :, :] - b[nzz, :, :])**2) / np.sum(b[nzz, :, :]**2) err1 = np.linalg.norm(x[nzz, :, :] - x_old[nzz, :, :]) err2 = 0.5 * np.linalg.norm(tp.A(x[nzz, :, :]) - b[nzz, :, :]) err_list.append([err1, err2]) it += 1 print('\nEM-iteration: ', it, ' error: ', err) ## Plot intermediate reconstruction as check if param.plot is True: ax.imshow(x[nzz, i2:i1:-1, i1:i2], animated=True, cmap=cm.Greys_r) py.draw() plt.pause(1) ## Write iterate for further analysis of the algorithm if param.checkit is True: if param.projector == 'grid-pswf' or param.projector == 'grid-kb' or param.projector == 'pix-driv': x_aux = x[nzz, i1:i2, i1:i2].copy() elif param.projector == 'radon': x_aux = x[nzz, i2:i1:-1, i2:i1:-1].copy() elif param.projector == 'bspline': x_aux = bfun.convert_from_bspline_to_pixel_basis( x[nzz, i2:i1:-1, i2:i1:-1], 3) if it < 10: niter = '00' + str(it) elif it < 100: niter = '0' + str(it) else: niter = str(it) io.writeImage(param.path_rmse + 'reco_iter' + niter + '.DMP', x_aux) info = np.array(err_list) if param.plot is True: py.ioff() return x, info
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') ## 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 ## Use anti-alising filter if args.anti_alias is not None: if args.anti_alias == 'hlsf' or args.anti_alias == 'lhsf': print('\nAnti-aliasing HLSF filter enabled') sino = lhsf.anti_alias_filt(sino) nang, npix = sino.shape print('New number of projection angles: ', nang) sino = sino.astype(myfloat) elif args.anti_alias == 'cubic': print('\nAnti-aliasing cubic interpolation enabled') sino = extrap.anti_alias_filt(sino, op='cubic') nang, npix = sino.shape print('New number of projection angles: ', nang) sino = sino.astype(myfloat) elif args.anti_alias == 'telea': print('\nAnti-aliasing telea inpainting enabled') sino = extrap.anti_alias_filt(sino, op='telea', radius=2) nang, npix = sino.shape print('New number of projection angles: ', nang) sino = sino.astype(myfloat) else: print('\nWarning: anti-aliasing method ', args.anti_alias, ' not found!') print('No anti-aliasing filtering applied!\n') if args.plot is True: dis.plot(sino, 'Sinogram with double number of views') io.writeImage('sino.DMP', sino) ## 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: 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 ## 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('\nRESCALE IMAGE\n') ## Get input arguments args = getArgs() ## Get input and output path pathin = args.pathin if pathin[len(pathin) - 1] != '/': pathin += '/' if args.pathout is None: pathout = pathin else: pathout = args.pathout if pathout[len(pathout) - 1] != '/': pathout += '/' print('\nInput path:\n', pathin) print('\nOutput path:\n', pathout) ## Get single image if args.image is not None: ## Reading image filein = args.image imagein = io.readImage(pathin + filein) nrows, ncols = imagein.shape[0], imagein.shape[1] print('\nReading image:', filein) print('Image size: ', nrows, ' X ', ncols) ## Check plot if args.plot is True: dis.plot(imagein, 'Input image') ## Make image square if args.square is True: if nrows < ncols: imagein = imagein[:, :nrows] else: imagein = imagein[:ncols, :] ## Rescaled image if args.rescale is not None: rescale = args.rescale nrows_new = int(nrows * rescale) ncols_new = int(ncols * rescale) else: nrows_new = ncols_new = args.npix rescale = nrows_new / myfloat(nrows) image_rescale = rescale_image(imagein, rescale) print('\nRescaled factor: ', rescale) print('Rescaled-image size: ', image_rescale.shape) ## Check plot if args.plot is True: dis.plot(image_rescale, 'Rescaled image -- factor = ' + str(rescale)) ## Write noisy image to file fileout = filein[:len(filein) - 4] + '_pix' if nrows_new < 100: fileout += '00' + str(nrows_new) + '.DMP' elif nrows_new < 1000: fileout += '0' + str(nrows_new) + '.DMP' else: fileout += str(nrows_new) + '.DMP' io.writeImage(pathout + fileout, image_rescale) print('\nWriting rescaled image:', fileout) ## Get bunch of input images elif args.label is not None: curr_dir = os.getcwd() ## Reading images os.chdir(pathin) files = sorted(glob.glob('*' + args.label + '*')) os.chdir(curr_dir) num_im_input = len(files) for i in range(num_im_input): imagein = io.readImage(pathin + files[i]) nrows, ncols = imagein.shape[0], imagein.shape[1] print('\nReading image:\n', files[i]) print('\nImage size: ', nrows, ' X ', ncols) ## Make image square if args.square is True: if nrows < ncols: imagein = imagein[:, :nrows] else: imagein = imagein[:ncols, :] ## Rescaled image if args.rescale is not None: rescale = args.rescale nrows_new = int(nrows * rescale) ncols_new = int(ncols * rescale) else: nrows_new = ncols_new = args.npix rescale = nrows_new / myfloat(nrows) image_rescale = rescale_image(imagein, rescale) print('\nRescaled factor: ', rescale) print('Rescaled-image size: ', image_rescale.shape) ## Write noisy image to file fileout = files[i][:len(files[i]) - 4] + '_pix' if nrows_new < 100: fileout += '00' + str(nrows_new) + '.DMP' elif nrows_new < 1000: fileout += '0' + str(nrows_new) + '.DMP' else: fileout += str(nrows_new) + '.DMP' io.writeImage(pathout + fileout, image_rescale) print('\nWriting rescaled image:', fileout) print('\n\n')
def main(): print('###################################################') 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')