def test_invert_and_piv():
""" Test windef.piv with invert option """
settings = windef.Settings()
'Data related settings'
# Folder with the images to process
settings.filepath_images = pathlib.Path(__file__).parent / '../examples/test1'
settings.save_path = '.'
# Root name of the output Folder for Result Files
settings.save_folder_suffix = 'test'
# Format and Image Sequence
settings.frame_pattern_a = 'exp1_001_a.bmp'
settings.frame_pattern_b = 'exp1_001_b.bmp'
settings.num_iterations = 1
settings.show_plot = False
settings.scale_plot = 100
settings.show_all_plots = False
settings.invert = True
windef.piv(settings)
# %%
image_path = pathlib.Path(r'./2B_RectificatedFrames_Particles_50mmh')
res_path = pathlib.Path(r'./Results/Open_PIV_results_64_Particles_50mmh/')
# %%
file_list = []
for path in sorted(image_path.rglob('*.tif')):
# print(f'{path.name}')
file_list.append(path.name)
# %%
file_list
# %%
settings = windef.Settings()
'Data related settings'
# Folder with the images to process
settings.filepath_images = image_path
# Folder for the outputs
settings.save_path = './Results/'
# Root name of the output Folder for Result Files
settings.save_folder_suffix = 'Particles_50mmh'
# Format and Image Sequence
settings.frame_pattern_a = '*.tif' # file_list[0]
# settings.frame_pattern_b = file_list[1]
def process(self, args):
"""
Process chain as configured in the GUI.
Parameters
----------
args : tuple
Tuple as expected by the inherited run method:
file_a (str) -- image file a
file_b (str) -- image file b
counter (int) -- index pointing to an element of the filename
list
"""
file_a, file_b, counter = args
frame_a = piv_tls.imread(file_a)
frame_b = piv_tls.imread(file_b)
# Smoothning script borrowed from openpiv.windef
s = self.p['smoothn_val']
def smoothn(u, s):
s = s
u, _, _, _ = piv_smt.smoothn(u, s=s, isrobust=self.p['robust'])
return (u)
# delimiters placed here for safety
delimiter = self.p['separator']
if delimiter == 'tab':
delimiter = '\t'
if delimiter == 'space':
delimiter = ' '
# preprocessing
print('\nPre-pocessing image pair: {}'.format(counter + 1))
if self.p['background_subtract'] \
and self.p['background_type'] == 'minA - minB':
self.background = gen_background(self.p, frame_a, frame_b)
frame_a = frame_a.astype(np.int32)
frame_a = process_images(self,
frame_a,
self.GUI.preprocessing_methods,
background=self.background)
frame_b = frame_b.astype(np.int32)
frame_b = process_images(self,
frame_b,
self.GUI.preprocessing_methods,
background=self.background)
print('Evaluating image pair: {}'.format(counter + 1))
# evaluation first pass
start = time.time()
passes = 1
# setup custom windowing if selected
if self.parameter['custom_windowing']:
corr_window_0 = self.parameter['corr_window_1']
overlap_0 = self.parameter['overlap_1']
for i in range(2, 8):
if self.parameter['pass_%1d' % i]:
passes += 1
else:
break
else:
passes = self.parameter['coarse_factor']
if self.parameter['grid_refinement'] == 'all passes' \
and self.parameter['coarse_factor'] != 1:
corr_window_0 = self.parameter['corr_window'] * \
2**(self.parameter['coarse_factor'] - 1)
overlap_0 = self.parameter['overlap'] * \
2**(self.parameter['coarse_factor'] - 1)
# Refine all passes after first when there are more than 1 pass.
elif self.parameter['grid_refinement'] == '2nd pass on' \
and self.parameter['coarse_factor'] != 1:
corr_window_0 = self.parameter['corr_window'] * \
2**(self.parameter['coarse_factor'] - 2)
overlap_0 = self.parameter['overlap'] * \
2**(self.parameter['coarse_factor'] - 2)
# If >>none<< is selected or something goes wrong, the window
# size would remain the same.
else:
corr_window_0 = self.parameter['corr_window']
overlap_0 = self.parameter['overlap']
overlap_percent = overlap_0 / corr_window_0
sizeX = corr_window_0
u, v, sig2noise = piv_wdf.extended_search_area_piv(
frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=corr_window_0,
overlap=overlap_0,
search_area_size=corr_window_0,
width=self.parameter['s2n_mask'],
subpixel_method=self.parameter['subpixel_method'],
sig2noise_method=self.parameter['sig2noise_method'],
correlation_method=self.parameter['corr_method'],
normalized_correlation=self.parameter['normalize_correlation'])
x, y = piv_prc.get_coordinates(frame_a.shape, corr_window_0, overlap_0)
# validating first pass
mask = np.full_like(x, 0)
if self.parameter['fp_vld_global_threshold']:
u, v, Mask = piv_vld.global_val(
u,
v,
u_thresholds=(self.parameter['fp_MinU'],
self.parameter['fp_MaxU']),
v_thresholds=(self.parameter['fp_MinV'],
self.parameter['fp_MaxV']))
# consolidate effects of mask
mask += Mask
if self.parameter['fp_local_med']:
u, v, Mask = piv_vld.local_median_val(
u,
v,
u_threshold=self.parameter['fp_local_med'],
v_threshold=self.parameter['fp_local_med'],
size=self.parameter['fp_local_med_size'])
mask += Mask
if self.parameter['adv_repl']:
u, v = piv_flt.replace_outliers(
u,
v,
method=self.parameter['adv_repl_method'],
max_iter=self.parameter['adv_repl_iter'],
kernel_size=self.parameter['adv_repl_kernel'])
print('Validated first pass result of image pair: {}.'.format(counter +
1))
# smoothning before deformation if 'each pass' is selected
if self.parameter['smoothn_each_pass']:
if self.parameter['smoothn_first_more']:
s *= 2
u = smoothn(u, s)
v = smoothn(v, s)
print('Smoothned pass 1 for image pair: {}.'.format(counter + 1))
s = self.parameter['smoothn_val1']
print('Finished pass 1 for image pair: {}.'.format(counter + 1))
print("window size: " + str(corr_window_0))
print('overlap: ' + str(overlap_0), '\n')
# evaluation of all other passes
if passes != 1:
iterations = passes - 1
for i in range(2, passes + 1):
# setting up the windowing of each pass
if self.parameter['custom_windowing']:
corr_window = self.parameter['corr_window_%1d' % i]
overlap = int(corr_window * overlap_percent)
else:
if self.parameter['grid_refinement'] == 'all passes' or \
self.parameter['grid_refinement'] == '2nd pass on':
corr_window = self.parameter['corr_window'] * \
2**(iterations - 1)
overlap = self.parameter['overlap'] * \
2**(iterations - 1)
else:
corr_window = self.parameter['corr_window']
overlap = self.parameter['overlap']
sizeX = corr_window
# translate settings to windef settings object
piv_wdf_settings = piv_wdf.Settings()
piv_wdf_settings.correlation_method = \
self.parameter['corr_method']
piv_wdf_settings.normalized_correlation = \
self.parameter['normalize_correlation']
piv_wdf_settings.windowsizes = (corr_window, ) * (passes + 1)
piv_wdf_settings.overlap = (overlap, ) * (passes + 1)
piv_wdf_settings.num_iterations = passes
piv_wdf_settings.subpixel_method = \
self.parameter['subpixel_method']
piv_wdf_settings.deformation_method = \
self.parameter['deformation_method']
piv_wdf_settings.interpolation_order = \
self.parameter['interpolation_order']
piv_wdf_settings.sig2noise_validate = True,
piv_wdf_settings.sig2noise_method = \
self.parameter['sig2noise_method']
piv_wdf_settings.sig2noise_mask = self.parameter['s2n_mask']
# do the correlation
x, y, u, v, sig2noise, mask = piv_wdf.multipass_img_deform(
frame_a.astype(np.int32),
frame_b.astype(np.int32),
i, # current iteration
x,
y,
u,
v,
piv_wdf_settings)
# validate other passes
if self.parameter['sp_vld_global_threshold']:
u, v, Mask = piv_vld.global_val(
u,
v,
u_thresholds=(self.parameter['sp_MinU'],
self.parameter['sp_MaxU']),
v_thresholds=(self.parameter['sp_MinV'],
self.parameter['sp_MaxV']))
mask += Mask # consolidate effects of mask
if self.parameter['sp_vld_global_threshold']:
u, v, Mask = piv_vld.global_std(
u, v, std_threshold=self.parameter['sp_std_threshold'])
mask += Mask
if self.parameter['sp_local_med_validation']:
u, v, Mask = piv_vld.local_median_val(
u,
v,
u_threshold=self.parameter['sp_local_med'],
v_threshold=self.parameter['sp_local_med'],
size=self.parameter['sp_local_med_size'])
mask += Mask
if self.parameter['adv_repl']:
u, v = piv_flt.replace_outliers(
u,
v,
method=self.parameter['adv_repl_method'],
max_iter=self.parameter['adv_repl_iter'],
kernel_size=self.parameter['adv_repl_kernel'])
print('Validated pass {} of image pair: {}.'.format(
i, counter + 1))
# smoothning each individual pass if 'each pass' is selected
if self.parameter['smoothn_each_pass']:
u = smoothn(u, s)
v = smoothn(v, s)
print('Smoothned pass {} for image pair: {}.'.format(
i, counter + 1))
print('Finished pass {} for image pair: {}.'.format(
i, counter + 1))
print("window size: " + str(corr_window))
print('overlap: ' + str(overlap), '\n')
iterations -= 1
if self.p['flip_u']:
u = np.flipud(u)
if self.p['flip_v']:
v = np.flipud(v)
if self.p['invert_u']:
u *= -1
if self.p['invert_v']:
v *= -1
# scaling
u = u / self.parameter['dt']
v = v / self.parameter['dt']
x, y, u, v = piv_scl.uniform(x,
y,
u,
v,
scaling_factor=self.parameter['scale'])
end = time.time()
# save data to file.
out = np.vstack([m.ravel() for m in [x, y, u, v, mask, sig2noise]])
np.savetxt(self.save_fnames[counter],
out.T,
fmt='%8.4f',
delimiter=delimiter)
print('Processed image pair: {}'.format(counter + 1))
sizeY = sizeX
sizeX = ((int(frame_a.shape[0] - sizeX) //
(sizeX - (sizeX * overlap_percent))) + 1)
sizeY = ((int(frame_a.shape[1] - sizeY) //
(sizeY - (sizeY * overlap_percent))) + 1)
time_per_vec = _round((((end - start) * 1000) / ((sizeX * sizeY) - 1)),
3)
print('Process time: {} second(s)'.format((_round((end - start), 3))))
print('Number of vectors: {}'.format(int((sizeX * sizeY) - 1)))
print('Time per vector: {} millisecond(s)'.format(time_per_vec))