def reconstruct(sname, rot_center, ovlpfind, s_start, s_end): fname = dfolder + sname + '.h5' print(fname) start = s_start end = s_end chunks = 24 num_sino = (end - start) // chunks for m in range(chunks): sino_start = start + num_sino * m sino_end = start + num_sino * (m + 1) start_read_time = time.time() proj, flat, dark, thetat = dxchange.read_aps_2bm(fname, sino=(sino_start, sino_end)) print(' done read in %0.1f min' % ((time.time() - start_read_time) / 60)) dark = proj[9001:9002] flat = proj[0:1] proj = proj[1:9000] theta = tomopy.angles(proj.shape[0], 0., 360.) proj = tomopy.sino_360_to_180(proj, overlap=ovlpfind, rotation='right') proj = tomopy.remove_outlier(proj, dif=0.4) proj = tomopy.normalize_bg(proj, air=10) proj = tomopy.minus_log(proj) center = rot_center start_ring_time = time.time() proj = tomopy.remove_stripe_fw(proj, wname='sym5', sigma=4, pad=False) proj = tomopy.remove_stripe_sf(proj, size=3) print(' done pre-process in %0.1f min' % ((time.time() - start_ring_time) / 60)) start_phase_time = time.time() proj = tomopy.retrieve_phase(proj, pixel_size=detector_pixel_size_x, dist=sample_detector_distance, energy=energy, alpha=alpha, pad=True, ncore=None, nchunk=None) print(' done phase retrieval in %0.1f min' % ((time.time() - start_phase_time) / 60)) start_recon_time = time.time() rec = tomopy.recon(proj, theta, center=center, algorithm='gridrec', filter_name='ramalk') tomopy.circ_mask(rec, axis=0, ratio=0.95) print("Reconstructed", rec.shape) dxchange.write_tiff_stack(rec, fname=dfolder + '/' + sname + '/' + sname, overwrite=True, start=sino_start) print(' Chunk reconstruction done in %0.1f min' % ((time.time() - start_recon_time) / 60)) print("Done!")
def phase_retrieval(data, params): log.info(" *** retrieve phase") if (params.retrieve_phase_method == 'paganin'): log.info(' *** *** paganin') log.info(" *** *** pixel size: %s" % params.pixel_size) log.info(" *** *** sample detector distance: %s" % params.propagation_distance) log.info(" *** *** energy: %s" % params.energy) log.info(" *** *** alpha: %s" % params.retrieve_phase_alpha) data = tomopy.retrieve_phase(data,pixel_size=(params.pixel_size*1e-4),dist=(params.propagation_distance/10.0),energy=params.energy, alpha=params.retrieve_phase_alpha,pad=True) elif(params.retrieve_phase_method == 'none'): log.warning(' *** *** OFF') return data
def prepare_slice(grid, shift_grid, grid_lines, slice_in_tile, ds_level=0, method='max', blend_options=None, pad=None, rot_center=None, assert_width=None, sino_blur=None, color_correction=False, normalize=True, mode='180', phase_retrieval=None, **kwargs): sinos = [None] * grid.shape[1] for col in range(grid.shape[1]): try: sinos[col] = load_sino(grid[grid_lines[col], col], slice_in_tile[col], normalize=normalize) except: pass t = time.time() row_sino = register_recon(grid, grid_lines, shift_grid, sinos, method=method, blend_options=blend_options, color_correction=color_correction, assert_width=assert_width) if not pad is None: row_sino, rot_center = pad_sino(row_sino, pad, rot_center) print('stitch: ' + str(time.time() - t)) print('final size: ' + str(row_sino.shape)) t = time.time() row_sino = tomopy.downsample(row_sino, level=ds_level) print('downsample: ' + str(time.time() - t)) print('new shape : ' + str(row_sino.shape)) # t = time.time() # row_sino = tomopy.remove_stripe_fw(row_sino, 2) # print('strip removal: ' + str(time.time() - t)) # Minus Log row_sino = tomosaic.util.preprocess(row_sino) if sino_blur is not None: row_sino[:, 0, :] = gaussian_filter(row_sino[:, 0, :], sino_blur) if mode == '360': overlap = 2 * (row_sino.shape[2] - rot_center) row_sino = tomosaic.morph.sino_360_to_180(row_sino, overlap=overlap, rotation='right') if phase_retrieval: row_sino = tomopy.retrieve_phase(row_sino, kwargs['pixel_size'], kwargs['dist'], kwargs['energy'], kwargs['alpha']) return row_sino, rot_center
def reconstruct(sname, rot_center, ovlpfind, s_start, s_end): fname = dfolder + sname + '.h5' print (fname) start = s_start end = s_end chunks = 24 num_sino = (end - start) // chunks for m in range(chunks): sino_start = start + num_sino * m sino_end = start + num_sino * (m + 1) start_read_time = time.time() proj, flat, dark, thetat = dxchange.read_aps_2bm(fname, sino=(sino_start, sino_end)) print(' done read in %0.1f min' % ((time.time() - start_read_time)/60)) dark = proj[9001:9002] flat = proj[0:1] proj = proj[1:9000] theta = tomopy.angles(proj.shape[0], 0., 360.) proj = tomopy.sino_360_to_180(proj, overlap=ovlpfind, rotation='right') proj = tomopy.remove_outlier(proj, dif=0.4) proj = tomopy.normalize_bg(proj, air=10) proj = tomopy.minus_log(proj) center = rot_center start_ring_time = time.time() proj = tomopy.remove_stripe_fw(proj, wname='sym5', sigma=4, pad=False) proj = tomopy.remove_stripe_sf(proj, size=3) print(' done pre-process in %0.1f min' % ((time.time() - start_ring_time)/60)) start_phase_time = time.time() proj = tomopy.retrieve_phase(proj, pixel_size=detector_pixel_size_x, dist=sample_detector_distance, energy=energy, alpha=alpha, pad=True, ncore=None, nchunk=None) print(' done phase retrieval in %0.1f min' % ((time.time() - start_phase_time)/60)) start_recon_time = time.time() rec = tomopy.recon(proj, theta, center=center, algorithm='gridrec', filter_name='ramalk') tomopy.circ_mask(rec, axis=0, ratio=0.95) print ("Reconstructed", rec.shape) dxchange.write_tiff_stack(rec, fname = dfolder + '/' + sname + '/' + sname, overwrite=True, start=sino_start) print(' Chunk reconstruction done in %0.1f min' % ((time.time() - start_recon_time)/60)) print ("Done!")
def reconstruct(filename,inputPath="", outputPath="", COR=COR, doOutliers=doOutliers, outlier_diff=outlier_diff, outlier_size=outlier_size, doFWringremoval=doFWringremoval, ringSigma=ringSigma,ringLevel=ringLevel, ringWavelet=ringWavelet,pad_sino=pad_sino, doPhaseRetrieval=doPhaseRetrieval, propagation_dist=propagation_dist, kev=kev,alphaReg=alphaReg, butterworthpars=butterworthpars, doPolarRing=doPolarRing,Rarc=Rarc, Rmaxwidth=Rmaxwidth, Rtmax=Rtmax, Rthr=Rthr, Rtmin=Rtmin, useAutoCOR=useAutoCOR, use360to180=use360to180, num_substacks=num_substacks,recon_slice=recon_slice): # Convert filename to list type if only one file name is given if type(filename) != list: filename=[filename] # If useAutoCor == true, a list of COR will be automatically calculated for all files # If a list of COR is given, only entries with boolean False will use automatic COR calculation if useAutoCOR==True or (len(COR) != len(filename)): logging.info('using auto COR for all input files') COR = [False]*len(filename) for x in range(len(filename)): logging.info('opening data set, checking metadata') fdata, gdata = read_als_832h5_metadata(inputPath[x]+filename[x]+'.h5') pxsize = float(gdata['pxsize'])/10.0 # convert from metadata (mm) to this script (cm) numslices = int(gdata['nslices']) # recon_slice == True, only center slice will be reconstructed # if integer is given, a specific if recon_slice != False: if (type(recon_slice) == int) and (recon_slice <= numslices): sinorange [recon_slice-1, recon_slice] else: sinorange = [numslices//2-1, numslices//2] else: sinorange = [0, numslices] # Calculate number of substacks (chunks) substacks = num_substacks #(sinorange[1]-sinorange[0]-1)//num_sino_per_substack+1 if (sinorange[1]-sinorange[0]) >= substacks: num_sino_per_substack = (sinorange[1]-sinorange[0])//num_substacks else: num_sino_per_substack = 1 firstcor, lastcor = 0, int(gdata['nangles'])-1 projs, flat, dark, floc = dxchange.read_als_832h5(inputPath[x]+filename[x]+'.h5', ind_tomo=(firstcor, lastcor)) projs = tomopy.normalize_nf(projs, flat, dark, floc) autocor = tomopy.find_center_pc(projs[0], projs[1], tol=0.25) if (type(COR[x]) == bool) or (COR[x]<0) or (COR[x]=='auto'): firstcor, lastcor = 0, int(gdata['nangles'])-1 projs, flat, dark, floc = dxchange.read_als_832h5(inputPath[x]+filename[x]+'.h5', ind_tomo=(firstcor, lastcor)) projs = tomopy.normalize_nf(projs, flat, dark, floc) cor = tomopy.find_center_pc(projs[0], projs[1], tol=0.25) else: cor = COR[x] logging.info('Dataset %s, has %d total slices, reconstructing slices %d through %d in %d substack(s), using COR: %f',filename[x], int(gdata['nslices']), sinorange[0], sinorange[1]-1, substacks, cor) for y in range(0, substacks): logging.info('Starting dataset %s (%d of %d), substack %d of %d',filename[x], x+1, len(filename), y+1, substacks) logging.info('Reading sinograms...') projs, flat, dark, floc = dxchange.read_als_832h5(inputPath[x]+filename[x]+'.h5', sino=(sinorange[0]+y*num_sino_per_substack, sinorange[0]+(y+1)*num_sino_per_substack, 1)) logging.info('Doing remove outliers, norm (nearest flats), and -log...') if doOutliers: projs = tomopy.remove_outlier(projs, outlier_diff, size=outlier_size, axis=0) flat = tomopy.remove_outlier(flat, outlier_diff, size=outlier_size, axis=0) tomo = tomopy.normalize_nf(projs, flat, dark, floc) tomo = tomopy.minus_log(tomo, out=tomo) # in place logarithm # Use padding to remove halo in reconstruction if present if pad_sino: npad = int(np.ceil(tomo.shape[2] * np.sqrt(2)) - tomo.shape[2])//2 tomo = tomopy.pad(tomo, 2, npad=npad, mode='edge') cor_rec = cor + npad # account for padding else: cor_rec = cor if doFWringremoval: logging.info('Doing ring (Fourier-wavelet) function...') tomo = tomopy.remove_stripe_fw(tomo, sigma=ringSigma, level=ringLevel, pad=True, wname=ringWavelet) if doPhaseRetrieval: logging.info('Doing Phase retrieval...') #tomo = tomopy.retrieve_phase(tomo, pixel_size=pxsize, dist=propagation_dist, energy=kev, alpha=alphaReg, pad=True) tomo = tomopy.retrieve_phase(tomo, pixel_size=pxsize, dist=propagation_dist, energy=kev, alpha=alphaReg, pad=True) logging.info('Doing recon (gridrec) function and scaling/masking, with cor %f...',cor_rec) rec = tomopy.recon(tomo, tomopy.angles(tomo.shape[0], 270, 90), center=cor_rec, algorithm='gridrec', filter_name='butterworth', filter_par=butterworthpars) #rec = tomopy.recon(tomo, tomopy.angles(tomo.shape[0], 180+angularrange/2, 180-angularrange/2), center=cor_rec, algorithm='gridrec', filter_name='butterworth', filter_par=butterworthpars) rec /= pxsize # intensity values in cm^-1 if pad_sino: rec = tomopy.circ_mask(rec[:, npad:-npad, npad:-npad], 0) else: rec = tomopy.circ_mask(rec, 0, ratio=1.0, val=0.0) if doPolarRing: logging.info('Doing ring (polar mean filter) function...') rec = tomopy.remove_ring(rec, theta_min=Rarc, rwidth=Rmaxwidth, thresh_max=Rtmax, thresh=Rthr, thresh_min=Rtmin) logging.info('Writing reconstruction slices to %s', filename[x]) #dxchange.write_tiff_stack(rec, fname=outputPath+'alpha'+str(alphaReg)+'/rec'+filename[x]+'/rec'+filename[x], start=sinorange[0]+y*num_sino_per_substack) dxchange.write_tiff_stack(rec, fname=outputPath + 'recon_'+filename[x]+'/recon_'+filename[x], start=sinorange[0]+y*num_sino_per_substack) logging.info('Reconstruction Complete: '+ filename[x])
def paganin(input, pixel=1e-4, distance=50, energy=25, alpha=1e-4): assert input.ndim == 2 input = input.reshape([1, input.shape[0], input.shape[1]]).astype('float32') res = tomopy.retrieve_phase(input, pixel_size=pixel, dist=distance, energy=energy, alpha=alpha) res = np.squeeze(res) return res
def recon( filename, inputPath='./', outputPath=None, outputFilename=None, doOutliers1D=False, # outlier removal in 1d (along sinogram columns) outlier_diff1D=750, # difference between good data and outlier data (outlier removal) outlier_size1D=3, # radius around each pixel to look for outliers (outlier removal) doOutliers2D=False, # outlier removal, standard 2d on each projection outlier_diff2D=750, # difference between good data and outlier data (outlier removal) outlier_size2D=3, # radius around each pixel to look for outliers (outlier removal) doFWringremoval=True, # Fourier-wavelet ring removal doTIringremoval=False, # Titarenko ring removal doSFringremoval=False, # Smoothing filter ring removal ringSigma=3, # damping parameter in Fourier space (Fourier-wavelet ring removal) ringLevel=8, # number of wavelet transform levels (Fourier-wavelet ring removal) ringWavelet='db5', # type of wavelet filter (Fourier-wavelet ring removal) ringNBlock=0, # used in Titarenko ring removal (doTIringremoval) ringAlpha=1.5, # used in Titarenko ring removal (doTIringremoval) ringSize=5, # used in smoothing filter ring removal (doSFringremoval) doPhaseRetrieval=False, # phase retrieval alphaReg=0.0002, # smaller = smoother (used for phase retrieval) propagation_dist=75, # sample-to-scintillator distance (phase retrieval) kev=24, # energy level (phase retrieval) butterworth_cutoff=0.25, #0.1 would be very smooth, 0.4 would be very grainy (reconstruction) butterworth_order=2, # for reconstruction doPolarRing=False, # ring removal Rarc=30, # min angle needed to be considered ring artifact (ring removal) Rmaxwidth=100, # max width of rings to be filtered (ring removal) Rtmax=3000.0, # max portion of image to filter (ring removal) Rthr=3000.0, # max value of offset due to ring artifact (ring removal) Rtmin=-3000.0, # min value of image to filter (ring removal) cor=None, # center of rotation (float). If not used then cor will be detected automatically corFunction='pc', # center of rotation function to use - can be 'pc', 'vo', or 'nm' voInd=None, # index of slice to use for cor search (vo) voSMin=-40, # min radius for searching in sinogram (vo) voSMax=40, # max radius for searching in sinogram (vo) voSRad=10, # search radius (vo) voStep=0.5, # search step (vo) voRatio=2.0, # ratio of field-of-view and object size (vo) voDrop=20, # drop lines around vertical center of mask (vo) nmInd=None, # index of slice to use for cor search (nm) nmInit=None, # initial guess for center (nm) nmTol=0.5, # desired sub-pixel accuracy (nm) nmMask=True, # if True, limits analysis to circular region (nm) nmRatio=1.0, # ratio of radius of circular mask to edge of reconstructed image (nm) nmSinoOrder=False, # if True, analyzes in sinogram space. If False, analyzes in radiograph space use360to180=False, # use 360 to 180 conversion doBilateralFilter=False, # if True, uses bilateral filter on image just before write step # NOTE: image will be converted to 8bit if it is not already bilateral_srad=3, # spatial radius for bilateral filter (image will be converted to 8bit if not already) bilateral_rrad=30, # range radius for bilateral filter (image will be converted to 8bit if not already) castTo8bit=False, # convert data to 8bit before writing cast8bit_min=-10, # min value if converting to 8bit cast8bit_max=30, # max value if converting to 8bit useNormalize_nf=False, # normalize based on background intensity (nf) chunk_proj=100, # chunk size in projection direction chunk_sino=100, # chunk size in sinogram direction npad=None, # amount to pad data before reconstruction projused=None, #should be slicing in projection dimension (start,end,step) sinoused=None, #should be sliceing in sinogram dimension (start,end,step). If first value is negative, it takes the number of slices from the second value in the middle of the stack. correcttilt=0, #tilt dataset tiltcenter_slice=None, # tilt center (x direction) tiltcenter_det=None, # tilt center (y direction) angle_offset=0, #this is the angle offset from our default (270) so that tomopy yields output in the same orientation as previous software (Octopus) anglelist=None, #if not set, will assume evenly spaced angles which will be calculated by the angular range and number of angles found in the file. if set to -1, will read individual angles from each image. alternatively, a list of angles can be passed. doBeamHardening=False, #turn on beam hardening correction, based on "Correction for beam hardening in computed tomography", Gabor Herman, 1979 Phys. Med. Biol. 24 81 BeamHardeningCoefficients=None, #6 values, tomo = a0 + a1*tomo + a2*tomo^2 + a3*tomo^3 + a4*tomo^4 + a5*tomo^5 projIgnoreList=None, #projections to be ignored in the reconstruction (for simplicity in the code, they will not be removed and will be processed as all other projections but will be set to zero absorption right before reconstruction. *args, **kwargs): start_time = time.time() print("Start {} at:".format(filename) + time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime())) outputPath = inputPath if outputPath is None else outputPath outputFilename = filename if outputFilename is None else outputFilename tempfilenames = [outputPath + 'tmp0.h5', outputPath + 'tmp1.h5'] filenametowrite = outputPath + '/rec' + filename.strip( ".h5") + '/' + outputFilename #filenametowrite = outputPath+'/rec'+filename+'/'+outputFilename print("cleaning up previous temp files", end="") for tmpfile in tempfilenames: try: os.remove(tmpfile) except OSError: pass print(", reading metadata") datafile = h5py.File(inputPath + filename, 'r') gdata = dict(dxchange.reader._find_dataset_group(datafile).attrs) pxsize = float(gdata['pxsize']) / 10 # /10 to convert unites from mm to cm numslices = int(gdata['nslices']) numangles = int(gdata['nangles']) angularrange = float(gdata['arange']) numrays = int(gdata['nrays']) npad = int(np.ceil(numrays * np.sqrt(2)) - numrays) // 2 if npad is None else npad projused = (0, numangles - 1, 1) if projused is None else projused # ndark = int(gdata['num_dark_fields']) # ind_dark = list(range(0, ndark)) # group_dark = [numangles - 1] inter_bright = int(gdata['i0cycle']) nflat = int(gdata['num_bright_field']) ind_flat = list(range(0, nflat)) if inter_bright > 0: group_flat = list(range(0, numangles, inter_bright)) if group_flat[-1] != numangles - 1: group_flat.append(numangles - 1) elif inter_bright == 0: group_flat = [0, numangles - 1] else: group_flat = None ind_tomo = list(range(0, numangles)) floc_independent = dxchange.reader._map_loc(ind_tomo, group_flat) #figure out the angle list (a list of angles, one per projection image) dtemp = datafile[list(datafile.keys())[0]] fltemp = list(dtemp.keys()) firstangle = float(dtemp[fltemp[0]].attrs.get('rot_angle', 0)) if anglelist is None: #the offset angle should offset from the angle of the first image, which is usually 0, but in the case of timbir data may not be. #we add the 270 to be inte same orientation as previous software used at bl832 angle_offset = 270 + angle_offset - firstangle anglelist = tomopy.angles(numangles, angle_offset, angle_offset - angularrange) elif anglelist == -1: anglelist = np.zeros(shape=numangles) for icount in range(0, numangles): anglelist[icount] = np.pi / 180 * (270 + angle_offset - float( dtemp[fltemp[icount]].attrs['rot_angle'])) #if projused is different than default, need to chnage numangles and angularrange #can't do useNormalize_nf and doOutliers2D at the same time, or doOutliers2D and doOutliers1D at the same time, b/c of the way we chunk, for now just disable that if useNormalize_nf == True and doOutliers2D == True: useNormalize_nf = False print( "we cannot currently do useNormalize_nf and doOutliers2D at the same time, turning off useNormalize_nf" ) if doOutliers2D == True and doOutliers1D == True: doOutliers1D = False print( "we cannot currently do doOutliers1D and doOutliers2D at the same time, turning off doOutliers1D" ) #figure out how user can pass to do central x number of slices, or set of slices dispersed throughout (without knowing a priori the value of numslices) if sinoused is None: sinoused = (0, numslices, 1) elif sinoused[0] < 0: sinoused = ( int(np.floor(numslices / 2.0) - np.ceil(sinoused[1] / 2.0)), int(np.floor(numslices / 2.0) + np.floor(sinoused[1] / 2.0)), 1) num_proj_per_chunk = np.minimum(chunk_proj, projused[1] - projused[0]) numprojchunks = (projused[1] - projused[0] - 1) // num_proj_per_chunk + 1 num_sino_per_chunk = np.minimum(chunk_sino, sinoused[1] - sinoused[0]) numsinochunks = (sinoused[1] - sinoused[0] - 1) // num_sino_per_chunk + 1 numprojused = (projused[1] - projused[0]) // projused[2] numsinoused = (sinoused[1] - sinoused[0]) // sinoused[2] BeamHardeningCoefficients = ( 0, 1, 0, 0, 0, .1) if BeamHardeningCoefficients is None else BeamHardeningCoefficients if cor is None: print("Detecting center of rotation", end="") if angularrange > 300: lastcor = int(np.floor(numangles / 2) - 1) else: lastcor = numangles - 1 #I don't want to see the warnings about the reader using a deprecated variable in dxchange with warnings.catch_warnings(): warnings.simplefilter("ignore") tomo, flat, dark, floc = dxchange.read_als_832h5( inputPath + filename, ind_tomo=(0, lastcor)) tomo = tomo.astype(np.float32) if useNormalize_nf: tomopy.normalize_nf(tomo, flat, dark, floc, out=tomo) else: tomopy.normalize(tomo, flat, dark, out=tomo) if corFunction == 'vo': # same reason for catching warnings as above with warnings.catch_warnings(): warnings.simplefilter("ignore") cor = tomopy.find_center_vo(tomo, ind=voInd, smin=voSMin, smax=voSMax, srad=voSRad, step=voStep, ratio=voRatio, drop=voDrop) elif corFunction == 'nm': cor = tomopy.find_center( tomo, tomopy.angles(numangles, angle_offset, angle_offset - angularrange), ind=nmInd, init=nmInit, tol=nmTol, mask=nmMask, ratio=nmRatio, sinogram_order=nmSinoOrder) elif corFunction == 'pc': cor = tomopy.find_center_pc(tomo[0], tomo[1], tol=0.25) else: raise ValueError("\'corFunction\' must be one of: [ pc, vo, nm ].") print(", {}".format(cor)) else: print("using user input center of {}".format(cor)) function_list = [] if doOutliers1D: function_list.append('remove_outlier1d') if doOutliers2D: function_list.append('remove_outlier2d') if useNormalize_nf: function_list.append('normalize_nf') else: function_list.append('normalize') function_list.append('minus_log') if doBeamHardening: function_list.append('beam_hardening') if doFWringremoval: function_list.append('remove_stripe_fw') if doTIringremoval: function_list.append('remove_stripe_ti') if doSFringremoval: function_list.append('remove_stripe_sf') if correcttilt: function_list.append('correcttilt') if use360to180: function_list.append('do_360_to_180') if doPhaseRetrieval: function_list.append('phase_retrieval') function_list.append('recon_mask') if doPolarRing: function_list.append('polar_ring') if castTo8bit: function_list.append('castTo8bit') if doBilateralFilter: function_list.append('bilateral_filter') function_list.append('write_output') # Figure out first direction to slice for func in function_list: if slice_dir[func] != 'both': axis = slice_dir[func] break done = False curfunc = 0 curtemp = 0 while True: # Loop over reading data in certain chunking direction if axis == 'proj': niter = numprojchunks else: niter = numsinochunks for y in range(niter): # Loop over chunks print("{} chunk {} of {}".format(axis, y + 1, niter)) if curfunc == 0: with warnings.catch_warnings(): warnings.simplefilter("ignore") if axis == 'proj': tomo, flat, dark, floc = dxchange.read_als_832h5( inputPath + filename, ind_tomo=range( y * num_proj_per_chunk + projused[0], np.minimum( (y + 1) * num_proj_per_chunk + projused[0], numangles)), sino=(sinoused[0], sinoused[1], sinoused[2])) else: tomo, flat, dark, floc = dxchange.read_als_832h5( inputPath + filename, ind_tomo=range(projused[0], projused[1], projused[2]), sino=(y * num_sino_per_chunk + sinoused[0], np.minimum((y + 1) * num_sino_per_chunk + sinoused[0], numslices), 1)) else: if axis == 'proj': start, end = y * num_proj_per_chunk, np.minimum( (y + 1) * num_proj_per_chunk, numprojused) tomo = dxchange.reader.read_hdf5( tempfilenames[curtemp], '/tmp/tmp', slc=((start, end, 1), (0, numslices, 1), (0, numrays, 1))) #read in intermediate file else: start, end = y * num_sino_per_chunk, np.minimum( (y + 1) * num_sino_per_chunk, numsinoused) tomo = dxchange.reader.read_hdf5(tempfilenames[curtemp], '/tmp/tmp', slc=((0, numangles, 1), (start, end, 1), (0, numrays, 1))) dofunc = curfunc keepvalues = None while True: # Loop over operations to do in current chunking direction func_name = function_list[dofunc] newaxis = slice_dir[func_name] if newaxis != 'both' and newaxis != axis: # We have to switch axis, so flush to disk if y == 0: try: os.remove(tempfilenames[1 - curtemp]) except OSError: pass appendaxis = 1 if axis == 'sino' else 0 dxchange.writer.write_hdf5( tomo, fname=tempfilenames[1 - curtemp], gname='tmp', dname='tmp', overwrite=False, appendaxis=appendaxis) #writing intermediate file... break print(func_name, end=" ") curtime = time.time() if func_name == 'remove_outlier1d': tomo = tomo.astype(np.float32, copy=False) remove_outlier1d(tomo, outlier_diff1D, size=outlier_size1D, out=tomo) if func_name == 'remove_outlier2d': tomo = tomo.astype(np.float32, copy=False) tomopy.remove_outlier(tomo, outlier_diff2D, size=outlier_size2D, axis=0, out=tomo) elif func_name == 'normalize_nf': tomo = tomo.astype(np.float32, copy=False) tomopy.normalize_nf( tomo, flat, dark, floc_independent, out=tomo ) #use floc_independent b/c when you read file in proj chunks, you don't get the correct floc returned right now to use here. elif func_name == 'normalize': tomo = tomo.astype(np.float32, copy=False) tomopy.normalize(tomo, flat, dark, out=tomo) elif func_name == 'minus_log': mx = np.float32(0.00000000000000000001) ne.evaluate('where(tomo>mx, tomo, mx)', out=tomo) tomopy.minus_log(tomo, out=tomo) elif func_name == 'beam_hardening': loc_dict = { 'a{}'.format(i): np.float32(val) for i, val in enumerate(BeamHardeningCoefficients) } tomo = ne.evaluate( 'a0 + a1*tomo + a2*tomo**2 + a3*tomo**3 + a4*tomo**4 + a5*tomo**5', local_dict=loc_dict, out=tomo) elif func_name == 'remove_stripe_fw': tomo = tomopy.remove_stripe_fw(tomo, sigma=ringSigma, level=ringLevel, pad=True, wname=ringWavelet) elif func_name == 'remove_stripe_ti': tomo = tomopy.remove_stripe_ti(tomo, nblock=ringNBlock, alpha=ringAlpha) elif func_name == 'remove_stripe_sf': tomo = tomopy.remove_stripe_sf(tomo, size=ringSize) elif func_name == 'correcttilt': if tiltcenter_slice is None: tiltcenter_slice = numslices / 2. if tiltcenter_det is None: tiltcenter_det = tomo.shape[2] / 2 new_center = tiltcenter_slice - 0.5 - sinoused[0] center_det = tiltcenter_det - 0.5 #add padding of 10 pixels, to be unpadded right after tilt correction. This makes the tilted image not have zeros at certain edges, which matters in cases where sample is bigger than the field of view. For the small amounts we are generally tilting the images, 10 pixels is sufficient. # tomo = tomopy.pad(tomo, 2, npad=10, mode='edge') # center_det = center_det + 10 cntr = (center_det, new_center) for b in range(tomo.shape[0]): tomo[b] = st.rotate( tomo[b], correcttilt, center=cntr, preserve_range=True, order=1, mode='edge', clip=True ) #center=None means image is rotated around its center; order=1 is default, order of spline interpolation # tomo = tomo[:, :, 10:-10] elif func_name == 'do_360_to_180': # Keep values around for processing the next chunk in the list keepvalues = [ angularrange, numangles, projused, num_proj_per_chunk, numprojchunks, numprojused, numrays, anglelist ] #why -.5 on one and not on the other? if tomo.shape[0] % 2 > 0: tomo = sino_360_to_180( tomo[0:-1, :, :], overlap=int( np.round((tomo.shape[2] - cor - .5)) * 2), rotation='right') angularrange = angularrange / 2 - angularrange / ( tomo.shape[0] - 1) else: tomo = sino_360_to_180( tomo[:, :, :], overlap=int(np.round((tomo.shape[2] - cor)) * 2), rotation='right') angularrange = angularrange / 2 numangles = int(numangles / 2) projused = (0, numangles - 1, 1) num_proj_per_chunk = np.minimum(chunk_proj, projused[1] - projused[0]) numprojchunks = (projused[1] - projused[0] - 1) // num_proj_per_chunk + 1 numprojused = (projused[1] - projused[0]) // projused[2] numrays = tomo.shape[2] anglelist = anglelist[:numangles] elif func_name == 'phase_retrieval': tomo = tomopy.retrieve_phase(tomo, pixel_size=pxsize, dist=propagation_dist, energy=kev, alpha=alphaReg, pad=True) elif func_name == 'recon_mask': tomo = tomopy.pad(tomo, 2, npad=npad, mode='edge') if projIgnoreList is not None: for badproj in projIgnoreList: tomo[badproj] = 0 rec = tomopy.recon( tomo, anglelist, center=cor + npad, algorithm='gridrec', filter_name='butterworth', filter_par=[butterworth_cutoff, butterworth_order]) rec = rec[:, npad:-npad, npad:-npad] rec /= pxsize # convert reconstructed voxel values from 1/pixel to 1/cm rec = tomopy.circ_mask(rec, 0) elif func_name == 'polar_ring': rec = np.ascontiguousarray(rec, dtype=np.float32) rec = tomopy.remove_ring(rec, theta_min=Rarc, rwidth=Rmaxwidth, thresh_max=Rtmax, thresh=Rthr, thresh_min=Rtmin, out=rec) elif func_name == 'castTo8bit': rec = convert8bit(rec, cast8bit_min, cast8bit_max) elif func_name == 'bilateral_filter': rec = pyF3D.run_BilateralFilter( rec, spatialRadius=bilateral_srad, rangeRadius=bilateral_rrad) elif func_name == 'write_output': dxchange.write_tiff_stack(rec, fname=filenametowrite, start=y * num_sino_per_chunk + sinoused[0]) print('(took {:.2f} seconds)'.format(time.time() - curtime)) dofunc += 1 if dofunc == len(function_list): break if y < niter - 1 and keepvalues: # Reset original values for next chunk angularrange, numangles, projused, num_proj_per_chunk, numprojchunks, numprojused, numrays, anglelist = keepvalues curtemp = 1 - curtemp curfunc = dofunc if curfunc == len(function_list): break axis = slice_dir[function_list[curfunc]] print("cleaning up temp files") for tmpfile in tempfilenames: try: os.remove(tmpfile) except OSError: pass print("End Time: " + time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime())) print('It took {:.3f} s to process {}'.format(time.time() - start_time, inputPath + filename))
# -*- coding: utf-8 -*- """ Created on Thu Dec 3 16:20:30 2015 @author: lbluque """ import tomopy first, flats, darks, floc = tomopy.read_als_832h5('../../TestDatasets/20151021_105637_ALS10_RT_210lbs_10x.h5', ind_tomo=(0,)) first = tomopy.normalize_nf(first, flats, darks, floc) base = '20151021_105637_ALS10_RT_210lbs_10x_tomopy_phase_' dist = (0.1, 0.5, 1.0, 2.5, 5.0, 10.0, 13.2284, 100.0, 500.0) alpha = (1.0e-3, 1.0e-2, 1.0e-1) for d in dist: for a in alpha: print a phase = tomopy.retrieve_phase(first, pixel_size=0.000129, dist=d, alpha=a, energy=40) name = base + 'dist{0:.1f}_alpha{1:.1e}'.format(d*10.0, a) print(name) tomopy.write_tiff(phase, fname='filters/'+name)
def reconstruct(filename, inputPath="", outputPath="", COR=COR, doOutliers=doOutliers, outlier_diff=outlier_diff, outlier_size=outlier_size, doFWringremoval=doFWringremoval, ringSigma=ringSigma, ringLevel=ringLevel, ringWavelet=ringWavelet, pad_sino=pad_sino, doPhaseRetrieval=doPhaseRetrieval, propagation_dist=propagation_dist, kev=kev, alphaReg=alphaReg, butterworthpars=butterworthpars, doPolarRing=doPolarRing, Rarc=Rarc, Rmaxwidth=Rmaxwidth, Rtmax=Rtmax, Rthr=Rthr, Rtmin=Rtmin, useAutoCOR=useAutoCOR, use360to180=use360to180, num_substacks=num_substacks, recon_slice=recon_slice): # Convert filename to list type if only one file name is given if type(filename) != list: filename = [filename] # If useAutoCor == true, a list of COR will be automatically calculated for all files # If a list of COR is given, only entries with boolean False will use automatic COR calculation if useAutoCOR == True or (len(COR) != len(filename)): logging.info('using auto COR for all input files') COR = [False] * len(filename) for x in range(len(filename)): logging.info('opening data set, checking metadata') fdata, gdata = read_als_832h5_metadata(inputPath[x] + filename[x] + '.h5') pxsize = float( gdata['pxsize'] ) / 10.0 # convert from metadata (mm) to this script (cm) numslices = int(gdata['nslices']) # recon_slice == True, only center slice will be reconstructed # if integer is given, a specific if recon_slice != False: if (type(recon_slice) == int) and (recon_slice <= numslices): sinorange[recon_slice - 1, recon_slice] else: sinorange = [numslices // 2 - 1, numslices // 2] else: sinorange = [0, numslices] # Calculate number of substacks (chunks) substacks = num_substacks #(sinorange[1]-sinorange[0]-1)//num_sino_per_substack+1 if (sinorange[1] - sinorange[0]) >= substacks: num_sino_per_substack = (sinorange[1] - sinorange[0]) // num_substacks else: num_sino_per_substack = 1 firstcor, lastcor = 0, int(gdata['nangles']) - 1 projs, flat, dark, floc = dxchange.read_als_832h5( inputPath[x] + filename[x] + '.h5', ind_tomo=(firstcor, lastcor)) projs = tomopy.normalize_nf(projs, flat, dark, floc) autocor = tomopy.find_center_pc(projs[0], projs[1], tol=0.25) if (type(COR[x]) == bool) or (COR[x] < 0) or (COR[x] == 'auto'): firstcor, lastcor = 0, int(gdata['nangles']) - 1 projs, flat, dark, floc = dxchange.read_als_832h5( inputPath[x] + filename[x] + '.h5', ind_tomo=(firstcor, lastcor)) projs = tomopy.normalize_nf(projs, flat, dark, floc) cor = tomopy.find_center_pc(projs[0], projs[1], tol=0.25) else: cor = COR[x] logging.info( 'Dataset %s, has %d total slices, reconstructing slices %d through %d in %d substack(s), using COR: %f', filename[x], int(gdata['nslices']), sinorange[0], sinorange[1] - 1, substacks, cor) for y in range(0, substacks): logging.info('Starting dataset %s (%d of %d), substack %d of %d', filename[x], x + 1, len(filename), y + 1, substacks) logging.info('Reading sinograms...') projs, flat, dark, floc = dxchange.read_als_832h5( inputPath[x] + filename[x] + '.h5', sino=(sinorange[0] + y * num_sino_per_substack, sinorange[0] + (y + 1) * num_sino_per_substack, 1)) logging.info( 'Doing remove outliers, norm (nearest flats), and -log...') if doOutliers: projs = tomopy.remove_outlier(projs, outlier_diff, size=outlier_size, axis=0) flat = tomopy.remove_outlier(flat, outlier_diff, size=outlier_size, axis=0) tomo = tomopy.normalize_nf(projs, flat, dark, floc) tomo = tomopy.minus_log(tomo, out=tomo) # in place logarithm # Use padding to remove halo in reconstruction if present if pad_sino: npad = int( np.ceil(tomo.shape[2] * np.sqrt(2)) - tomo.shape[2]) // 2 tomo = tomopy.pad(tomo, 2, npad=npad, mode='edge') cor_rec = cor + npad # account for padding else: cor_rec = cor if doFWringremoval: logging.info('Doing ring (Fourier-wavelet) function...') tomo = tomopy.remove_stripe_fw(tomo, sigma=ringSigma, level=ringLevel, pad=True, wname=ringWavelet) if doPhaseRetrieval: logging.info('Doing Phase retrieval...') #tomo = tomopy.retrieve_phase(tomo, pixel_size=pxsize, dist=propagation_dist, energy=kev, alpha=alphaReg, pad=True) tomo = tomopy.retrieve_phase(tomo, pixel_size=pxsize, dist=propagation_dist, energy=kev, alpha=alphaReg, pad=True) logging.info( 'Doing recon (gridrec) function and scaling/masking, with cor %f...', cor_rec) rec = tomopy.recon(tomo, tomopy.angles(tomo.shape[0], 270, 90), center=cor_rec, algorithm='gridrec', filter_name='butterworth', filter_par=butterworthpars) #rec = tomopy.recon(tomo, tomopy.angles(tomo.shape[0], 180+angularrange/2, 180-angularrange/2), center=cor_rec, algorithm='gridrec', filter_name='butterworth', filter_par=butterworthpars) rec /= pxsize # intensity values in cm^-1 if pad_sino: rec = tomopy.circ_mask(rec[:, npad:-npad, npad:-npad], 0) else: rec = tomopy.circ_mask(rec, 0, ratio=1.0, val=0.0) if doPolarRing: logging.info('Doing ring (polar mean filter) function...') rec = tomopy.remove_ring(rec, theta_min=Rarc, rwidth=Rmaxwidth, thresh_max=Rtmax, thresh=Rthr, thresh_min=Rtmin) logging.info('Writing reconstruction slices to %s', filename[x]) #dxchange.write_tiff_stack(rec, fname=outputPath+'alpha'+str(alphaReg)+'/rec'+filename[x]+'/rec'+filename[x], start=sinorange[0]+y*num_sino_per_substack) dxchange.write_tiff_stack(rec, fname=outputPath + 'recon_' + filename[x] + '/recon_' + filename[x], start=sinorange[0] + y * num_sino_per_substack) logging.info('Reconstruction Complete: ' + filename[x])
from scipy.ndimage import gaussian_filter from scipy.ndimage import rotate # f = h5py.File('cone_256/data_cone_256.h5', 'r') # f = h5py.File('data_diff_tf_360_unity.h5', 'r') f = h5py.File('cone_256_filled/data_cone_256_1nm_1um.h5', 'r') dat = f['exchange/data'][...] dat = np.copy(dat) dat = np.abs(dat)**2 # dat = (dat - dat.min()) / (dat.max() - dat.min()) print(dat) dat = tomopy.retrieve_phase(dat, pixel_size=1. - 7, dist=1.e-4, alpha=1.e-3, energy=5.) dxchange.write_tiff(dat, 'cone_256_filled/paganin_obj/pr/pr', dtype='float32', overwrite=True) dat = tomopy.minus_log(dat) extra_options = {'MinConstraint': 0} options = {'num_iter': 200} t0 = time.time() rec = tomopy.recon( dat, theta=tomopy.angles(dat.shape[0]),
def center(io_paras, data_paras, center_start, center_end, center_step, diag_cycle=0, mode='diag', normalize=True, stripe_removal=10, phase_retrieval=False): # Input and output datafile = io_paras.get('datafile') path2white = io_paras.get('path2white', datafile) path2dark = io_paras.get('path2dark', path2white) out_dir = io_paras.get('out_dir') diag_cent_dir = io_paras.get('diag_cent_dir', out_dir+"/center_diagnose/") recon_dir = io_paras.get('recon_dir', out_dir+"/recon/") out_prefix = io_paras.get('out_prefix', "recon_") # Parameters of dataset NumCycles = data_paras.get('NumCycles', 1) # Number of cycles used for recon ProjPerCycle = data_paras.get('ProjPerCycle') # Number of projections per cycle, N_theta cycle_offset = data_paras.get('cycle_offset', 0) # Offset in output cycle number proj_start = data_paras.get('proj_start', 0) # Starting projection of reconstruction proj_step = data_paras.get('proj_step') z_start = data_paras.get('z_start', 0) z_end = data_paras.get('z_end', z_start+1) z_step = data_paras.get('z_step') x_start = data_paras.get('x_start') x_end = data_paras.get('x_end', x_start+1) x_step = data_paras.get('x_step') white_start = data_paras.get('white_start') white_end = data_paras.get('white_end') dark_start = data_paras.get('dark_start') dark_end = data_paras.get('dark_end') # Set start and end of each subcycle projections_start = diag_cycle * ProjPerCycle + proj_start projections_end = projections_start + ProjPerCycle slice1 = slice(projections_start, projections_end, proj_step) slice2 = slice(z_start, z_end, z_step) slice3 = slice(x_start, x_end, x_step) slices = (slice1, slice2, slice3) white_slices = (slice(white_start, white_end), slice2, slice3) dark_slices = (slice(dark_start, dark_end), slice2, slice3) print("Running center diagnosis (projs %s to %s)" % (projections_start, projections_end)) # Read HDF5 file. print("Reading datafile %s..." % datafile, end="") sys.stdout.flush() data, white, dark = reader.read_aps_2bm(datafile, slices, white_slices, dark_slices, path2white=path2white, path2dark=path2dark) theta = gen_theta(data.shape[0]) print("Done!") print("Data shape = %s;\nwhite shape = %s;\ndark shape = %s." % (data.shape, white.shape, dark.shape)) ## Normalize dataset using data_white and data_dark if normalize: data = tomopy.normalize(data, white, dark, cutoff=None, ncore=_ncore, nchunk=None) ## Remove stripes caused by dead pixels in the detector if stripe_removal: data = tomopy.remove_stripe_fw(data, level=stripe_removal, wname='db5', sigma=2, pad=True, ncore=None, nchunk=None) # data = tomopy.remove_stripe_ti(data, nblock=0, alpha=1.5, # ncore=None, nchunk=None) # # Show preprocessed projection # plt.figure("%s-prep" % projections_start) # plt.imshow(d.data[0,:,:], cmap=cm.Greys_r) # plt.savefig(out_dir+"/preprocess/%s-prep.jpg" # % projections_start) # # plt.show() # continue ## Phase retrieval if phase_retrieval: data = tomopy.retrieve_phase(data, pixel_size=6.5e-5, dist=33, energy=30, alpha=1e-3, pad=True, ncore=_ncore, nchunk=None) ## Determine and set the center of rotation ### Using optimization method to automatically find the center # d.optimize_center() if 'opti' in mode: print("Optimizing center ...", end="") sys.stdout.flush() rot_center = tomopy.find_center(data, theta, ind=None, emission=True, init=None, tol=0.5, mask=True, ratio=1.) print("Done!") print("center = %s" % rot_center) ### Output the reconstruction results using a range of centers, ### and then manually find the optimal center. if 'diag' in mode: if not os.path.exists(diag_cent_dir): os.makedirs(diag_cent_dir) print("Testing centers ...", end="") sys.stdout.flush() tomopy.write_center(data, theta, dpath=diag_cent_dir, cen_range=[center_start, center_end, center_step], ind=None, emission=False, mask=False, ratio=1.) print("Done!")
def recon3(io_paras, data_paras, rot_center=None, normalize=True, stripe_removal=10, stripe_sigma=2, phase_retrieval=False, opt_center=False, diag_center=False, output="tiff", z_recon_size=None): # Input and output datafile = io_paras.get('datafile') path2white = io_paras.get('path2white', datafile) path2dark = io_paras.get('path2dark', path2white) out_dir = io_paras.get('out_dir') diag_cent_dir = io_paras.get('diag_cent_dir', out_dir + "/center_diagnose/") recon_dir = io_paras.get('recon_dir', out_dir + "/recon/") out_prefix = io_paras.get('out_prefix', "recon_") # Parameters of dataset NumCycles = data_paras.get('NumCycles', 1) # Number of cycles used for recon ProjPerCycle = data_paras.get( 'ProjPerCycle') # Number of projections per cycle, N_theta cycle_offset = data_paras.get('cycle_offset', 0) # Offset in output cycle number proj_start = data_paras.get('proj_start', 0) # Starting projection of reconstruction proj_step = data_paras.get('proj_step') z_start = data_paras.get('z_start', 0) z_end = data_paras.get('z_end', z_start + 1) z_step = data_paras.get('z_step') x_start = data_paras.get('x_start') x_end = data_paras.get('x_end', x_start + 1) x_step = data_paras.get('x_step') white_start = data_paras.get('white_start') white_end = data_paras.get('white_end') dark_start = data_paras.get('dark_start') dark_end = data_paras.get('dark_end') # TIMBIR parameters NumSubCycles = data_paras.get('NumSubCycles', 1) # Number of subcycles in one cycle, K SlewSpeed = data_paras.get('SlewSpeed', 0) # In deg/s MinAcqTime = data_paras.get('MinAcqTime', 0) # In s TotalNumCycles = data_paras.get( 'TotalNumCycles', 1) # Total number of cycles in the full scan data ProjPerRecon = data_paras.get( 'ProjPerRecon', ProjPerCycle) # Number of projections per reconstruction # Calculate thetas for interlaced scan theta = gen_theta_timbir(NumSubCycles, ProjPerCycle, SlewSpeed, MinAcqTime, TotalNumCycles) if ProjPerRecon is None: ProjPerCycle = theta.size // TotalNumCycles else: ProjPerCycle = ProjPerRecon print("Will use %s projections per reconstruction." % ProjPerCycle) # Distribute z slices to processes if z_step is None: z_step = 1 z_pool = get_pool(z_start, z_end, z_step, z_chunk_size=z_recon_size, fmt='slice') slice3 = slice(x_start, x_end, x_step) rot_center_copy = rot_center for cycle in xrange(NumCycles): # Set start and end of each cycle projections_start = cycle * ProjPerCycle + proj_start projections_end = projections_start + ProjPerCycle slice1 = slice(projections_start, projections_end, proj_step) # Setup continuous output if "cont" in output: if not os.path.exists(recon_dir): os.makedirs(recon_dir) cont_fname = recon_dir+"/"+out_prefix+"t_%d_z_%d_%d.bin" \ % (cycle + cycle_offset, z_start, z_end) cont_file = file(cont_fname, 'wb') # Distribute z slices to processes for i in range(_rank, len(z_pool), _nprocs): slice2 = z_pool[i] slices = (slice1, slice2, slice3) white_slices = (slice(white_start, white_end), slice2, slice3) dark_slices = (slice(dark_start, dark_end), slice2, slice3) print( "Running cycle #%s (projs %s to %s, z = %s - %s) on process %s of %s" % (cycle, projections_start, projections_end, slice2.start, slice2.stop, _rank, _nprocs)) # Read HDF5 file. print("Reading datafile %s..." % datafile, end="") sys.stdout.flush() data, white, dark = reader.read_aps_2bm(datafile, slices, white_slices, dark_slices, path2white=path2white, path2dark=path2dark) # data += 1 # theta = gen_theta(data.shape[0]) print("Done!") print("Data shape = %s;\nwhite shape = %s;\ndark shape = %s." % (data.shape, white.shape, dark.shape)) # data = tomopy.focus_region(data, dia=1560, xcoord=1150, ycoord=1080, # center=rot_center, pad=False, corr=True) # rot_center = None # print("Data shape = %s;\nwhite shape = %s;\ndark shape = %s." # % (data.shape, white.shape, dark.shape)) ## Normalize dataset using data_white and data_dark if normalize: print("Normalizing data ...") # white = white.mean(axis=0).reshape(-1, *data.shape[1:]) # dark = dark.mean(axis=0).reshape(-1, *data.shape[1:]) # data = (data - dark) / (white - dark) data = tomopy.normalize(data, white, dark, cutoff=None, ncore=_ncore, nchunk=_nchunk)[...] ## Remove stripes caused by dead pixels in the detector if stripe_removal: print("Removing stripes ...") data = tomopy.remove_stripe_fw(data, level=stripe_removal, wname='db5', sigma=stripe_sigma, pad=True, ncore=_ncore, nchunk=_nchunk) # data = tomopy.remove_stripe_ti(data, nblock=0, alpha=1.5, # ncore=None, nchunk=None) # # Show preprocessed projection # plt.figure("%s-prep" % projections_start) # plt.imshow(d.data[0,:,:], cmap=cm.Greys_r) # plt.savefig(out_dir+"/preprocess/%s-prep.jpg" # % projections_start) # # plt.show() # continue ## Phase retrieval if phase_retrieval: print("Retrieving phase ...") data = tomopy.retrieve_phase(data, pixel_size=1.1e-4, dist=6, energy=25.7, alpha=1e-2, pad=True, ncore=_ncore, nchunk=_nchunk) ## Determine and set the center of rotation if opt_center: # or (rot_center == None): ### Using optimization method to automatically find the center # d.optimize_center() print("Optimizing center ...", end="") sys.stdout.flush() rot_center = tomopy.find_center(data, theta, ind=None, emission=True, init=None, tol=0.5, mask=True, ratio=1.) print("Done!") print("center = %s" % rot_center) if diag_center: ### Output the reconstruction results using a range of centers, ### and then manually find the optimal center. # d.diagnose_center() if not os.path.exists(diag_cent_dir): os.makedirs(diag_cent_dir) print("Testing centers ...", end="") sys.stdout.flush() tomopy.write_center( data, theta, dpath=diag_cent_dir, cen_range=[center_start, center_end, center_step], ind=None, emission=False, mask=False, ratio=1.) print("Done!") ## Flip odd frames # if (cycle % 2): # data[...] = data[...,::-1] # rot_center = data.shape[-1] - rot_center_copy # else: # rot_center = rot_center_copy ## Reconstruction using FBP print("Running gridrec ...", end="") sys.stdout.flush() recon = tomopy.recon( data, theta[slice1], center=rot_center, emission=False, algorithm='gridrec', # num_gridx=None, num_gridy=None, filter_name='shepp', ncore=_ncore, nchunk=_nchunk) print("Done!") ## Collect background # if cycle == 0: # bg = recon # elif cycle < 4: # bg += recon # else: # recon -= bg/4. # Write to stack of TIFFs. if not os.path.exists(recon_dir): os.makedirs(recon_dir) out_fname = recon_dir + "/" + out_prefix + "t_%d_z_" % ( cycle + cycle_offset) if "hdf" in output: hdf_fname = out_fname + "%d_%d.hdf5" % (slice2.start, slice2.stop) print("Writing reconstruction output file %s..." % hdf_fname, end="") sys.stdout.flush() tomopy.write_hdf5(recon, fname=hdf_fname, gname='exchange', overwrite=False) print("Done!") if "tif" in output: if "stack" in output: # single stacked file for multiple z tiff_fname = out_fname + "%d_%d.tiff" % (slice2.start, slice2.stop) print("Writing reconstruction tiff files %s ..." % tiff_fname, end="") sys.stdout.flush() tomopy.write_tiff(recon, fname=tiff_fname, overwrite=False) print("Done!") else: # separate files for different z for iz, z in enumerate( range(slice2.start, slice2.stop, slice2.step)): tiff_fname = out_fname + "%d.tiff" % z print("Writing reconstruction tiff files %s ..." % tiff_fname, end="") sys.stdout.flush() tomopy.write_tiff(recon[iz], fname=tiff_fname, overwrite=False) print("Done!") if "bin" in output: bin_fname = out_fname + "%d_%d.bin" % (slice2.start, slice2.stop) print("Writing reconstruction to binary files %s..." % bin_fname, end="") sys.stdout.flush() recon.tofile(bin_fname) if "cont" in output: print("Writing reconstruction to binary files %s..." % cont_fname, end="") sys.stdout.flush() recon.tofile(cont_file) print("Done!") if "cont" in output: cont_file.close() if _usempi: comm.Barrier() if _rank == 0: print("All done!")
def prepare_slice(grid, shift_grid, grid_lines, slice_in_tile, ds_level=0, method='max', blend_options=None, pad=None, rot_center=None, assert_width=None, sino_blur=None, color_correction=False, normalize=True, mode='180', phase_retrieval=None, data_format='aps_32id', **kwargs): sinos = [None] * grid.shape[1] t = time.time() for col in range(grid.shape[1]): if os.path.exists(grid[grid_lines[col], col]): sinos[col] = load_sino(grid[grid_lines[col], col], slice_in_tile[col], normalize=normalize, data_format=data_format) else: pass internal_print('reading: ' + str(time.time() - t)) t = time.time() row_sino = register_recon(grid, grid_lines, shift_grid, sinos, method=method, blend_options=blend_options, color_correction=color_correction, assert_width=assert_width) if not pad is None: row_sino, rot_center = pad_sino(row_sino, pad, rot_center) internal_print('stitch: ' + str(time.time() - t)) internal_print('final size: ' + str(row_sino.shape)) t = time.time() row_sino = tomopy.downsample(row_sino, level=ds_level) internal_print('downsample: ' + str(time.time() - t)) internal_print('new shape : ' + str(row_sino.shape)) # t = time.time() # row_sino = tomopy.remove_stripe_fw(row_sino, 2) # print('strip removal: ' + str(time.time() - t)) # Minus Log row_sino = tomosaic.util.preprocess(row_sino) if sino_blur is not None: row_sino[:, 0, :] = gaussian_filter(row_sino[:, 0, :], sino_blur) if mode == '360': overlap = 2 * (row_sino.shape[2] - rot_center) row_sino = tomosaic.sino_360_to_180(row_sino, overlap=overlap, rotation='right') if phase_retrieval: row_sino = tomopy.retrieve_phase(row_sino, kwargs['pixel_size'], kwargs['dist'], kwargs['energy'], kwargs['alpha']) return row_sino, rot_center
def recon_single(fname, center, dest_folder, sino_range=None, chunk_size=50, read_theta=True, pad_length=0, phase_retrieval=False, ring_removal=True, algorithm='gridrec', flattened_radius=40, crop=None, remove_padding=True, **kwargs): prj_shape = read_data_adaptive(fname, shape_only=True) if read_theta: theta = read_data_adaptive(fname, proj=(0, 1), return_theta=True) else: theta = tomopy.angles(prj_shape[0]) if sino_range is None: sino_st = 0 sino_end = prj_shape[1] sino_step = 1 else: sino_st, sino_end = sino_range[:2] if len(sino_range) == 3: sino_step = sino_range[-1] else: sino_step = 1 chunks = np.arange(0, sino_end, chunk_size * sino_step, dtype='int') for chunk_st in chunks: t0 = time.time() chunk_end = min(chunk_st + chunk_size * sino_step, prj_shape[1]) data, flt, drk = read_data_adaptive(fname, sino=(chunk_st, chunk_end, sino_step), return_theta=False) data = tomopy.normalize(data, flt, drk) data = data.astype('float32') data = tomopy.remove_stripe_ti(data, alpha=4) if phase_retrieval: data = tomopy.retrieve_phase(data, kwargs['pixel_size'], kwargs['dist'], kwargs['energy'], kwargs['alpha']) if pad_length != 0: data = pad_sinogram(data, pad_length) if ring_removal: data = tomopy.remove_stripe_ti(data, alpha=4) rec0 = tomopy.recon(data, theta, center=center + pad_length, algorithm=algorithm, **kwargs) rec = tomopy.remove_ring(np.copy(rec0)) cent = int((rec.shape[1] - 1) / 2) xx, yy = np.meshgrid(np.arange(rec.shape[2]), np.arange(rec.shape[1])) mask0 = ((xx - cent)**2 + (yy - cent)**2 <= flattened_radius**2) mask = np.zeros(rec.shape, dtype='bool') for i in range(mask.shape[0]): mask[i, :, :] = mask0 rec[mask] = (rec[mask] + rec0[mask]) / 2 else: rec = tomopy.recon(data, theta, center=center + pad_length, algorithm=algorithm, **kwargs) if pad_length != 0 and remove_padding: rec = rec[:, pad_length:pad_length + prj_shape[2], pad_length:pad_length + prj_shape[2]] rec = tomopy.circ_mask(rec, axis=0, ratio=0.95) if crop is not None: crop = np.asarray(crop) rec = rec[:, crop[0, 0]:crop[1, 0], crop[0, 1]:crop[1, 1]] for i in range(rec.shape[0]): slice = chunk_st + sino_step * i internal_print('Saving slice {}'.format(slice)) dxchange.write_tiff( rec[i, :, :], fname=os.path.join(dest_folder, 'recon_{:05d}.tiff').format(slice), dtype='float32') internal_print('Block finished in {:.2f} s.'.format(time.time() - t0))
import dxchange import numpy as np import tomopy src_fname = 'data/cameraman_512_dp.tiff' actual_size = [512, 512] energy_ev = 25000. psize_cm = 1e-4 dist_cm = 50 img = dxchange.read_tiff(src_fname) img = np.sqrt(img) img = img[np.newaxis, :, :] res = np.squeeze( tomopy.retrieve_phase(img, psize_cm, dist_cm, energy_ev / 1000, alpha=5e-2)) dxchange.write_tiff(res, 'data/cameraman_512_paganin', dtype='float32', overwrite=True)
def recon( filename, inputPath = './', outputPath = None, outputFilename = None, doOutliers1D = False, # outlier removal in 1d (along sinogram columns) outlier_diff1D = 750, # difference between good data and outlier data (outlier removal) outlier_size1D = 3, # radius around each pixel to look for outliers (outlier removal) doOutliers2D = False, # outlier removal, standard 2d on each projection outlier_diff2D = 750, # difference between good data and outlier data (outlier removal) outlier_size2D = 3, # radius around each pixel to look for outliers (outlier removal) doFWringremoval = True, # Fourier-wavelet ring removal doTIringremoval = False, # Titarenko ring removal doSFringremoval = False, # Smoothing filter ring removal ringSigma = 3, # damping parameter in Fourier space (Fourier-wavelet ring removal) ringLevel = 8, # number of wavelet transform levels (Fourier-wavelet ring removal) ringWavelet = 'db5', # type of wavelet filter (Fourier-wavelet ring removal) ringNBlock = 0, # used in Titarenko ring removal (doTIringremoval) ringAlpha = 1.5, # used in Titarenko ring removal (doTIringremoval) ringSize = 5, # used in smoothing filter ring removal (doSFringremoval) doPhaseRetrieval = False, # phase retrieval alphaReg = 0.0002, # smaller = smoother (used for phase retrieval) propagation_dist = 75, # sample-to-scintillator distance (phase retrieval) kev = 24, # energy level (phase retrieval) butterworth_cutoff = 0.25, #0.1 would be very smooth, 0.4 would be very grainy (reconstruction) butterworth_order = 2, # for reconstruction doTranslationCorrection = False, # correct for linear drift during scan xshift = 0, # undesired dx transation correction (from 0 degree to 180 degree proj) yshift = 0, # undesired dy transation correction (from 0 degree to 180 degree proj) doPolarRing = False, # ring removal Rarc=30, # min angle needed to be considered ring artifact (ring removal) Rmaxwidth=100, # max width of rings to be filtered (ring removal) Rtmax=3000.0, # max portion of image to filter (ring removal) Rthr=3000.0, # max value of offset due to ring artifact (ring removal) Rtmin=-3000.0, # min value of image to filter (ring removal) cor=None, # center of rotation (float). If not used then cor will be detected automatically corFunction = 'pc', # center of rotation function to use - can be 'pc', 'vo', or 'nm' voInd = None, # index of slice to use for cor search (vo) voSMin = -40, # min radius for searching in sinogram (vo) voSMax = 40, # max radius for searching in sinogram (vo) voSRad = 10, # search radius (vo) voStep = 0.5, # search step (vo) voRatio = 2.0, # ratio of field-of-view and object size (vo) voDrop = 20, # drop lines around vertical center of mask (vo) nmInd = None, # index of slice to use for cor search (nm) nmInit = None, # initial guess for center (nm) nmTol = 0.5, # desired sub-pixel accuracy (nm) nmMask = True, # if True, limits analysis to circular region (nm) nmRatio = 1.0, # ratio of radius of circular mask to edge of reconstructed image (nm) nmSinoOrder = False, # if True, analyzes in sinogram space. If False, analyzes in radiograph space use360to180 = False, # use 360 to 180 conversion doBilateralFilter = False, # if True, uses bilateral filter on image just before write step # NOTE: image will be converted to 8bit if it is not already bilateral_srad = 3, # spatial radius for bilateral filter (image will be converted to 8bit if not already) bilateral_rrad = 30, # range radius for bilateral filter (image will be converted to 8bit if not already) castTo8bit = False, # convert data to 8bit before writing cast8bit_min=-10, # min value if converting to 8bit cast8bit_max=30, # max value if converting to 8bit useNormalize_nf = False, # normalize based on background intensity (nf) chunk_proj = 100, # chunk size in projection direction chunk_sino = 100, # chunk size in sinogram direction npad = None, # amount to pad data before reconstruction projused = None, #should be slicing in projection dimension (start,end,step) sinoused = None, #should be sliceing in sinogram dimension (start,end,step). If first value is negative, it takes the number of slices from the second value in the middle of the stack. correcttilt = 0, #tilt dataset tiltcenter_slice = None, # tilt center (x direction) tiltcenter_det = None, # tilt center (y direction) angle_offset = 0, #this is the angle offset from our default (270) so that tomopy yields output in the same orientation as previous software (Octopus) anglelist = None, #if not set, will assume evenly spaced angles which will be calculated by the angular range and number of angles found in the file. if set to -1, will read individual angles from each image. alternatively, a list of angles can be passed. doBeamHardening = False, #turn on beam hardening correction, based on "Correction for beam hardening in computed tomography", Gabor Herman, 1979 Phys. Med. Biol. 24 81 BeamHardeningCoefficients = None, #6 values, tomo = a0 + a1*tomo + a2*tomo^2 + a3*tomo^3 + a4*tomo^4 + a5*tomo^5 projIgnoreList = None, #projections to be ignored in the reconstruction (for simplicity in the code, they will not be removed and will be processed as all other projections but will be set to zero absorption right before reconstruction. *args, **kwargs): start_time = time.time() print("Start {} at:".format(filename)+time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime())) outputPath = inputPath if outputPath is None else outputPath outputFilename = filename if outputFilename is None else outputFilename outputFilename = outputFilename.replace('.h5','') tempfilenames = [outputPath+'tmp0.h5',outputPath+'tmp1.h5'] filenametowrite = outputPath+'/rec'+filename.strip(".h5")+'/'+outputFilename #filenametowrite = outputPath+'/rec'+filename+'/'+outputFilename print("cleaning up previous temp files", end="") for tmpfile in tempfilenames: try: os.remove(tmpfile) except OSError: pass print(", reading metadata") datafile = h5py.File(inputPath+filename, 'r') gdata = dict(dxchange.reader._find_dataset_group(datafile).attrs) pxsize = float(gdata['pxsize'])/10 # /10 to convert units from mm to cm numslices = int(gdata['nslices']) numangles = int(gdata['nangles']) angularrange = float(gdata['arange']) numrays = int(gdata['nrays']) npad = int(np.ceil(numrays * np.sqrt(2)) - numrays)//2 if npad is None else npad projused = (0,numangles-1,1) if projused is None else projused # ndark = int(gdata['num_dark_fields']) # ind_dark = list(range(0, ndark)) # group_dark = [numangles - 1] inter_bright = int(gdata['i0cycle']) nflat = int(gdata['num_bright_field']) ind_flat = list(range(0, nflat)) if inter_bright > 0: group_flat = list(range(0, numangles, inter_bright)) if group_flat[-1] != numangles - 1: group_flat.append(numangles - 1) elif inter_bright == 0: group_flat = [0, numangles - 1] else: group_flat = None ind_tomo = list(range(0, numangles)) floc_independent = dxchange.reader._map_loc(ind_tomo, group_flat) #figure out the angle list (a list of angles, one per projection image) dtemp = datafile[list(datafile.keys())[0]] fltemp = list(dtemp.keys()) firstangle = float(dtemp[fltemp[0]].attrs.get('rot_angle',0)) if anglelist is None: #the offset angle should offset from the angle of the first image, which is usually 0, but in the case of timbir data may not be. #we add the 270 to be inte same orientation as previous software used at bl832 angle_offset = 270 + angle_offset - firstangle anglelist = tomopy.angles(numangles, angle_offset, angle_offset-angularrange) elif anglelist==-1: anglelist = np.zeros(shape=numangles) for icount in range(0,numangles): anglelist[icount] = np.pi/180*(270 + angle_offset - float(dtemp[fltemp[icount]].attrs['rot_angle'])) #if projused is different than default, need to chnage numangles and angularrange #can't do useNormalize_nf and doOutliers2D at the same time, or doOutliers2D and doOutliers1D at the same time, b/c of the way we chunk, for now just disable that if useNormalize_nf==True and doOutliers2D==True: useNormalize_nf = False print("we cannot currently do useNormalize_nf and doOutliers2D at the same time, turning off useNormalize_nf") if doOutliers2D==True and doOutliers1D==True: doOutliers1D = False print("we cannot currently do doOutliers1D and doOutliers2D at the same time, turning off doOutliers1D") #figure out how user can pass to do central x number of slices, or set of slices dispersed throughout (without knowing a priori the value of numslices) if sinoused is None: sinoused = (0,numslices,1) elif sinoused[0]<0: sinoused=(int(np.floor(numslices/2.0)-np.ceil(sinoused[1]/2.0)),int(np.floor(numslices/2.0)+np.floor(sinoused[1]/2.0)),1) num_proj_per_chunk = np.minimum(chunk_proj,projused[1]-projused[0]) numprojchunks = (projused[1]-projused[0]-1)//num_proj_per_chunk+1 num_sino_per_chunk = np.minimum(chunk_sino,sinoused[1]-sinoused[0]) numsinochunks = (sinoused[1]-sinoused[0]-1)//num_sino_per_chunk+1 numprojused = (projused[1]-projused[0])//projused[2] numsinoused = (sinoused[1]-sinoused[0])//sinoused[2] BeamHardeningCoefficients = (0, 1, 0, 0, 0, .1) if BeamHardeningCoefficients is None else BeamHardeningCoefficients if cor is None: print("Detecting center of rotation", end="") if angularrange>300: lastcor = int(np.floor(numangles/2)-1) else: lastcor = numangles-1 #I don't want to see the warnings about the reader using a deprecated variable in dxchange with warnings.catch_warnings(): warnings.simplefilter("ignore") tomo, flat, dark, floc = dxchange.read_als_832h5(inputPath+filename,ind_tomo=(0,lastcor)) tomo = tomo.astype(np.float32) if useNormalize_nf: tomopy.normalize_nf(tomo, flat, dark, floc, out=tomo) else: tomopy.normalize(tomo, flat, dark, out=tomo) if corFunction == 'vo': # same reason for catching warnings as above with warnings.catch_warnings(): warnings.simplefilter("ignore") cor = tomopy.find_center_vo(tomo, ind=voInd, smin=voSMin, smax=voSMax, srad=voSRad, step=voStep, ratio=voRatio, drop=voDrop) elif corFunction == 'nm': cor = tomopy.find_center(tomo, tomopy.angles(numangles, angle_offset, angle_offset-angularrange), ind=nmInd, init=nmInit, tol=nmTol, mask=nmMask, ratio=nmRatio, sinogram_order=nmSinoOrder) elif corFunction == 'pc': cor = tomopy.find_center_pc(tomo[0], tomo[1], tol=0.25) else: raise ValueError("\'corFunction\' must be one of: [ pc, vo, nm ].") print(", {}".format(cor)) else: print("using user input center of {}".format(cor)) function_list = [] if doOutliers1D: function_list.append('remove_outlier1d') if doOutliers2D: function_list.append('remove_outlier2d') if useNormalize_nf: function_list.append('normalize_nf') else: function_list.append('normalize') function_list.append('minus_log') if doBeamHardening: function_list.append('beam_hardening') if doFWringremoval: function_list.append('remove_stripe_fw') if doTIringremoval: function_list.append('remove_stripe_ti') if doSFringremoval: function_list.append('remove_stripe_sf') if correcttilt: function_list.append('correcttilt') if use360to180: function_list.append('do_360_to_180') if doPhaseRetrieval: function_list.append('phase_retrieval') function_list.append('recon_mask') if doPolarRing: function_list.append('polar_ring') if castTo8bit: function_list.append('castTo8bit') if doBilateralFilter: function_list.append('bilateral_filter') function_list.append('write_output') # Figure out first direction to slice for func in function_list: if slice_dir[func] != 'both': axis = slice_dir[func] break done = False curfunc = 0 curtemp = 0 while True: # Loop over reading data in certain chunking direction if axis=='proj': niter = numprojchunks else: niter = numsinochunks for y in range(niter): # Loop over chunks print("{} chunk {} of {}".format(axis, y+1, niter)) if curfunc==0: with warnings.catch_warnings(): warnings.simplefilter("ignore") if axis=='proj': tomo, flat, dark, floc = dxchange.read_als_832h5(inputPath+filename,ind_tomo=range(y*num_proj_per_chunk+projused[0],np.minimum((y + 1)*num_proj_per_chunk+projused[0],numangles)),sino=(sinoused[0],sinoused[1], sinoused[2]) ) else: tomo, flat, dark, floc = dxchange.read_als_832h5(inputPath+filename,ind_tomo=range(projused[0],projused[1],projused[2]),sino=(y*num_sino_per_chunk+sinoused[0],np.minimum((y + 1)*num_sino_per_chunk+sinoused[0],numslices),1) ) else: if axis=='proj': start, end = y * num_proj_per_chunk, np.minimum((y + 1) * num_proj_per_chunk,numprojused) tomo = dxchange.reader.read_hdf5(tempfilenames[curtemp],'/tmp/tmp',slc=((start,end,1),(0,numslices,1),(0,numrays,1))) #read in intermediate file else: start, end = y * num_sino_per_chunk, np.minimum((y + 1) * num_sino_per_chunk,numsinoused) tomo = dxchange.reader.read_hdf5(tempfilenames[curtemp],'/tmp/tmp',slc=((0,numangles,1),(start,end,1),(0,numrays,1))) dofunc = curfunc keepvalues = None while True: # Loop over operations to do in current chunking direction func_name = function_list[dofunc] newaxis = slice_dir[func_name] if newaxis != 'both' and newaxis != axis: # We have to switch axis, so flush to disk if y==0: try: os.remove(tempfilenames[1-curtemp]) except OSError: pass appendaxis = 1 if axis=='sino' else 0 dxchange.writer.write_hdf5(tomo,fname=tempfilenames[1-curtemp],gname='tmp',dname='tmp',overwrite=False,appendaxis=appendaxis) #writing intermediate file... break print(func_name, end=" ") curtime = time.time() if func_name == 'remove_outlier1d': tomo = tomo.astype(np.float32,copy=False) remove_outlier1d(tomo, outlier_diff1D, size=outlier_size1D, out=tomo) if func_name == 'remove_outlier2d': tomo = tomo.astype(np.float32,copy=False) tomopy.remove_outlier(tomo, outlier_diff2D, size=outlier_size2D, axis=0, out=tomo) elif func_name == 'normalize_nf': tomo = tomo.astype(np.float32,copy=False) tomopy.normalize_nf(tomo, flat, dark, floc_independent, out=tomo) #use floc_independent b/c when you read file in proj chunks, you don't get the correct floc returned right now to use here. elif func_name == 'normalize': tomo = tomo.astype(np.float32,copy=False) tomopy.normalize(tomo, flat, dark, out=tomo) elif func_name == 'minus_log': mx = np.float32(0.00000000000000000001) ne.evaluate('where(tomo>mx, tomo, mx)', out=tomo) tomopy.minus_log(tomo, out=tomo) elif func_name == 'beam_hardening': loc_dict = {'a{}'.format(i):np.float32(val) for i,val in enumerate(BeamHardeningCoefficients)} tomo = ne.evaluate('a0 + a1*tomo + a2*tomo**2 + a3*tomo**3 + a4*tomo**4 + a5*tomo**5', local_dict=loc_dict, out=tomo) elif func_name == 'remove_stripe_fw': tomo = tomopy.remove_stripe_fw(tomo, sigma=ringSigma, level=ringLevel, pad=True, wname=ringWavelet) elif func_name == 'remove_stripe_ti': tomo = tomopy.remove_stripe_ti(tomo, nblock=ringNBlock, alpha=ringAlpha) elif func_name == 'remove_stripe_sf': tomo = tomopy.remove_stripe_sf(tomo, size=ringSize) elif func_name == 'correcttilt': if tiltcenter_slice is None: tiltcenter_slice = numslices/2. if tiltcenter_det is None: tiltcenter_det = tomo.shape[2]/2 new_center = tiltcenter_slice - 0.5 - sinoused[0] center_det = tiltcenter_det - 0.5 #add padding of 10 pixels, to be unpadded right after tilt correction. This makes the tilted image not have zeros at certain edges, which matters in cases where sample is bigger than the field of view. For the small amounts we are generally tilting the images, 10 pixels is sufficient. # tomo = tomopy.pad(tomo, 2, npad=10, mode='edge') # center_det = center_det + 10 cntr = (center_det, new_center) for b in range(tomo.shape[0]): tomo[b] = st.rotate(tomo[b], correcttilt, center=cntr, preserve_range=True, order=1, mode='edge', clip=True) #center=None means image is rotated around its center; order=1 is default, order of spline interpolation # tomo = tomo[:, :, 10:-10] elif func_name == 'do_360_to_180': # Keep values around for processing the next chunk in the list keepvalues = [angularrange, numangles, projused, num_proj_per_chunk, numprojchunks, numprojused, numrays, anglelist] #why -.5 on one and not on the other? if tomo.shape[0]%2>0: tomo = sino_360_to_180(tomo[0:-1,:,:], overlap=int(np.round((tomo.shape[2]-cor-.5))*2), rotation='right') angularrange = angularrange/2 - angularrange/(tomo.shape[0]-1) else: tomo = sino_360_to_180(tomo[:,:,:], overlap=int(np.round((tomo.shape[2]-cor))*2), rotation='right') angularrange = angularrange/2 numangles = int(numangles/2) projused = (0,numangles-1,1) num_proj_per_chunk = np.minimum(chunk_proj,projused[1]-projused[0]) numprojchunks = (projused[1]-projused[0]-1)//num_proj_per_chunk+1 numprojused = (projused[1]-projused[0])//projused[2] numrays = tomo.shape[2] anglelist = anglelist[:numangles] elif func_name == 'phase_retrieval': tomo = tomopy.retrieve_phase(tomo, pixel_size=pxsize, dist=propagation_dist, energy=kev, alpha=alphaReg, pad=True) elif func_name == 'translation_correction': tomo = linear_translation_correction(tomo,dx=xshift,dy=yshift,interpolation=False): elif func_name == 'recon_mask': tomo = tomopy.pad(tomo, 2, npad=npad, mode='edge') if projIgnoreList is not None: for badproj in projIgnoreList: tomo[badproj] = 0 rec = tomopy.recon(tomo, anglelist, center=cor+npad, algorithm='gridrec', filter_name='butterworth', filter_par=[butterworth_cutoff, butterworth_order]) rec = rec[:, npad:-npad, npad:-npad] rec /= pxsize # convert reconstructed voxel values from 1/pixel to 1/cm rec = tomopy.circ_mask(rec, 0) elif func_name == 'polar_ring': rec = np.ascontiguousarray(rec, dtype=np.float32) rec = tomopy.remove_ring(rec, theta_min=Rarc, rwidth=Rmaxwidth, thresh_max=Rtmax, thresh=Rthr, thresh_min=Rtmin,out=rec) elif func_name == 'castTo8bit': rec = convert8bit(rec, cast8bit_min, cast8bit_max) elif func_name == 'bilateral_filter': rec = pyF3D.run_BilateralFilter(rec, spatialRadius=bilateral_srad, rangeRadius=bilateral_rrad) elif func_name == 'write_output': dxchange.write_tiff_stack(rec, fname=filenametowrite, start=y*num_sino_per_chunk + sinoused[0]) print('(took {:.2f} seconds)'.format(time.time()-curtime)) dofunc+=1 if dofunc==len(function_list): break if y<niter-1 and keepvalues: # Reset original values for next chunk angularrange, numangles, projused, num_proj_per_chunk, numprojchunks, numprojused, numrays, anglelist = keepvalues curtemp = 1 - curtemp curfunc = dofunc if curfunc==len(function_list): break axis = slice_dir[function_list[curfunc]] print("cleaning up temp files") for tmpfile in tempfilenames: try: os.remove(tmpfile) except OSError: pass print("End Time: "+time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime())) print('It took {:.3f} s to process {}'.format(time.time()-start_time,inputPath+filename))
# dxchange.write_tiff_stack(tomo, fname=sinofilenametowrite, start=sinorange[0]+y*num_sino_per_chunk,axis=1) if doFWringremoval == True and useFLOCforFWringremoval != True: logging.info('Doing ring (Fourier-wavelet) function') tomo = tomopy.remove_stripe_fw(tomo, sigma=ringSigma, level=ringLevel, pad=True, wname=ringWavelet) if doFWringremovalofJustCentralPortion: logging.info('Doing ring (Fourier-wavelet) function on just central portion') tomo[:,:,int(np.round(cor_rec-radiusPixels_CentralFW)):int(np.round(cor_rec+radiusPixels_CentralFW))] = tomopy.remove_stripe_fw(tomo[:,:,int(np.round(cor_rec-radiusPixels_CentralFW)):int(np.round(cor_rec+radiusPixels_CentralFW))], sigma=ringSigma, level=ringLevel, pad=True, wname=ringWavelet) if doPhaseRetrieval: logging.info('Doing Phase retrieval') # phase_pad_each_side = 10 # tomo = tomopy.pad(tomo,axis=1,mode='edge',npad=phase_pad_each_side) #logging.info('Shape of projections matrix after phase pad: %d, %d, %d', tomo.shape[0],tomo.shape[1],tomo.shape[2]) tomo = tomopy.retrieve_phase(tomo, pixel_size=pxsize, dist=propagation_dist, energy=kev, alpha=alphaReg, pad=True) # tomo = tomo[:,phase_pad_each_side:-phase_pad_each_side,:] #logging.info('Shape of projections matrix after phase crop: %d, %d, %d', tomo.shape[0],tomo.shape[1],tomo.shape[2]) # sinofilenametowrite = odirectory+'/rec'+iname[x]+'/'+iname[x]+'sinoAfterPhase_' # dxchange.write_tiff_stack(tomo, fname=sinofilenametowrite, start=sinorange[0]+y*num_sino_per_chunk,axis=1) if recon_centralSlice != True and overlap_chunk>0: if y < chunks-1: tomo = tomo[:,:-overlap_chunk,:] if y > 0: tomo = tomo[:,overlap_chunk:,:] logging.info('Doing recon (gridrec) function...')
def recon_hdf5(src_fanme, dest_folder, sino_range, sino_step, shift_grid, center_vec=None, center_eq=None, dtype='float32', algorithm='gridrec', tolerance=1, chunk_size=20, save_sino=False, sino_blur=None, flattened_radius=120, mode='180', test_mode=False, phase_retrieval=None, ring_removal=True, **kwargs): """ center_eq: a and b parameters in fitted center position equation center = a*slice + b. """ if not os.path.exists(dest_folder): try: os.mkdir(dest_folder) except: pass sino_ini = int(sino_range[0]) sino_end = int(sino_range[1]) sino_ls_all = np.arange(sino_ini, sino_end, sino_step, dtype='int') alloc_set = allocate_mpi_subsets(sino_ls_all.size, size, task_list=sino_ls_all) sino_ls = alloc_set[rank] # prepare metadata f = h5py.File(src_fanme) dset = f['exchange/data'] full_shape = dset.shape theta = tomopy.angles(full_shape[0]) if center_eq is not None: a, b = center_eq center_ls = sino_ls * a + b center_ls = np.round(center_ls) for iblock in range(int(sino_ls.size/chunk_size)+1): print('Beginning block {:d}.'.format(iblock)) t0 = time.time() istart = iblock*chunk_size iend = np.min([(iblock+1)*chunk_size, sino_ls.size]) fstart = sino_ls[istart] fend = sino_ls[iend] center = center_ls[istart:iend] data = dset[:, fstart:fend:sino_step, :] data[np.isnan(data)] = 0 data = data.astype('float32') data = tomopy.remove_stripe_ti(data, alpha=4) if sino_blur is not None: for i in range(data.shape[1]): data[:, i, :] = gaussian_filter(data[:, i, :], sino_blur) rec = tomopy.recon(data, theta, center=center, algorithm=algorithm, **kwargs) rec = tomopy.remove_ring(rec) rec = tomopy.remove_outlier(rec, tolerance) rec = tomopy.circ_mask(rec, axis=0, ratio=0.95) for i in range(rec.shape[0]): slice = fstart + i*sino_step dxchange.write_tiff(rec[i, :, :], fname=os.path.join(dest_folder, 'recon/recon_{:05d}_{:05d}.tiff').format(slice, sino_ini)) if save_sino: dxchange.write_tiff(data[:, i, :], fname=os.path.join(dest_folder, 'sino/recon_{:05d}_{:d}.tiff').format(slice, int(center[i]))) iblock += 1 print('Block {:d} finished in {:.2f} s.'.format(iblock, time.time()-t0)) else: # divide chunks grid_bins = np.append(np.ceil(shift_grid[:, 0, 0]), full_shape[1]) chunks = [] center_ls = [] istart = 0 counter = 0 # irow should be 0 for slice 0 irow = np.searchsorted(grid_bins, sino_ls[0], side='right')-1 for i in range(sino_ls.size): counter += 1 sino_next = i+1 if i != sino_ls.size-1 else i if counter >= chunk_size or sino_ls[sino_next] >= grid_bins[irow+1] or sino_next == i: iend = i+1 chunks.append((istart, iend)) istart = iend center_ls.append(center_vec[irow]) if sino_ls[sino_next] >= grid_bins[irow+1]: irow += 1 counter = 0 # reconstruct chunks iblock = 1 for (istart, iend), center in izip(chunks, center_ls): print('Beginning block {:d}.'.format(iblock)) t0 = time.time() fstart = sino_ls[istart] fend = sino_ls[iend-1] print('Reading data...') data = dset[:, fstart:fend+1:sino_step, :] if mode == '360': overlap = 2 * (dset.shape[2] - center) data = tomosaic.morph.sino_360_to_180(data, overlap=overlap, rotation='right') theta = tomopy.angles(data.shape[0]) data[np.isnan(data)] = 0 data = data.astype('float32') if sino_blur is not None: for i in range(data.shape[1]): data[:, i, :] = gaussian_filter(data[:, i, :], sino_blur) if ring_removal: data = tomopy.remove_stripe_ti(data, alpha=4) if phase_retrieval: data = tomopy.retrieve_phase(data, kwargs['pixel_size'], kwargs['dist'], kwargs['energy'], kwargs['alpha']) rec0 = tomopy.recon(data, theta, center=center, algorithm=algorithm, **kwargs) rec = tomopy.remove_ring(np.copy(rec0)) cent = int((rec.shape[1]-1) / 2) xx, yy = np.meshgrid(np.arange(rec.shape[2]), np.arange(rec.shape[1])) mask0 = ((xx-cent)**2+(yy-cent)**2 <= flattened_radius**2) mask = np.zeros(rec.shape, dtype='bool') for i in range(mask.shape[0]): mask[i, :, :] = mask0 rec[mask] = (rec[mask] + rec0[mask])/2 else: rec = tomopy.recon(data, theta, center=center, algorithm=algorithm, **kwargs) rec = tomopy.remove_outlier(rec, tolerance) rec = tomopy.circ_mask(rec, axis=0, ratio=0.95) for i in range(rec.shape[0]): slice = fstart + i*sino_step if test_mode: dxchange.write_tiff(rec[i, :, :], fname=os.path.join(dest_folder, 'recon/recon_{:05d}_{:d}.tiff').format(slice, center), dtype=dtype) else: dxchange.write_tiff(rec[i, :, :], fname=os.path.join(dest_folder, 'recon/recon_{:05d}.tiff').format(slice), dtype=dtype) if save_sino: dxchange.write_tiff(data[:, i, :], fname=os.path.join(dest_folder, 'sino/recon_{:05d}_{:d}.tiff').format(slice, center), dtype=dtype) print('Block {:d} finished in {:.2f} s.'.format(iblock, time.time()-t0)) iblock += 1 return
dim1 = between 1000 and 10000 dim2 = between 1000 and 10000 dim3 = between 1000 and 10000 prj = numpy.random( ... ) # ----------------------------- # Processing funcs -------------- # phase retrieval t = time.time() prj = tomopy.retrieve_phase(prj, alpha=1e-4) print time.time() - t # reconstruct t = time.time() rec = tomopy.recon(prj, ang, algorithm='gridrec', center=1010, emission=False) print time.time() - t # ----------------------------- # save as tiff stack
def recon_hdf5(src_fanme, dest_folder, sino_range, sino_step, shift_grid, center_vec=None, center_eq=None, dtype='float32', algorithm='gridrec', tolerance=1, chunk_size=20, save_sino=False, sino_blur=None, flattened_radius=120, mode='180', test_mode=False, phase_retrieval=None, ring_removal=True, crop=None, num_iter=None, pad_length=0, read_theta=True, **kwargs): """ center_eq: a and b parameters in fitted center position equation center = a*slice + b. """ if not os.path.exists(dest_folder): try: os.mkdir(dest_folder) except: pass sino_ini = int(sino_range[0]) sino_end = int(sino_range[1]) sino_ls_all = np.arange(sino_ini, sino_end, sino_step, dtype='int') alloc_set = allocate_mpi_subsets(sino_ls_all.size, size, task_list=sino_ls_all) sino_ls = alloc_set[rank] # prepare metadata f = h5py.File(src_fanme) dset = f['exchange/data'] full_shape = dset.shape if read_theta: _, _, _, theta = read_data_adaptive(src_fanme, proj=(0, 1)) else: theta = tomopy.angles(full_shape[0]) if center_eq is not None: a, b = center_eq center_ls = sino_ls_all * a + b center_ls = np.round(center_ls) for iblock in range(int(sino_ls.size / chunk_size) + 1): internal_print('Beginning block {:d}.'.format(iblock)) t0 = time.time() istart = iblock * chunk_size iend = np.min([(iblock + 1) * chunk_size, sino_ls.size]) sub_sino_ls = sino_ls[istart:iend - 1] center = np.take(center_ls, sub_sino_ls) data = np.zeros([dset.shape[0], len(sub_sino_ls), dset.shape[2]]) for ind, i in enumerate(sub_sino_ls): data[:, ind, :] = dset[:, i, :] data[np.isnan(data)] = 0 data = data.astype('float32') data = tomopy.remove_stripe_ti(data, alpha=4) if sino_blur is not None: for i in range(data.shape[1]): data[:, i, :] = gaussian_filter(data[:, i, :], sino_blur) if phase_retrieval: data = tomopy.retrieve_phase(data, kwargs['pixel_size'], kwargs['dist'], kwargs['energy'], kwargs['alpha']) if pad_length != 0: data = pad_sinogram(data, pad_length) data = tomopy.remove_stripe_ti(data, alpha=4) if ring_removal: rec0 = tomopy.recon(data, theta, center=center + pad_length, algorithm=algorithm, **kwargs) rec = tomopy.remove_ring(np.copy(rec0)) cent = int((rec.shape[1] - 1) / 2) xx, yy = np.meshgrid(np.arange(rec.shape[2]), np.arange(rec.shape[1])) mask0 = ((xx - cent)**2 + (yy - cent)**2 <= flattened_radius**2) mask = np.zeros(rec.shape, dtype='bool') for i in range(mask.shape[0]): mask[i, :, :] = mask0 rec[mask] = (rec[mask] + rec0[mask]) / 2 else: rec = tomopy.recon(data, theta, center=center + pad_length, algorithm=algorithm, **kwargs) if pad_length != 0: rec = rec[:, pad_length:pad_length + full_shape[2], pad_length:pad_length + full_shape[2]] rec = tomopy.remove_outlier(rec, tolerance) rec = tomopy.circ_mask(rec, axis=0, ratio=0.95) if crop is not None: crop = np.asarray(crop) rec = rec[:, crop[0, 0]:crop[1, 0], crop[0, 1]:crop[1, 1]] for i in range(rec.shape[0]): slice = sub_sino_ls[i] dxchange.write_tiff( rec[i, :, :], fname=os.path.join( dest_folder, 'recon/recon_{:05d}.tiff').format(slice)) if save_sino: dxchange.write_tiff( data[:, i, :], fname=os.path.join( dest_folder, 'sino/recon_{:05d}_{:d}.tiff').format( slice, int(center[i]))) iblock += 1 internal_print('Block {:d} finished in {:.2f} s.'.format( iblock, time.time() - t0)) else: # divide chunks grid_bins = np.append(np.ceil(shift_grid[:, 0, 0]), full_shape[1]) chunks = [] center_ls = [] istart = 0 counter = 0 # irow should be 0 for slice 0 irow = np.searchsorted(grid_bins, sino_ls[0], side='right') - 1 for i in range(sino_ls.size): counter += 1 sino_next = i + 1 if i != sino_ls.size - 1 else i if counter >= chunk_size or sino_ls[sino_next] >= grid_bins[ irow + 1] or sino_next == i: iend = i + 1 chunks.append((istart, iend)) istart = iend center_ls.append(center_vec[irow]) if sino_ls[sino_next] >= grid_bins[irow + 1]: irow += 1 counter = 0 # reconstruct chunks iblock = 1 for (istart, iend), center in zip(chunks, center_ls): internal_print('Beginning block {:d}.'.format(iblock)) t0 = time.time() internal_print('Reading data...') sub_sino_ls = sino_ls[istart:iend] data = np.zeros([dset.shape[0], len(sub_sino_ls), dset.shape[2]]) for ind, i in enumerate(sub_sino_ls): data[:, ind, :] = dset[:, i, :] if mode == '360': overlap = 2 * (dset.shape[2] - center) data = tomosaic.sino_360_to_180(data, overlap=overlap, rotation='right') theta = tomopy.angles(data.shape[0]) data[np.isnan(data)] = 0 data = data.astype('float32') if sino_blur is not None: for i in range(data.shape[1]): data[:, i, :] = gaussian_filter(data[:, i, :], sino_blur) if phase_retrieval: data = tomopy.retrieve_phase(data, kwargs['pixel_size'], kwargs['dist'], kwargs['energy'], kwargs['alpha']) if pad_length != 0: data = pad_sinogram(data, pad_length) data = tomopy.remove_stripe_ti(data, alpha=4) if ring_removal: rec0 = tomopy.recon(data, theta, center=center + pad_length, algorithm=algorithm, **kwargs) rec = tomopy.remove_ring(np.copy(rec0)) cent = int((rec.shape[1] - 1) / 2) xx, yy = np.meshgrid(np.arange(rec.shape[2]), np.arange(rec.shape[1])) mask0 = ((xx - cent)**2 + (yy - cent)**2 <= flattened_radius**2) mask = np.zeros(rec.shape, dtype='bool') for i in range(mask.shape[0]): mask[i, :, :] = mask0 rec[mask] = (rec[mask] + rec0[mask]) / 2 else: rec = tomopy.recon(data, theta, center=center + pad_length, algorithm=algorithm, **kwargs) if pad_length != 0: rec = rec[:, pad_length:pad_length + full_shape[2], pad_length:pad_length + full_shape[2]] rec = tomopy.remove_outlier(rec, tolerance) rec = tomopy.circ_mask(rec, axis=0, ratio=0.95) if crop is not None: crop = np.asarray(crop) rec = rec[:, crop[0, 0]:crop[1, 0], crop[0, 1]:crop[1, 1]] for i in range(rec.shape[0]): slice = sub_sino_ls[i] if test_mode: dxchange.write_tiff( rec[i, :, :], fname=os.path.join( dest_folder, 'recon/recon_{:05d}_{:d}.tiff').format( slice, center), dtype=dtype) else: dxchange.write_tiff( rec[i, :, :], fname=os.path.join( dest_folder, 'recon/recon_{:05d}.tiff').format(slice), dtype=dtype) if save_sino: dxchange.write_tiff( data[:, i, :], fname=os.path.join( dest_folder, 'sino/recon_{:05d}_{:d}.tiff').format( slice, center), dtype=dtype) internal_print('Block {:d} finished in {:.2f} s.'.format( iblock, time.time() - t0)) iblock += 1 return
def recon(io_paras, data_paras, rot_center=None, normalize=True, stripe_removal=10, phase_retrieval=False, opt_center=False, diag_center=False, output="tiff"): # Input and output datafile = io_paras.get('datafile') path2white = io_paras.get('path2white', datafile) path2dark = io_paras.get('path2dark', path2white) out_dir = io_paras.get('out_dir') diag_cent_dir = io_paras.get('diag_cent_dir', out_dir+"/center_diagnose/") recon_dir = io_paras.get('recon_dir', out_dir+"/recon/") out_prefix = io_paras.get('out_prefix', "recon_") # Parameters of dataset NumCycles = data_paras.get('NumCycles', 1) # Number of cycles used for recon ProjPerCycle = data_paras.get('ProjPerCycle') # Number of projections per cycle, N_theta cycle_offset = data_paras.get('cycle_offset', 0) # Offset in output cycle number proj_start = data_paras.get('proj_start', 0) # Starting projection of reconstruction proj_step = data_paras.get('proj_step') z_start = data_paras.get('z_start', 0) z_end = data_paras.get('z_end', z_start+1) z_step = data_paras.get('z_step') x_start = data_paras.get('x_start') x_end = data_paras.get('x_end', x_start+1) x_step = data_paras.get('x_step') white_start = data_paras.get('white_start') white_end = data_paras.get('white_end') dark_start = data_paras.get('dark_start') dark_end = data_paras.get('dark_end') rot_center_copy = rot_center for cycle in xrange(NumCycles): # Set start and end of each cycle projections_start = cycle * ProjPerCycle + proj_start projections_end = projections_start + ProjPerCycle slice1 = slice(projections_start, projections_end, proj_step) slice2 = slice(z_start, z_end, z_step) slice3 = slice(x_start, x_end, x_step) slices = (slice1, slice2, slice3) white_slices = (slice(white_start, white_end), slice2, slice3) dark_slices = (slice(dark_start, dark_end), slice2, slice3) print("Running cycle #%s (projs %s to %s)" % (cycle, projections_start, projections_end)) # Read HDF5 file. print("Reading datafile %s..." % datafile, end="") sys.stdout.flush() data, white, dark = reader.read_aps_2bm(datafile, slices, white_slices, dark_slices, path2white=path2white, path2dark=path2dark) theta = gen_theta(data.shape[0]) print("Done!") print("Data shape = %s;\nwhite shape = %s;\ndark shape = %s." % (data.shape, white.shape, dark.shape)) ## Normalize dataset using data_white and data_dark if normalize: print("Normalizing data ...") # white = white.mean(axis=0).reshape(-1, *data.shape[1:]) # dark = dark.mean(axis=0).reshape(-1, *data.shape[1:]) # data = (data - dark) / (white - dark) data = tomopy.normalize(data, white, dark, cutoff=None, ncore=_ncore, nchunk=None)[...] ## Remove stripes caused by dead pixels in the detector if stripe_removal: print("Removing stripes ...") data = tomopy.remove_stripe_fw(data, level=stripe_removal, wname='db5', sigma=2, pad=True, ncore=_ncore, nchunk=None) # data = tomopy.remove_stripe_ti(data, nblock=0, alpha=1.5, # ncore=None, nchunk=None) # # Show preprocessed projection # plt.figure("%s-prep" % projections_start) # plt.imshow(d.data[0,:,:], cmap=cm.Greys_r) # plt.savefig(out_dir+"/preprocess/%s-prep.jpg" # % projections_start) # # plt.show() # continue ## Phase retrieval if phase_retrieval: print("Retrieving phase ...") data = tomopy.retrieve_phase(data, pixel_size=1e-4, dist=50, energy=20, alpha=1e-3, pad=True, ncore=_ncore, nchunk=None) ## Determine and set the center of rotation if opt_center or (rot_center == None): ### Using optimization method to automatically find the center # d.optimize_center() print("Optimizing center ...", end="") sys.stdout.flush() rot_center = tomopy.find_center(data, theta, ind=None, emission=True, init=None, tol=0.5, mask=True, ratio=1.) print("Done!") print("center = %s" % rot_center) if diag_center: ### Output the reconstruction results using a range of centers, ### and then manually find the optimal center. # d.diagnose_center() if not os.path.exists(diag_cent_dir): os.makedirs(diag_cent_dir) print("Testing centers ...", end="") sys.stdout.flush() tomopy.write_center(data, theta, dpath=diag_cent_dir, cen_range=[center_start, center_end, center_step], ind=None, emission=False, mask=False, ratio=1.) print("Done!") ## Flip odd frames if (cycle % 2): data[...] = data[...,::-1] rot_center = data.shape[-1] - rot_center_copy else: rot_center = rot_center_copy ## Reconstruction using FBP print("Running gridrec ...", end="") sys.stdout.flush() recon = tomopy.recon(data, theta, center=rot_center, emission=False, algorithm='gridrec', # num_gridx=None, num_gridy=None, filter_name='shepp', ncore=_ncore, nchunk=_nchunk) print("Done!") ## Collect background # if cycle == 0: # bg = recon # elif cycle < 4: # bg += recon # else: # recon -= bg/4. # Write to stack of TIFFs. if not os.path.exists(recon_dir): os.makedirs(recon_dir) out_fname = recon_dir+"/"+out_prefix+"t_%d" % (cycle + cycle_offset) if "hdf" in output: hdf_fname = out_fname + ".hdf5" print("Writing reconstruction output file %s..." % hdf_fname, end="") sys.stdout.flush() tomopy.write_hdf5(recon, fname=hdf_fname, gname='exchange', overwrite=False) print("Done!") if "tif" in output: tiff_fname = out_fname + ".tiff" print("Writing reconstruction tiff files %s ..." % tiff_fname, end="") sys.stdout.flush() tomopy.write_tiff_stack(recon, fname=tiff_fname, axis=0, digit=5, start=0, overwrite=False) print("Done!") if "bin" in output: bin_fname = out_fname + ".bin" print("Writing reconstruction to binary files %s..." % bin_fname, end="") sys.stdout.flush() recon.tofile(bin_fname)
#dim2 = between 1000 and 10000 #dim3 = between 1000 and 10000 dim1 = 1000 prj = numpy.random.random([dim1,dim1,dim1]) # ----------------------------- # Processing funcs -------------- # phase retrieval t = time.time() prj = tomopy.retrieve_phase(prj) #print time.time() - t logging.info("Phase - dt: %s" % (time.time() - t)) # reconstruct t = time.time() rec = tomopy.recon(prj, ang, algorithm='gridrec', center=1010, alpha=1e-4, emission=False) #print time.time() - t logging.info("Reconstruction - dt: %s" % (time.time() - t)) # -----------------------------