def _process(lock, int_from, int_to, num_sinos, infile_1, infile_2, infile_3, outfile_abs, outfile_ref, outfile_sca, r1, r2, r3, d1, d2, d3, dd1, dd2, dd3, shiftVert_1, shiftHoriz_1, shiftVert_2, shiftHoriz_2, shiftVert_3, shiftHoriz_3, outshape, outtype, skipflat_1, skipflat_2, skipflat_3, plan_1, plan_2, plan_3, norm_sx, norm_dx, flat_end, half_half, half_half_line, ext_fov, ext_fov_rot_right, ext_fov_overlap, ext_fov_normalize, ext_fov_average, ringrem, dynamic_ff, EFF_1, EFF_2, EFF_3, filtEFF_1, filtEFF_2, filtEFF_3, im_dark_1, im_dark_2, im_dark_3, logfilename): # Process the required subset of images: for i in range(int_from, int_to + 1): # Read input image for top, left and right: t0 = time() f_in = getHDF5(infile_1, 'r') if "/tomo" in f_in: dset = f_in['tomo'] flat_avg1 = float(f_in['flat'].attrs['avg']) dark_avg1 = float(f_in['dark'].attrs['avg']) else: dset = f_in['exchange/data'] flat_avg1 = float(f_in['exchange/data_white'].attrs['avg']) dark_avg1 = float(f_in['exchange/data_dark'].attrs['avg']) # Processing in the sinogram domain so a vertical shift of the # projection requires loading a different sinogram: idx1 = min(max(0, i - shiftVert_1), num_sinos - 1) im_1 = tdf.read_sino(dset, idx1).astype(float32) f_in.close() f_in = getHDF5(infile_2, 'r') if "/tomo" in f_in: dset = f_in['tomo'] flat_avg2 = float(f_in['flat'].attrs['avg']) dark_avg2 = float(f_in['dark'].attrs['avg']) else: dset = f_in['exchange/data'] flat_avg2 = float(f_in['exchange/data_white'].attrs['avg']) dark_avg2 = float(f_in['exchange/data_dark'].attrs['avg']) # Processing in the sinogram domain so a vertical shift of the # projection requires loading a different sinogram: idx2 = min(max(0, i - shiftVert_2), num_sinos - 1) im_2 = tdf.read_sino(dset, idx2).astype(float32) f_in.close() f_in = getHDF5(infile_3, 'r') if "/tomo" in f_in: dset = f_in['tomo'] flat_avg3 = float(f_in['flat'].attrs['avg']) dark_avg3 = float(f_in['dark'].attrs['avg']) else: dset = f_in['exchange/data'] flat_avg3 = float(f_in['exchange/data_white'].attrs['avg']) dark_avg3 = float(f_in['exchange/data_dark'].attrs['avg']) # Processing in the sinogram domain so a vertical shift of the projection # requires loading a different sinogram: idx3 = min(max(0, i - shiftVert_3), num_sinos - 1) im_3 = tdf.read_sino(dset, idx3).astype(float32) f_in.close() t1 = time() # Perform pre-processing (flat fielding, extended FOV, ring removal): if not skipflat_1: if dynamic_ff: # Dynamic flat fielding with downsampling = 2: im_1 = dynamic_flat_fielding(im_1, idx1, EFF_1, filtEFF_1, 2, im_dark_1, norm_sx, norm_dx) else: im_1 = flat_fielding(im_1, idx1, plan_1, flat_end, half_half, half_half_line, norm_sx, norm_dx) if ext_fov: im_1 = extfov_correction(im_1, ext_fov_rot_right, ext_fov_overlap, ext_fov_normalize, ext_fov_average) if not skipflat_1 and not dynamic_ff: im_1 = ring_correction(im_1, ringrem, flat_end, plan_1['skip_flat_after'], half_half, half_half_line, ext_fov) else: im_1 = ring_correction(im_1, ringrem, False, False, half_half, half_half_line, ext_fov) # Perform pre-processing (flat fielding, extended FOV, ring removal): if not skipflat_2: if dynamic_ff: # Dynamic flat fielding with downsampling = 2: im_2 = dynamic_flat_fielding(im_2, idx2, EFF_2, filtEFF_2, 2, im_dark_2, norm_sx, norm_dx) else: im_2 = flat_fielding(im_2, idx2, plan_2, flat_end, half_half, half_half_line, norm_sx, norm_dx) if ext_fov: im_2 = extfov_correction(im_2, ext_fov_rot_right, ext_fov_overlap, ext_fov_normalize, ext_fov_average) if not skipflat_2 and not dynamic_ff: im_2 = ring_correction(im_2, ringrem, flat_end, plan_2['skip_flat_after'], half_half, half_half_line, ext_fov) else: im_2 = ring_correction(im_2, ringrem, False, False, half_half, half_half_line, ext_fov) # Perform pre-processing (flat fielding, extended FOV, ring removal): if not skipflat_3: if dynamic_ff: # Dynamic flat fielding with downsampling = 2: im_3 = dynamic_flat_fielding(im_3, idx3, EFF_3, filtEFF_3, 2, im_dark_3, norm_sx, norm_dx) else: im_3 = flat_fielding(im_3, idx3, plan_3, flat_end, half_half, half_half_line, norm_sx, norm_dx) if ext_fov: im_3 = extfov_correction(im_3, ext_fov_rot_right, ext_fov_overlap, ext_fov_normalize, ext_fov_average) if not skipflat_3 and not dynamic_ff: im_3 = ring_correction(im_3, ringrem, flat_end, plan_3['skip_flat_after'], half_half, half_half_line, ext_fov) else: im_3 = ring_correction(im_3, ringrem, False, False, half_half, half_half_line, ext_fov) t2 = time() # Processing in the sinogram domain so a vertical shift of the # projection requires loading a different sinogram: # Only horizontal shift can be considered at a sinogram level: if (shiftHoriz_1 != 0): im_1 = _shift_horiz(im_1, shiftHoriz_1) if (shiftHoriz_2 != 0): im_2 = _shift_horiz(im_2, shiftHoriz_2) if (shiftHoriz_3 != 0): im_3 = _shift_horiz(im_3, shiftHoriz_3) # Re-normalize with average of the flat-field images: max_val = amax( array([ mean(flat_avg1 - dark_avg1), mean(flat_avg2 - dark_avg2), mean(flat_avg3 - dark_avg3) ])) im_1 = im_1 * (flat_avg1 - dark_avg1) / max_val im_2 = im_2 * (flat_avg2 - dark_avg2) / max_val im_3 = im_3 * (flat_avg3 - dark_avg3) / max_val # Apply GDEI: (im_abs, im_ref, im_sca) = gdei(im_1, im_2, im_3, r1, r2, r3, d1, d2, d3, dd1, dd2, dd3) # Save processed image to HDF5 file (atomic procedure - lock used): lock.acquire() try: t3 = time() _write_data(im_abs, i, outfile_abs, outshape, outtype) _write_data(im_ref, i, outfile_ref, outshape, outtype) _write_data(im_sca, i, outfile_sca, outshape, outtype) t4 = time() # Print out execution time: log = open(logfilename, "a") log.write( linesep + "\tsino_%s processed (CPU: %0.3f sec - I/O: %0.3f sec)." % (str(i).zfill(4), t2 - t1, (t1 - t0) + (t4 - t3))) log.close() finally: lock.release()
## initialize communication with the lumina devices = pyxid.get_xid_devices() if devices: lumina_dev = devices[0] else: print "Could not find Lumina device" sys.exit(1) print lumina_dev if lumina_dev.is_response_device(): lumina_dev.reset_base_timer() lumina_dev.reset_rt_timer() else: print "Error: Lumina device is not a response device??" log.write("Error: Lumina device is not a response device??") sys.exit(1) # Ensure that relative paths start from the same directory as this script _thisDir = os.path.dirname(os.path.abspath(__file__)).decode( sys.getfilesystemencoding()) os.chdir(_thisDir) # Store info about the experiment session expName = u'nemo' # from the Builder filename that created this script expInfo = {'participant': '', 'session': '001'} dlg = gui.DlgFromDict(dictionary=expInfo, title=expName) if dlg.OK == False: core.quit() # user pressed cancel expInfo['date'] = data.getDateStr() # add a simple timestamp expInfo['expName'] = expName
def main(argv): """To do... Usage ----- Parameters --------- Example -------------------------- """ lock = Lock() # Get the from and to number of files to process: int_from = int(argv[0]) int_to = int(argv[1]) # Get paths: infile_1 = argv[2] infile_2 = argv[3] infile_3 = argv[4] outfile_abs = argv[5] outfile_ref = argv[6] outfile_sca = argv[7] # Normalization parameters: norm_sx = int(argv[8]) norm_dx = int(argv[9]) # Params for flat fielding with post flats/darks: flat_end = True if argv[10] == "True" else False half_half = True if argv[11] == "True" else False half_half_line = int(argv[12]) # Params for extended FOV: ext_fov = True if argv[13] == "True" else False ext_fov_rot_right = argv[14] if ext_fov_rot_right == "True": ext_fov_rot_right = True if (ext_fov): norm_sx = 0 else: ext_fov_rot_right = False if (ext_fov): norm_dx = 0 ext_fov_overlap = int(argv[15]) ext_fov_normalize = True if argv[16] == "True" else False ext_fov_average = True if argv[17] == "True" else False # Method and parameters coded into a string: ringrem = argv[18] # Flat fielding method (conventional or dynamic): dynamic_ff = True if argv[19] == "True" else False # Shift parameters: shiftVert_1 = int(argv[20]) shiftHoriz_1 = int(argv[21]) shiftVert_2 = int(argv[22]) shiftHoriz_2 = int(argv[23]) shiftVert_3 = int(argv[24]) shiftHoriz_3 = int(argv[25]) # DEI coefficients: r1 = float(argv[26]) r2 = float(argv[27]) r3 = float(argv[28]) d1 = float(argv[29]) d2 = float(argv[30]) d3 = float(argv[31]) dd1 = float(argv[32]) dd2 = float(argv[33]) dd3 = float(argv[34]) # Nr of threads and log file: nr_threads = int(argv[35]) logfilename = argv[36] # Log input parameters: log = open(logfilename, "w") log.write(linesep + "\tInput TDF file #1: %s" % (infile_1)) log.write(linesep + "\tInput TDF file #2: %s" % (infile_2)) log.write(linesep + "\tInput TDF file #3: %s" % (infile_3)) log.write(linesep + "\tOutput TDF file for Absorption: %s" % (outfile_abs)) log.write(linesep + "\tOutput TDF file for Refraction: %s" % (outfile_ref)) log.write(linesep + "\tOutput TDF file for Scattering: %s" % (outfile_sca)) log.write(linesep + "\t--------------") log.write(linesep + "\tOpening input dataset...") log.close() # Remove a previous copy of output: #if exists(outfile): # remove(outfile) # Open the HDF5 files: f_in_1 = getHDF5(infile_1, 'r') f_in_2 = getHDF5(infile_2, 'r') f_in_3 = getHDF5(infile_3, 'r') if "/tomo" in f_in_1: dset_1 = f_in_1['tomo'] tomoprefix_1 = 'tomo' flatprefix_1 = 'flat' darkprefix_1 = 'dark' else: dset_1 = f_in_1['exchange/data'] if "/provenance/detector_output" in f_in_1: prov_dset_1 = f_in_1['provenance/detector_output'] tomoprefix_1 = prov_dset_1.attrs['tomo_prefix'] flatprefix_1 = prov_dset_1.attrs['flat_prefix'] darkprefix_1 = prov_dset_1.attrs['dark_prefix'] if "/tomo" in f_in_2: dset_2 = f_in_2['tomo'] tomoprefix_2 = 'tomo' flatprefix_2 = 'flat' darkprefix_2 = 'dark' else: dset_2 = f_in_2['exchange/data'] if "/provenance/detector_output" in f_in_2: prov_dset_2 = f_in_2['provenance/detector_output'] tomoprefix_2 = prov_dset_2.attrs['tomo_prefix'] flatprefix_2 = prov_dset_2.attrs['flat_prefix'] darkprefix_2 = prov_dset_2.attrs['dark_prefix'] if "/tomo" in f_in_3: dset_3 = f_in_3['tomo'] tomoprefix_3 = 'tomo' flatprefix_3 = 'flat' darkprefix_3 = 'dark' else: dset_3 = f_in_3['exchange/data'] if "/provenance/detector_output" in f_in_3: prov_dset_3 = f_in_1['provenance/detector_output'] tomoprefix_3 = prov_dset_3.attrs['tomo_prefix'] flatprefix_3 = prov_dset_3.attrs['flat_prefix'] darkprefix_3 = prov_dset_3.attrs['dark_prefix'] # Assuming that what works for the dataset #1 works for the other two: num_proj = tdf.get_nr_projs(dset_1) num_sinos = tdf.get_nr_sinos(dset_1) if (num_sinos == 0): log = open(logfilename, "a") log.write(linesep + "\tNo projections found. Process will end.") log.close() exit() # Check extrema (int_to == -1 means all files): if ((int_to >= num_sinos) or (int_to == -1)): int_to = num_sinos - 1 # Prepare the work plan for flat and dark images: log = open(logfilename, "a") log.write(linesep + "\t--------------") log.write(linesep + "\tPreparing the work plan...") log.close() # Extract flat and darks: skipflat_1 = False skipdark_1 = False skipflat_2 = False skipdark_2 = False skipflat_3 = False skipdark_3 = False # Following variables make sense only for dynamic flat fielding: EFF_1 = -1 filtEFF_1 = -1 im_dark_1 = -1 EFF_2 = -1 filtEFF_2 = -1 im_dark_2 = -1 EFF_3 = -1 filtEFF_3 = -1 im_dark_3 = -1 # Following variable makes sense only for conventional flat fielding: plan_1 = -1 plan_2 = -1 plan_3 = -1 if not dynamic_ff: plan_1 = extract_flatdark(f_in_1, flat_end, logfilename) if (isscalar(plan_1['im_flat']) and isscalar(plan_1['im_flat_after'])): skipflat_1 = True else: skipflat_1 = False plan_2 = extract_flatdark(f_in_2, flat_end, logfilename) if (isscalar(plan_2['im_flat']) and isscalar(plan_2['im_flat_after'])): skipflat_2 = True else: skipflat_2 = False plan_3 = extract_flatdark(f_in_3, flat_end, logfilename) if (isscalar(plan_3['im_flat']) and isscalar(plan_3['im_flat_after'])): skipflat_3 = True else: skipflat_3 = False else: # Dynamic flat fielding: if "/tomo" in f_in_1: if "/flat" in f_in_1: flat_dset_1 = f_in_1['flat'] if "/dark" in f_in_1: im_dark_1 = _medianize(f_in_1['dark']) else: skipdark_1 = True else: skipflat_1 = True # Nothing to do in this case else: if "/exchange/data_white" in f_in_1: flat_dset_1 = f_in_1['/exchange/data_white'] if "/exchange/data_dark" in f_in_1: im_dark_1 = _medianize(f_in_1['/exchange/data_dark']) else: skipdark_1 = True else: skipflat_1 = True # Nothing to do in this case # Prepare plan for dynamic flat fielding with 16 repetitions: if not skipflat_1: EFF_1, filtEFF_1 = dff_prepare_plan(flat_dset_1, 16, im_dark_1) # Dynamic flat fielding: if "/tomo" in f_in_2: if "/flat" in f_in_2: flat_dset_2 = f_in_2['flat'] if "/dark" in f_in_2: im_dark_2 = _medianize(f_in_2['dark']) else: skipdark_2 = True else: skipflat_2 = True # Nothing to do in this case else: if "/exchange/data_white" in f_in_2: flat_dset_2 = f_in_2['/exchange/data_white'] if "/exchange/data_dark" in f_in_2: im_dark_2 = _medianize(f_in_2['/exchange/data_dark']) else: skipdark_2 = True else: skipflat_2 = True # Nothing to do in this case # Prepare plan for dynamic flat fielding with 16 repetitions: if not skipflat_2: EFF_2, filtEFF_2 = dff_prepare_plan(flat_dset_2, 16, im_dark_2) # Dynamic flat fielding: if "/tomo" in f_in_3: if "/flat" in f_in_3: flat_dset_3 = f_in_3['flat'] if "/dark" in f_in_3: im_dark_3 = _medianize(f_in_3['dark']) else: skipdark_3 = True else: skipflat_3 = True # Nothing to do in this case else: if "/exchange/data_white" in f_in_3: flat_dset_3 = f_in_3['/exchange/data_white'] if "/exchange/data_dark" in f_in_3: im_dark_3 = _medianize(f_in_3['/exchange/data_dark']) else: skipdark_3 = True else: skipflat_3 = True # Nothing to do in this case # Prepare plan for dynamic flat fielding with 16 repetitions: if not skipflat_3: EFF_3, filtEFF_3 = dff_prepare_plan(flat_dset_3, 16, im_dark_3) # Outfile shape can be determined only after first processing in ext FOV mode: if (ext_fov): # Read input sino: idx = num_sinos / 2 im = tdf.read_sino(dset_1, idx).astype(float32) im = extfov_correction(im, ext_fov_rot_right, ext_fov_overlap, ext_fov_normalize, ext_fov_average) # Get the corrected outshape: outshape = tdf.get_dset_shape(im.shape[1], num_sinos, im.shape[0]) else: # Get the corrected outshape (in this case it's easy): im = tdf.read_tomo(dset_1, 0).astype(float32) outshape = tdf.get_dset_shape(im.shape[1], im.shape[0], num_proj) f_in_1.close() f_in_2.close() f_in_3.close() # Create the output HDF5 files: f_out_abs = getHDF5(outfile_abs, 'w') f_out_dset_abs = f_out_abs.create_dataset('exchange/data', outshape, float32) f_out_dset_abs.attrs['min'] = str(finfo(float32).max) f_out_dset_abs.attrs['max'] = str(finfo(float32).min) f_out_dset_abs.attrs['version'] = '1.0' f_out_dset_abs.attrs['axes'] = "y:theta:x" f_out_abs.close() f_out_ref = getHDF5(outfile_ref, 'w') f_out_dset_ref = f_out_ref.create_dataset('exchange/data', outshape, float32) f_out_dset_ref.attrs['min'] = str(finfo(float32).max) f_out_dset_ref.attrs['max'] = str(finfo(float32).min) f_out_dset_ref.attrs['version'] = '1.0' f_out_dset_ref.attrs['axes'] = "y:theta:x" f_out_ref.close() f_out_sca = getHDF5(outfile_sca, 'w') f_out_dset_sca = f_out_sca.create_dataset('exchange/data', outshape, float32) f_out_dset_sca.attrs['min'] = str(finfo(float32).max) f_out_dset_sca.attrs['max'] = str(finfo(float32).min) f_out_dset_sca.attrs['version'] = '1.0' f_out_dset_sca.attrs['axes'] = "y:theta:x" f_out_sca.close() # Log infos: log = open(logfilename, "a") log.write(linesep + "\tWork plan prepared correctly.") log.write(linesep + "\t--------------") log.write(linesep + "\tPerforming GDEI...") log.close() # Run several threads for independent computation without waiting for threads # completion: for num in range(nr_threads): start = (num_sinos / nr_threads) * num if (num == nr_threads - 1): end = num_sinos - 1 else: end = (num_sinos / nr_threads) * (num + 1) - 1 Process( target=_process, args=(lock, start, end, num_sinos, infile_1, infile_2, infile_3, outfile_abs, outfile_ref, outfile_sca, r1, r2, r3, d1, d2, d3, dd1, dd2, dd3, shiftVert_1, shiftHoriz_1, shiftVert_2, shiftHoriz_2, shiftVert_3, shiftHoriz_3, outshape, float32, skipflat_1, skipflat_2, skipflat_3, plan_1, plan_2, plan_3, norm_sx, norm_dx, flat_end, half_half, half_half_line, ext_fov, ext_fov_rot_right, ext_fov_overlap, ext_fov_normalize, ext_fov_average, ringrem, dynamic_ff, EFF_1, EFF_2, EFF_3, filtEFF_1, filtEFF_2, filtEFF_3, im_dark_1, im_dark_2, im_dark_3, logfilename)).start()