def test_first_pass_circ():
""" test of the first pass """
x, y, u, v, s2n = windef.first_pass(
frame_a,
frame_b,
settings
)
print("\n", x, y, u, v, s2n)
assert np.mean(np.abs(u - shift_u)) < threshold
assert np.mean(np.abs(v - shift_v)) < threshold
def test_multi_pass_circ():
""" test fot the multipass """
settings.windowsizes = (64, 64, 16)
settings.overlap = (32, 32, 8)
settings.num_iterations = 2
settings.interpolation_order = 3
settings.validation_first_pass = True
settings.sig2noise_validate = False
# ettings.show_all_plots = True
x, y, u, v, s2n = windef.first_pass(
frame_a,
frame_b,
settings,
)
print("first pass\n")
print("\n", x, y, u, v, s2n)
assert np.allclose(u, shift_u, atol = threshold)
assert np.allclose(v, shift_v, atol = threshold)
if settings.image_mask:
image_mask = np.logical_and(mask_a, mask_b)
mask_coords = preprocess.mask_coordinates(image_mask)
# mark those points on the grid of PIV inside the mask
grid_mask = preprocess.prepare_mask_on_grid(x,y,mask_coords)
# mask the velocity
u = np.ma.masked_array(u, mask=grid_mask)
v = np.ma.masked_array(v, mask=grid_mask)
else:
mask_coords = []
u = np.ma.masked_array(u, mask=np.ma.nomask)
v = np.ma.masked_array(v, mask=np.ma.nomask)
for i in range(1,settings.num_iterations):
x, y, u, v, s2n, _ = windef.multipass_img_deform(
frame_a,
frame_b,
i,
x,
y,
u,
v,
settings
)
print(f"Pass {i}\n")
print(x)
print(y)
print(u)
print(v)
print(s2n)
assert np.mean(np.abs(u - shift_u)) < threshold
assert np.mean(np.abs(v - shift_v)) < threshold
def test_first_pass_lin():
""" test of the first pass """
settings.correlation_method = 'linear'
x, y, u, v, s2n = windef.first_pass(
frame_a,
frame_b,
settings,
)
print("\n", x, y, u, v, s2n)
assert np.mean(np.abs(u - shift_u)) < threshold
assert np.mean(np.abs(v - shift_v)) < threshold
def test_multi_pass_circ():
""" test fot the multipass """
window_size = (128, 64, 32)
overlap = (64, 32, 16)
iterations = 3
frame_a = np.zeros((1024, 1024))
frame_a = random_noise(frame_a)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
frame_a = img_as_ubyte(frame_a)
frame_b = np.roll(np.roll(frame_a, 3, axis=1), 2, axis=0)
x, y, u, v, sig2noise_ratio = windef.first_pass(
frame_a,
frame_b,
window_size[0],
overlap[0],
iterations,
correlation_method='circular',
subpixel_method='gaussian',
do_sig2noise=True,
sig2noise_method='peak2peak',
sig2noise_mask=2)
u_old = u
v_old = v
i = 1
for i in range(2, iterations + 1):
x, y, u, v, sig2noise_ratio, mask = windef.multipass_img_deform(
frame_a,
frame_b,
window_size[i - 1],
overlap[i - 1],
iterations,
i,
x,
y,
u,
v,
correlation_method='circular',
subpixel_method='gaussian',
do_sig2noise=False,
sig2noise_method='peak2peak',
sig2noise_mask=2,
MinMaxU=(-100, 50),
MinMaxV=(-50, 50),
std_threshold=1000000,
median_threshold=200000,
median_size=1,
filter_method='localmean',
max_filter_iteration=10,
filter_kernel_size=2,
interpolation_order=3)
assert (np.max(np.abs(u - 3)) < 0.1 and np.any(u != u_old))
assert (np.max(np.abs(v - 2)) < 0.1 and np.any(v != v_old))
def test_first_pass_lin():
""" test of the first pass """
x, y, u, v, s2n = windef.first_pass(frame_a,
frame_b,
window_size=64,
overlap=32,
iterations=1,
correlation_method='linear',
subpixel_method='gaussian',
do_sig2noise=True,
sig2noise_method='peak2peak',
sig2noise_mask=2)
# print u,v
assert (np.max(np.abs(u - 3)) < 0.1)
assert (np.max(np.abs(v + 2)) < 0.1)
def test_multi_pass_lin():
""" test fot the multipass """
window_size = (128, 64, 32)
overlap = (64, 32, 16)
iterations = 3
x, y, u, v, s2n = windef.first_pass(frame_a,
frame_b,
window_size[0],
overlap[0],
iterations,
correlation_method='linear',
subpixel_method='gaussian',
do_sig2noise=True,
sig2noise_method='peak2peak',
sig2noise_mask=2)
u_old = u.copy()
v_old = v.copy()
i = 1
for i in range(2, iterations + 1):
x, y,\
u, v,\
sn, m = windef.multipass_img_deform(frame_a, frame_b,
window_size[i-1],
overlap[i-1],
iterations, i, x, y,
u, v,
correlation_method='linear',
subpixel_method='gaussian',
do_sig2noise=False,
sig2noise_method='peak2peak',
sig2noise_mask=2,
MinMaxU=(-100, 50),
MinMaxV=(-50, 50),
std_threshold=1000000,
median_threshold=200000,
median_size=1,
filter_method='localmean',
max_filter_iteration=10,
filter_kernel_size=2,
interpolation_order=3)
assert (np.max(np.abs(u - 3)) < 0.1 and np.any(u != u_old))
assert (np.max(np.abs(v + 2)) < 0.1 and np.any(v != v_old))
def test_multi_pass_lin():
""" test fot the multipass """
settings.windowsizes = (64, 32, 16)
settings.overlap = (32, 16, 8)
settings.num_iterations = 1
settings.sig2noise_validate = True
settings.correlation_method = 'linear'
settings.normalized_correlation = True
settings.sig2noise_threshold = 1.0 # note the value for linear/normalized
x, y, u, v, s2n = windef.first_pass(
frame_a,
frame_b,
settings,
)
print("\n", x, y, u, v, s2n)
assert np.mean(np.abs(u - shift_u)) < threshold
assert np.mean(np.abs(v - shift_v)) < threshold
mask_coords = []
u = np.ma.masked_array(u, mask=np.ma.nomask)
v = np.ma.masked_array(v, mask=np.ma.nomask)
for i in range(1, settings.num_iterations):
x, y, u, v, s2n, _ = windef.multipass_img_deform(
frame_a,
frame_b,
i,
x,
y,
u,
v,
settings,
)
print(f"Iteration {i}")
print("\n", x, y, u, v, s2n)
assert np.allclose(u, shift_u, atol=threshold)
assert np.allclose(v, shift_v, atol=threshold)
def test_first_pass_circ():
""" test of the first pass """
frame_a = np.zeros((1024, 1024))
frame_a = random_noise(frame_a)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
frame_a = img_as_ubyte(frame_a)
frame_b = np.roll(np.roll(frame_a, 3, axis=1), 2, axis=0)
x, y, u, v, sig2noise_ratio = windef.first_pass(
frame_a,
frame_b,
window_size=64,
overlap=32,
iterations=1,
correlation_method='circular',
subpixel_method='gaussian',
do_sig2noise=True,
sig2noise_method='peak2peak',
sig2noise_mask=2)
# print u,v
#print('test')
assert (np.max(np.abs(u - 3)) < 0.1)
assert (np.max(np.abs(v - 2)) < 0.1)
def func(args):
"""A function to process each image pair."""
# this line is REQUIRED for multiprocessing to work
# always use it in your custom function
file_a, file_b, counter = args
' read images into numpy arrays'
frame_a = tools.imread(os.path.join(settings.filepath_images, file_a))
frame_b = tools.imread(os.path.join(settings.filepath_images, file_b))
' crop to ROI'
if settings.ROI=='full':
frame_a=frame_a
frame_b=frame_b
else:
frame_a = frame_a[settings.ROI[0]:settings.ROI[1],settings.ROI[2]:settings.ROI[3]]
frame_b = frame_b[settings.ROI[0]:settings.ROI[1],settings.ROI[2]:settings.ROI[3]]
if settings.dynamic_masking_method=='edge' or 'intensity':
frame_a = preprocess.dynamic_masking(frame_a,method=settings.dynamic_masking_method,filter_size=settings.dynamic_masking_filter_size,threshold=settings.dynamic_masking_threshold)
frame_b = preprocess.dynamic_masking(frame_b,method=settings.dynamic_masking_method,filter_size=settings.dynamic_masking_filter_size,threshold=settings.dynamic_masking_threshold)
'''%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%'''
'first pass'
x, y, u, v, sig2noise_ratio = windef.first_pass(frame_a,frame_b,settings.windowsizes[0], settings.overlap[0],settings.iterations,
correlation_method=settings.correlation_method, subpixel_method=settings.subpixel_method, do_sig2noise=settings.extract_sig2noise,
sig2noise_method=settings.sig2noise_method, sig2noise_mask=settings.sig2noise_mask,)
'validation using gloabl limits and std and local median'
'''MinMaxU : two elements tuple
sets the limits of the u displacment component
Used for validation.
MinMaxV : two elements tuple
sets the limits of the v displacment component
Used for validation.
std_threshold : float
sets the threshold for the std validation
median_threshold : float
sets the threshold for the median validation
filter_method : string
the method used to replace the non-valid vectors
Methods:
'localmean',
'disk',
'distance',
max_filter_iteration : int
maximum of filter iterations to replace nans
filter_kernel_size : int
size of the kernel used for the filtering'''
mask=np.full_like(x,False)
if settings.validation_first_pass==True:
u, v, mask_g = validation.global_val( u, v, settings.MinMax_U_disp, settings.MinMax_V_disp)
u,v, mask_s = validation.global_std( u, v, std_threshold = settings.std_threshold )
u, v, mask_m = validation.local_median_val( u, v, u_threshold=settings.median_threshold, v_threshold=settings.median_threshold, size=settings.median_size )
if settings.extract_sig2noise==True and settings.iterations==1 and settings.do_sig2noise_validation==True:
u,v, mask_s2n = validation.sig2noise_val( u, v, sig2noise_ratio, threshold = settings.sig2noise_threshold)
mask=mask+mask_g+mask_m+mask_s+mask_s2n
else:
mask=mask+mask_g+mask_m+mask_s
'filter to replace the values that where marked by the validation'
if settings.iterations>1:
u, v = filters.replace_outliers( u, v, method=settings.filter_method, max_iter=settings.max_filter_iteration, kernel_size=settings.filter_kernel_size)
'adding masks to add the effect of all the validations'
if settings.smoothn==True:
#print('Hello I am running')
u,dummy_u1,dummy_u2,dummy_u3=smoothn(u,s=settings.smoothn_p)
v,dummy_v1,dummy_v2,dummy_v3=smoothn(v,s=settings.smoothn_p)
elif settings.iterations==1 and settings.replace_vectors==True:
u, v = filters.replace_outliers( u, v, method=settings.filter_method, max_iter=settings.max_filter_iteration, kernel_size=settings.filter_kernel_size)
'adding masks to add the effect of all the validations'
if settings.smoothn==True:
#print('Hello I am running')
u, v = filters.replace_outliers( u, v, method=settings.filter_method, max_iter=settings.max_filter_iteration, kernel_size=settings.filter_kernel_size)
u,dummy_u1,dummy_u2,dummy_u3=smoothn(u,s=settings.smoothn_p)
v,dummy_v1,dummy_v2,dummy_v3=smoothn(v,s=settings.smoothn_p)
i = 1
'all the following passes'
for i in range(2, settings.iterations+1):
x, y, u, v, sig2noise_ratio, mask = windef.multipass_img_deform(frame_a, frame_b, settings.windowsizes[i-1], settings.overlap[i-1],settings.iterations,i,
x, y, u, v, correlation_method=settings.correlation_method,
subpixel_method=settings.subpixel_method, do_sig2noise=settings.extract_sig2noise,
sig2noise_method=settings.sig2noise_method, sig2noise_mask=settings.sig2noise_mask,
MinMaxU=settings.MinMax_U_disp,
MinMaxV=settings.MinMax_V_disp,std_threshold=settings.std_threshold,
median_threshold=settings.median_threshold,median_size=settings.median_size,filter_method=settings.filter_method,
max_filter_iteration=settings.max_filter_iteration, filter_kernel_size=settings.filter_kernel_size,
interpolation_order=settings.interpolation_order)
# If the smoothing is active, we do it at each pass
if settings.smoothn==True:
#print('Hello I am running')
u,dummy_u1,dummy_u2,dummy_u3=smoothn(u,s=settings.smoothn_p)
v,dummy_v1,dummy_v2,dummy_v3=smoothn(v,s=settings.smoothn_p)
# if settings.smoothn==True
# u,dummy_u1,dummy_u2,dummy_u3=smoothn(u,s=settings.smoothn_p)
# v,dummy_v1,dummy_v2,dummy_v3=smoothn(v,s=settings.smoothn_p)
'''%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%'''
if settings.extract_sig2noise==True and i==settings.iterations and settings.iterations!=1 and settings.do_sig2noise_validation==True:
u,v, mask_s2n = validation.sig2noise_val( u, v, sig2noise_ratio, threshold = settings.sig2noise_threshold)
mask=mask+mask_s2n
if settings.replace_vectors==True:
u, v = filters.replace_outliers( u, v, method=settings.filter_method, max_iter=settings.max_filter_iteration, kernel_size=settings.filter_kernel_size)
'pixel/frame->pixel/sec'
u=u/settings.dt
v=v/settings.dt
'scales the results pixel-> meter'
x, y, u, v = scaling.uniform(x, y, u, v, scaling_factor = settings.scaling_factor )
'save to a file'
tools_patch.save_windef(x, y, u, v,sig2noise_ratio, mask ,os.path.join(save_path,'field_A%03d.txt' % counter), delimiter='\t')
'some messages to check if it is still alive'
'some other stuff that one might want to use'
if settings.show_plot==True or settings.save_plot==True:
plt.close('all')
fig, ax = tools_patch.display_vector_field_windef(os.path.join(save_path, 'field_A%03d.txt' % counter), scaling_factor=settings.scale_plot)
Name = os.path.join(save_path, 'Image_A%03d.png' % (counter-1))
#Name = os.path.join(save_path, settings.field_name)
if settings.save_plot==True:
fig.savefig(Name, dpi=100)
if settings.show_plot==True:
plt.show()
print('Image Pair ' + str(counter))
# coordinates, we have to either run first pass or
# use get_coordinates
# Since we do not know how to use the image_mask in the
# first pass with the vectorized correlations, i.e. how to
# save some computational time by skipping the interrogation
# windows within the image mask, we just run the first pass
# "first pass"
x, y, u, v, sig2noise_ratio = windef.first_pass(
frame_a,
frame_b,
settings.windowsizes[0],
settings.overlap[0],
settings.iterations,
correlation_method=settings.correlation_method,
subpixel_method=settings.subpixel_method,
do_sig2noise=settings.extract_sig2noise,
sig2noise_method=settings.sig2noise_method,
sig2noise_mask=settings.sig2noise_mask,
normalized_correlation=settings.normalized_correlation
)
# store for the comparison of the following steps
u0 = u.copy()
v0 = v.copy()
def status_message(u):
print(f"{np.isnan(u).sum()/u.size*100:.2f}% invalid vectors out of {u.size} vectors")
status_message(u)
