def image_to_ndarray(filename, convert_grey=True, cmap=None, debug=False):
"""
Convert an image to a numpy array using pillow (matplotlib only supports the PNG format).
:param filename: absolute path of the image to open
:param convert_grey: if True and the number of layers is 3, it will be converted to a single layer of grey
:param cmap: colormap for the plots
:param debug: True to see plots
:return:
"""
from PIL import Image
if cmap is None:
cmap = gu.Colormap(bad_color='1.0').cmap
im = Image.open(filename)
array = np.asarray(im)
if array.ndim == 3 and convert_grey:
print('converting image to gray')
array = rgb2gray(array)
print(f'Image shape after conversion to ndarray: {array.shape}')
if debug:
gu.imshow_plot(array,
sum_axis=2,
plot_colorbar=True,
cmap=cmap,
reciprocal_space=False)
return array
allow_none=True,
name=valid_name)
if ndim == 3:
comment = f'_direction{direction[0]}_{direction[1]}_{direction[2]}_{comment}'
else:
comment = f'_direction{direction[0]}_{direction[1]}_{comment}'
#########################
# normalize the modulus #
#########################
obj = abs(obj) / abs(obj).max() # normalize the modulus to 1
obj[np.isnan(obj)] = 0 # remove nans
if ndim == 2:
gu.imshow_plot(array=obj,
plot_colorbar=True,
reciprocal_space=False,
is_orthogonal=True)
else:
gu.multislices_plot(array=obj,
sum_frames=False,
plot_colorbar=True,
reciprocal_space=False,
is_orthogonal=True,
slice_position=(25, 37, 25))
#####################################
# create the linecut for each point #
#####################################
result = dict()
for point in points:
# get the distances and the modulus values along the linecut
max_included=1,
name="angular_profile",
)
comment = f"_origin_{origin}_{comment}"
#########################
# normalize the modulus #
#########################
obj = abs(obj) / abs(obj).max() # normalize the modulus to 1
obj[np.isnan(obj)] = 0 # remove nans
fig, axs, _ = gu.imshow_plot(
array=obj,
sum_frames=True,
sum_axis=1,
plot_colorbar=True,
reciprocal_space=False,
vmin=0,
vmax=np.nan,
is_orthogonal=True,
)
gu.savefig(
savedir=savedir,
figure=fig,
axes=axs,
tick_width=tick_width,
tick_length=tick_length,
tick_labelsize=14,
xlabels=axs.get_xlabel(),
ylabels=axs.get_ylabel(),
titles=axs.get_title(),
plt.ion() # interactive graphics
mask = np.zeros((nb_pixel_y, nb_pixel_x))
ccdfiletmp = os.path.join(datadir,'scan_' + str('{:04d}'.format(scan)) + '_' + detector + '0000.hdf5'
h5file = h5py.File(ccdfiletmp, 'r')
data = h5file['entry']['measurement']['Merlin']['data']
nbz, nby, nbx = data.shape
if not roi:
data = np.array(data) # the whole array is loaded here
else
data = np.array(data[roi[0]:roi[1],roi[2]:roi[3],roi[4]:roi[5]])
mask[np.log10(data) > high_threshold] = 1
data[mask == 1] = 0
print('')
if is_scan:
plot_title = 'masked data'
filename = 'S' + str(scan) + '_scan.npz'
#sumdata, mask = pru.mask_merlin(data=sumdata, mask=mask) NOT IMPLEMENTED
if save_mask:
fig, _, _ = gu.imshow_plot(mask, plot_colorbar=False, title='mask')
np.savez_compressed(savedir+'hotpixels.npz', mask=mask)
fig.savefig(savedir + 'mask.png')
np.savez_compressed(savedir + filename, data=data)
def beamstop_correction(data, setup, debugging=False):
"""
Correct absorption from the beamstops during P10 forward CDI experiment.
:param data: the 3D stack of 2D CDI images, shape = (nbz, nby, nbx) or 2D image of
shape (nby, nbx)
:param setup: an instance of the class Setup
:param debugging: set to True to see plots
:return: the corrected data
"""
valid.valid_ndarray(arrays=data, ndim=(2, 3))
energy = setup.energy
if not isinstance(energy, Real):
raise TypeError(
f"Energy should be a number in eV, not a {type(energy)}")
print(f"Applying beamstop correction for the X-ray energy of {energy}eV")
if energy not in [8200, 8700, 10000, 10235]:
print("no beam stop information for the X-ray energy of {:d}eV,"
" defaulting to the correction for 8700 eV".format(int(energy)))
energy = 8700
ndim = data.ndim
if ndim == 3:
pass
elif ndim == 2:
data = data[np.newaxis, :, :]
else:
raise ValueError("2D or 3D data expected")
nbz, nby, nbx = data.shape
directbeam_y = setup.direct_beam[0] - setup.detector.roi[0] # vertical
directbeam_x = setup.direct_beam[1] - setup.detector.roi[2] # horizontal
# at 8200eV, the transmission of 100um Si is 0.26273
# at 8700eV, the transmission of 100um Si is 0.32478
# at 10000eV, the transmission of 100um Si is 0.47337
# at 10235eV, the transmission of 100um Si is 0.51431
if energy == 8200:
factor_large = 1 / 0.26273 # 5mm*5mm (100um thick) Si wafer
factor_small = 1 / 0.26273 # 3mm*3mm (100um thick) Si wafer
pixels_large = [-33, 35, -31, 36]
# boundaries of the large wafer relative to the direct beam (V x H)
pixels_small = [-14, 14, -11, 16]
# boundaries of the small wafer relative to the direct beam (V x H)
elif energy == 8700:
factor_large = 1 / 0.32478 # 5mm*5mm (100um thick) Si wafer
factor_small = 1 / 0.32478 # 3mm*3mm (100um thick) Si wafer
pixels_large = [-33, 35, -31, 36]
# boundaries of the large wafer relative to the direct beam (V x H)
pixels_small = [-14, 14, -11, 16]
# boundaries of the small wafer relative to the direct beam (V x H)
elif energy == 10000:
factor_large = 2.1 / 0.47337 # 5mm*5mm (200um thick) Si wafer
factor_small = 4.5 / 0.47337 # 3mm*3mm (300um thick) Si wafer
pixels_large = [-36, 34, -34, 35]
# boundaries of the large wafer relative to the direct beam (V x H)
pixels_small = [-21, 21, -21, 21]
# boundaries of the small wafer relative to the direct beam (V x H)
else: # energy = 10235
factor_large = 2.1 / 0.51431 # 5mm*5mm (200um thick) Si wafer
factor_small = 4.5 / 0.51431 # 3mm*3mm (300um thick) Si wafer
pixels_large = [-34, 35, -33, 36]
# boundaries of the large wafer relative to the direct beam (V x H)
pixels_small = [-20, 22, -20, 22]
# boundaries of the small wafer relative to the direct beam (V x H)
# define boolean arrays for the large and the small square beam stops
large_square = np.zeros((nby, nbx))
large_square[directbeam_y + pixels_large[0]:directbeam_y + pixels_large[1],
directbeam_x + pixels_large[2]:directbeam_x +
pixels_large[3], ] = 1
small_square = np.zeros((nby, nbx))
small_square[directbeam_y + pixels_small[0]:directbeam_y + pixels_small[1],
directbeam_x + pixels_small[2]:directbeam_x +
pixels_small[3], ] = 1
# define the boolean array for the border of the large square wafer
# (the border is 1 pixel wide)
temp_array = np.zeros((nby, nbx))
temp_array[directbeam_y + pixels_large[0] + 1:directbeam_y +
pixels_large[1] - 1, directbeam_x + pixels_large[2] +
1:directbeam_x + pixels_large[3] - 1, ] = 1
large_border = large_square - temp_array
# define the boolean array for the border of the small square wafer
# (the border is 1 pixel wide)
temp_array = np.zeros((nby, nbx))
temp_array[directbeam_y + pixels_small[0] + 1:directbeam_y +
pixels_small[1] - 1, directbeam_x + pixels_small[2] +
1:directbeam_x + pixels_small[3] - 1, ] = 1
small_border = small_square - temp_array
if debugging:
gu.imshow_plot(
data,
sum_frames=True,
sum_axis=0,
vmin=0,
vmax=11,
plot_colorbar=True,
scale="log",
title="data before absorption correction",
is_orthogonal=False,
reciprocal_space=True,
)
gu.combined_plots(
tuple_array=(large_square, small_square, large_border,
small_border),
tuple_sum_frames=(False, False, False, False),
tuple_sum_axis=0,
tuple_width_v=None,
tuple_width_h=None,
tuple_colorbar=False,
tuple_vmin=0,
tuple_vmax=11,
is_orthogonal=False,
reciprocal_space=True,
tuple_title=(
"large_square",
"small_square",
"larger border",
"small border",
),
tuple_scale=("linear", "linear", "linear", "linear"),
)
# absorption correction for the large and small square beam stops
for idx in range(nbz):
tempdata = data[idx, :, :]
tempdata[np.nonzero(large_square)] = (
tempdata[np.nonzero(large_square)] * factor_large)
tempdata[np.nonzero(small_square)] = (
tempdata[np.nonzero(small_square)] * factor_small)
data[idx, :, :] = tempdata
if debugging:
width = 40
_, (ax0, ax1) = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))
ax0.plot(
np.log10(data[:, directbeam_y, directbeam_x - width:directbeam_x +
width].sum(axis=0)))
ax0.set_title("horizontal cut after absorption correction")
ax0.vlines(
x=[
width + pixels_large[2],
width + pixels_large[3],
width + pixels_small[2],
width + pixels_small[3],
],
ymin=ax0.get_ylim()[0],
ymax=ax0.get_ylim()[1],
colors="b",
linestyle="dashed",
)
ax1.plot(
np.log10(data[:, directbeam_y - width:directbeam_y + width,
directbeam_x].sum(axis=0)))
ax1.set_title("vertical cut after absorption correction")
ax1.vlines(
x=[
width + pixels_large[0],
width + pixels_large[1],
width + pixels_small[0],
width + pixels_small[1],
],
ymin=ax1.get_ylim()[0],
ymax=ax1.get_ylim()[1],
colors="b",
linestyle="dashed",
)
gu.imshow_plot(
data,
sum_frames=True,
sum_axis=0,
vmin=0,
vmax=11,
plot_colorbar=True,
scale="log",
title="data after absorption correction",
is_orthogonal=False,
reciprocal_space=True,
)
# interpolation for the border of the large square wafer
indices = np.argwhere(large_border == 1)
data[np.nonzero(np.repeat(large_border[np.newaxis, :, :], nbz,
axis=0))] = 0 # exclude border points
for frame in range(nbz): # loop over 2D images in the detector plane
tempdata = data[frame, :, :]
for idx in range(indices.shape[0]):
pixrow = indices[idx, 0]
pixcol = indices[idx, 1]
counter = (9 - large_border[pixrow - 1:pixrow + 2,
pixcol - 1:pixcol + 2].sum()
) # number of pixels in a 3x3 window
# which do not belong to the border
tempdata[pixrow, pixcol] = (
tempdata[pixrow - 1:pixrow + 2, pixcol - 1:pixcol + 2].sum() /
counter)
data[frame, :, :] = tempdata
# interpolation for the border of the small square wafer
indices = np.argwhere(small_border == 1)
data[np.nonzero(np.repeat(small_border[np.newaxis, :, :], nbz,
axis=0))] = 0 # exclude border points
for frame in range(nbz): # loop over 2D images in the detector plane
tempdata = data[frame, :, :]
for idx in range(indices.shape[0]):
pixrow = indices[idx, 0]
pixcol = indices[idx, 1]
counter = (9 - small_border[pixrow - 1:pixrow + 2,
pixcol - 1:pixcol + 2].sum()
) # number of pixels in a 3x3 window
# which do not belong to the border
tempdata[pixrow, pixcol] = (
tempdata[pixrow - 1:pixrow + 2, pixcol - 1:pixcol + 2].sum() /
counter)
data[frame, :, :] = tempdata
if debugging:
width = 40
_, (ax0, ax1) = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))
ax0.plot(
np.log10(data[:, directbeam_y, directbeam_x - width:directbeam_x +
width].sum(axis=0)))
ax0.set_title("horizontal cut after interpolating border")
ax0.vlines(
x=[
width + pixels_large[2],
width + pixels_large[3],
width + pixels_small[2],
width + pixels_small[3],
],
ymin=ax0.get_ylim()[0],
ymax=ax0.get_ylim()[1],
colors="b",
linestyle="dashed",
)
ax1.plot(
np.log10(data[:, directbeam_y - width:directbeam_y + width,
directbeam_x].sum(axis=0)))
ax1.set_title("vertical cut after interpolating border")
ax1.vlines(
x=[
width + pixels_large[0],
width + pixels_large[1],
width + pixels_small[0],
width + pixels_small[1],
],
ymin=ax1.get_ylim()[0],
ymax=ax1.get_ylim()[1],
colors="b",
linestyle="dashed",
)
gu.imshow_plot(
data,
sum_frames=True,
sum_axis=0,
vmin=0,
vmax=11,
plot_colorbar=True,
scale="log",
title="data after interpolating the border of beam stops",
is_orthogonal=False,
reciprocal_space=True,
)
return data
def main(parameters):
"""
Protection for multiprocessing.
:param parameters: dictionnary containing input parameters
"""
def collect_result(result):
"""
Callback processing the result after asynchronous multiprocessing. Update the global arrays.
:param result: the output of load_p10_file, containing the 2d data, 2d mask, counter for each frame, and the
file index
"""
nonlocal sumdata, mask, counter, nb_files, current_point
# result is a tuple: data, mask, counter, file_index
current_point += 1
sumdata = sumdata + result[0]
mask[np.nonzero(result[1])] = 1
counter.append(result[2])
sys.stdout.write('\rFile {:d} / {:d}'.format(current_point, nb_files))
sys.stdout.flush()
######################################
# load the dictionnary of parameters #
######################################
scan = parameters['scan']
samplename = parameters['sample_name']
rootdir = parameters['rootdir']
image_nb = parameters['file_list']
counterroi = parameters['counter_roi']
savedir = parameters['savedir']
load_scan = parameters['is_scan']
compare_end = parameters['compare_ends']
savemask = parameters['save_mask']
multiproc = parameters['multiprocessing']
threshold = parameters['threshold']
cb_min = parameters['cb_min']
cb_max = parameters['cb_max']
grey_bckg = parameters['grey_bckg']
###################
# define colormap #
###################
if grey_bckg:
bad_color = '0.7'
else:
bad_color = '1.0' # white background
colormap = gu.Colormap(bad_color=bad_color)
my_cmap = colormap.cmap
#######################
# Initialize detector #
#######################
detector = exp.Detector(name=parameters['detector'])
nb_pixel_y, nb_pixel_x = detector.nb_pixel_y, detector.nb_pixel_x
sumdata = np.zeros((nb_pixel_y, nb_pixel_x))
mask = np.zeros((nb_pixel_y, nb_pixel_x))
counter = []
####################
# Initialize paths #
####################
if type(image_nb) == int:
image_nb = [image_nb]
if len(counterroi) == 0:
counterroi = [0, nb_pixel_y, 0, nb_pixel_x]
assert (counterroi[0] >= 0
and counterroi[1] <= nb_pixel_y
and counterroi[2] >= 0
and counterroi[3] <= nb_pixel_x), 'counter_roi setting does not match the detector size'
nb_files = len(image_nb)
if nb_files == 1:
multiproc = False
if load_scan: # scan or time series
detector.datadir = rootdir + samplename + '_' + str('{:05d}'.format(scan)) + '/e4m/'
template_file = detector.datadir + samplename + '_' + str('{:05d}'.format(scan)) + "_data_"
else: # single image
detector.datadir = rootdir + samplename + '/e4m/'
template_file = detector.datadir + samplename + '_take_' + str('{:05d}'.format(scan)) + "_data_"
compare_end = False
detector.savedir = savedir or os.path.abspath(os.path.join(detector.datadir, os.pardir)) + '/'
print(f'datadir: {detector.datadir}')
print(f'savedir: {detector.savedir}')
#############
# Load data #
#############
plt.ion()
filenames = [template_file + '{:06d}.h5'.format(image_nb[idx]) for idx in range(nb_files)]
roi_counter = None
current_point = 0
start = time.time()
if multiproc:
print("\nNumber of processors used: ", min(mp.cpu_count(), len(filenames)))
mp.freeze_support()
pool = mp.Pool(processes=min(mp.cpu_count(), len(filenames))) # use this number of processes
for file in range(nb_files):
pool.apply_async(load_p10_file, args=(detector, filenames[file], file, counterroi, threshold),
callback=collect_result, error_callback=util.catch_error)
pool.close()
pool.join() # postpones the execution of next line of code until all processes in the queue are done.
# sort out counter values (we are using asynchronous multiprocessing, order is not preserved)
roi_counter = sorted(counter, key=lambda x: x[1])
else:
for idx in range(nb_files):
sys.stdout.write('\rLoading file {:d}'.format(idx + 1) + ' / {:d}'.format(nb_files))
sys.stdout.flush()
h5file = h5py.File(filenames[idx], 'r')
data = h5file['entry']['data']['data'][:]
data[data <= threshold] = 0
nbz, nby, nbx = data.shape
[counter.append(data[index, counterroi[0]:counterroi[1], counterroi[2]:counterroi[3]].sum())
for index in range(nbz)]
if compare_end and nb_files == 1:
data_start, _ = detector.mask_detector(data=data[0, :, :], mask=mask)
data_start = data_start.astype(float)
data_stop, _ = detector.mask_detector(data=data[-1, :, :], mask=mask)
data_stop = data_stop.astype(float)
fig, _, _ = gu.imshow_plot(data_stop - data_start, plot_colorbar=True, scale='log',
title='difference between the last frame and the first frame of the series')
nb_frames = data.shape[0] # collect the number of frames in the eventual series
data, mask = detector.mask_detector(data=data.sum(axis=0), mask=mask, nb_img=nb_frames)
sumdata = sumdata + data
roi_counter = [[counter, idx]]
end = time.time()
print('\nTime ellapsed for loading data:', str(datetime.timedelta(seconds=int(end - start))))
frame_per_series = int(len(counter) / nb_files)
print('')
if load_scan:
if nb_files > 1:
plot_title = 'masked data - sum of ' + str(nb_files)\
+ ' points with {:d} frames each'.format(frame_per_series)
else:
plot_title = 'masked data - sum of ' + str(frame_per_series) + ' frames'
filename = 'S' + str(scan) + '_scan.png'
else: # single image
plot_title = 'masked data'
filename = 'S' + str(scan) + '_image_' + str(image_nb[0]) + '.png'
if savemask:
fig, _, _ = gu.imshow_plot(mask, plot_colorbar=False, title='mask')
np.savez_compressed(detector.savedir+'hotpixels.npz', mask=mask)
fig.savefig(detector.savedir + 'mask.png')
y0, x0 = np.unravel_index(abs(sumdata).argmax(), sumdata.shape)
print("Max at (y, x): ", y0, x0, ' Max = ', int(sumdata[y0, x0]))
np.savez_compressed(detector.savedir + f'{sample_name}_{scan_nb:05d}_sumdata.npz', data=sumdata)
if save_to_mat:
savemat(detector.savedir + f'{sample_name}_{scan_nb:05d}_sumdata.mat', {'data': sumdata})
if len(roi_counter[0][0]) > 1: # roi_counter[0][0] is the list of counter intensities in a series
int_roi = []
[int_roi.append(val[0][idx]) for val in roi_counter for idx in range(frame_per_series)]
plt.figure()
plt.plot(np.asarray(int_roi))
plt.title('Integrated intensity in counter_roi')
plt.pause(0.1)
cb_min = cb_min or sumdata.min()
cb_max = cb_max or sumdata.max()
fig, _, _ = gu.imshow_plot(sumdata, plot_colorbar=True, title=plot_title, vmin=cb_min, vmax=cb_max, scale='log',
cmap=my_cmap)
np.savez_compressed(detector.savedir + 'hotpixels.npz', mask=mask)
fig.savefig(detector.savedir + filename)
plt.show()
labels = (
(
"detector X",
"detector Y",
"stacking axis",
), # labels for x axis, y axis, title
("detector X", "stacking axis", "detector Y"),
("detector Y", "stacking axis", "detector X"),
)
fig, ax, _ = gu.imshow_plot(
dataset[cen_z, :, :],
sum_frames=False,
width_v=2 * width[1],
width_h=2 * width[2],
scale=plot_scale,
vmin=vmin,
vmax=vmax,
reciprocal_space=False,
is_orthogonal=is_orthogonal,
plot_colorbar=True,
)
gu.savefig(
savedir=savedir,
figure=fig,
axes=ax,
tick_width=tick_width,
tick_length=tick_length,
tick_labelsize=16,
xlabels=labels[0][0],
ylabels=labels[0][1],
counter.append(data[index, counter_roi[0]:counter_roi[1],
counter_roi[2]:counter_roi[3]].sum())
for index in range(nbz)
]
if compare_ends and nb_files == 1:
data_start, _ = pru.mask_eiger4m(data=data[0, :, :], mask=mask)
data_start[np.log10(data_start) > high_threshold] = 0
data_start = data_start.astype(float)
data_stop, _ = pru.mask_eiger4m(data=data[-1, :, :], mask=mask)
data_stop[np.log10(data_stop) > high_threshold] = 0
data_stop = data_stop.astype(float)
fig, _, _ = gu.imshow_plot(
data_stop - data_start,
plot_colorbar=True,
scale='log',
title=
'difference between the last frame and the first frame of the series'
)
data = data.sum(axis=0) # data becomes 2D
mask[np.log10(data) > high_threshold] = 1
data[mask == 1] = 0
sumdata = sumdata + data
sys.stdout.write('\rLoading file {:d}'.format(idx + 1) +
' / {:d}'.format(nb_files))
sys.stdout.flush()
print('')
if is_scan:
if nb_files > 1:
def main(parameters):
"""
Protection for multiprocessing.
:param parameters: dictionnary containing input parameters
"""
def collect_result(result):
"""
Callback processing the result after asynchronous multiprocessing.
Update the global arrays.
:param result: the output of load_p10_file, containing the 2d data, 2d mask,
counter for each frame, and the file index
"""
nonlocal sumdata, mask, counter, nb_files, current_point
# result is a tuple: data, mask, counter, file_index
current_point += 1
sumdata = sumdata + result[0]
mask[np.nonzero(result[1])] = 1
counter.append(result[2])
sys.stdout.write("\rFile {:d} / {:d}".format(current_point, nb_files))
sys.stdout.flush()
######################################
# load the dictionnary of parameters #
######################################
scan = parameters["scan"]
samplename = parameters["sample_name"]
rootdir = parameters["rootdir"]
image_nb = parameters["file_list"]
counterroi = parameters["counter_roi"]
savedir = parameters["savedir"]
load_scan = parameters["is_scan"]
compare_end = parameters["compare_ends"]
savemask = parameters["save_mask"]
multiproc = parameters["multiprocessing"]
threshold = parameters["threshold"]
cb_min = parameters["cb_min"]
cb_max = parameters["cb_max"]
grey_bckg = parameters["grey_bckg"]
###################
# define colormap #
###################
if grey_bckg:
bad_color = "0.7"
else:
bad_color = "1.0" # white background
my_cmap = ColormapFactory(bad_color=bad_color).generate_cmap()
#######################
# Initialize detector #
#######################
detector = create_detector(name=parameters["detector"])
nb_pixel_y, nb_pixel_x = detector.nb_pixel_y, detector.nb_pixel_x
sumdata = np.zeros((nb_pixel_y, nb_pixel_x))
mask = np.zeros((nb_pixel_y, nb_pixel_x))
counter = []
####################
# Initialize paths #
####################
if isinstance(image_nb, int):
image_nb = [image_nb]
if len(counterroi) == 0:
counterroi = [0, nb_pixel_y, 0, nb_pixel_x]
if not (counterroi[0] >= 0 and counterroi[1] <= nb_pixel_y
and counterroi[2] >= 0 and counterroi[3] <= nb_pixel_x):
raise ValueError(
"counter_roi setting does not match the detector size")
nb_files = len(image_nb)
if nb_files == 1:
multiproc = False
if load_scan: # scan or time series
detector.datadir = (rootdir + samplename + "_" +
str("{:05d}".format(scan)) + "/e4m/")
template_file = (detector.datadir + samplename + "_" +
str("{:05d}".format(scan)) + "_data_")
else: # single image
detector.datadir = rootdir + samplename + "/e4m/"
template_file = (detector.datadir + samplename + "_take_" +
str("{:05d}".format(scan)) + "_data_")
compare_end = False
detector.savedir = (
savedir
or os.path.abspath(os.path.join(detector.datadir, os.pardir)) + "/")
print(f"datadir: {detector.datadir}")
print(f"savedir: {detector.savedir}")
#############
# Load data #
#############
plt.ion()
filenames = [
template_file + "{:06d}.h5".format(image_nb[idx])
for idx in range(nb_files)
]
roi_counter = None
current_point = 0
start = time.time()
if multiproc:
print("\nNumber of processors used: ",
min(mp.cpu_count(), len(filenames)))
mp.freeze_support()
pool = mp.Pool(processes=min(
mp.cpu_count(), len(filenames))) # use this number of processes
for file in range(nb_files):
pool.apply_async(
load_p10_file,
args=(detector, filenames[file], file, counterroi, threshold),
callback=collect_result,
error_callback=util.catch_error,
)
pool.close()
pool.join() # postpones the execution of next line of code
# until all processes in the queue are done.
# sort out counter values
# (we are using asynchronous multiprocessing, order is not preserved)
roi_counter = sorted(counter, key=lambda x: x[1])
else:
for idx in range(nb_files):
sys.stdout.write("\rLoading file {:d}".format(idx + 1) +
" / {:d}".format(nb_files))
sys.stdout.flush()
h5file = h5py.File(filenames[idx], "r")
data = h5file["entry"]["data"]["data"][:]
data[data <= threshold] = 0
nbz, _, _ = data.shape
for index in range(nbz):
counter.append(data[index, counterroi[0]:counterroi[1],
counterroi[2]:counterroi[3], ].sum())
if compare_end and nb_files == 1:
data_start, _ = detector.mask_detector(data=data[0, :, :],
mask=mask)
data_start = data_start.astype(float)
data_stop, _ = detector.mask_detector(data=data[-1, :, :],
mask=mask)
data_stop = data_stop.astype(float)
fig, _, _ = gu.imshow_plot(
data_stop - data_start,
plot_colorbar=True,
scale="log",
title="""difference between the last frame and
the first frame of the series""",
)
nb_frames = data.shape[
0] # collect the number of frames in the eventual series
data, mask = detector.mask_detector(data=data.sum(axis=0),
mask=mask,
nb_frames=nb_frames)
sumdata = sumdata + data
roi_counter = [[counter, idx]]
end = time.time()
print(
"\nTime ellapsed for loading data:",
str(datetime.timedelta(seconds=int(end - start))),
)
frame_per_series = int(len(counter) / nb_files)
print("")
if load_scan:
if nb_files > 1:
plot_title = (
"masked data - sum of " + str(nb_files) +
" points with {:d} frames each".format(frame_per_series))
else:
plot_title = "masked data - sum of " + str(
frame_per_series) + " frames"
filename = "S" + str(scan) + "_scan.png"
else: # single image
plot_title = "masked data"
filename = "S" + str(scan) + "_image_" + str(image_nb[0]) + ".png"
if savemask:
fig, _, _ = gu.imshow_plot(mask, plot_colorbar=False, title="mask")
np.savez_compressed(detector.savedir + "hotpixels.npz", mask=mask)
fig.savefig(detector.savedir + "mask.png")
y0, x0 = np.unravel_index(abs(sumdata).argmax(), sumdata.shape)
print("Max at (y, x): ", y0, x0, " Max = ", int(sumdata[y0, x0]))
np.savez_compressed(detector.savedir +
f"{sample_name}_{scan_nb:05d}_sumdata.npz",
data=sumdata)
if save_to_mat:
savemat(
detector.savedir + f"{sample_name}_{scan_nb:05d}_sumdata.mat",
{"data": sumdata},
)
if len(roi_counter[0][0]) > 1:
# roi_counter[0][0] is the list of counter intensities in a series
int_roi = [
val[0][idx] for val in roi_counter
for idx in range(frame_per_series)
]
plt.figure()
plt.plot(np.asarray(int_roi))
plt.title("Integrated intensity in counter_roi")
plt.pause(0.1)
cb_min = cb_min or sumdata.min()
cb_max = cb_max or sumdata.max()
fig, _, _ = gu.imshow_plot(
sumdata,
plot_colorbar=True,
title=plot_title,
vmin=cb_min,
vmax=cb_max,
scale="log",
cmap=my_cmap,
)
np.savez_compressed(detector.savedir + "hotpixels.npz", mask=mask)
fig.savefig(detector.savedir + filename)
plt.show()