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
#####################
# Here goes you code
#####################
# read images into numpy arrays
frame_a = tools.imread(os.path.join(path, file_a))
frame_b = tools.imread(os.path.join(path, file_b))
frame_a = (frame_a * 1024).astype(np.int32)
frame_b = (frame_b * 1024).astype(np.int32)
# process image pair with extended search area piv algorithm.
u, v, sig2noise = process.extended_search_area_piv( frame_a, frame_b, \
window_size=64, overlap=32, dt=0.02, search_area_size=128, sig2noise_method='peak2peak')
u, v, mask = validation.sig2noise_val(u, v, sig2noise, threshold=1.5)
u, v = filters.replace_outliers(u,
v,
method='localmean',
max_iter=10,
kernel_size=2)
# get window centers coordinates
x, y = process.get_coordinates(image_size=frame_a.shape,
window_size=64,
overlap=32)
# save to a file
tools.save(x, y, u, v, mask, 'test2_%03d.txt' % counter)
tools.display_vector_field('test2_%03d.txt' % counter)
def process_node(i):
DeltaFrame = 1
winsize = 50 # pixels
searchsize = 50 #pixels
overlap = 25 # piexels
dt = DeltaFrame * 1. / fps # piexels
frame_a = tools.imread(fileNameList[i])
frame_b = tools.imread(fileNameList[i + DeltaFrame])
u0, v0, sig2noise = process.extended_search_area_piv(
frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=winsize,
overlap=overlap,
dt=dt,
search_area_size=searchsize,
sig2noise_method='peak2peak')
x, y = process.get_coordinates(image_size=frame_a.shape,
window_size=winsize,
overlap=overlap)
u1, v1, mask = validation.sig2noise_val(u0, v0, sig2noise, threshold=1.3)
u2, v2 = filters.replace_outliers(u1,
v1,
method='localmean',
max_iter=5,
kernel_size=5)
tools.save(x, y, u2, v2, mask,
'../muscle10fpsbotleft_results/' + str(i) + '.txt')
def openpiv_default_run(im1, im2):
""" default settings for OpenPIV analysis using
extended_search_area_piv algorithm for two images
Inputs:
im1,im2 : str,str = path of two image
"""
frame_a = tools.imread(im1)
frame_b = tools.imread(im2)
u, v, sig2noise = process.extended_search_area_piv(
frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=32,
overlap=8,
dt=1,
search_area_size=64,
sig2noise_method='peak2peak')
x, y = process.get_coordinates(image_size=frame_a.shape,
window_size=32,
overlap=8)
u, v, mask = validation.sig2noise_val(u, v, sig2noise, threshold=1.3)
u, v = filters.replace_outliers(u,
v,
method='localmean',
max_iter=10,
kernel_size=2)
x, y, u, v = scaling.uniform(x, y, u, v, scaling_factor=1)
tools.save(x, y, u, v, mask, list_of_images[0] + '.txt')
fig, ax = tools.display_vector_field(list_of_images[0] + '.txt',
on_img=True,
image_name=list_of_images[0],
scaling_factor=1,
ax=None)
def two_images(image_1, image_2, search_area_size=64, window_size=32, overlap=16, dt=0.02):
with open("image_1.bmp", "wb") as fh1:
fh1.write(base64.b64decode(image_1))
with open("image_2.bmp", "wb") as fh2:
fh2.write(base64.b64decode(image_2))
frame_a = tools.imread( 'image_1.bmp' )
frame_b = tools.imread( 'image_2.bmp' )
frame_a = (frame_a*1024).astype(np.int32)
frame_b = (frame_b*1024).astype(np.int32)
if not search_area_size:
search_area_size = 64
if not window_size:
window_size = 32
if not overlap:
overlap = 16
if not dt:
dt = 0.02
u, v, sig2noise = process.extended_search_area_piv( frame_a, frame_b, window_size=window_size,
overlap=overlap, dt=dt, search_area_size=search_area_size, sig2noise_method='peak2peak' )
x, y = process.get_coordinates( image_size=frame_a.shape, window_size=window_size, overlap=overlap )
u, v, mask = validation.sig2noise_val( u, v, sig2noise, threshold = 1.3 )
u, v, mask = validation.global_val( u, v, (-1000, 2000), (-1000, 1000) )
u, v = filters.replace_outliers( u, v, method='localmean', max_iter=10, kernel_size=2)
x, y, u, v = scaling.uniform(x, y, u, v, scaling_factor = 96.52 )
file_name_text = 'result.txt'
file_name_png = 'result.png'
if os.path.isfile(file_name_text):
os.remove(file_name_text)
if os.path.isfile(file_name_png):
os.remove(file_name_png)
tools.save(x, y, u, v, mask, file_name_text)
a = np.loadtxt(file_name_text)
fig = plt.figure()
invalid = a[:,4].astype('bool')
fig.canvas.set_window_title('Vector field, '+str(np.count_nonzero(invalid))+' wrong vectors')
valid = ~invalid
plt.quiver(a[invalid,0],a[invalid,1],a[invalid,2],a[invalid,3],color='r',scale=100, width=0.0025)
plt.quiver(a[valid,0],a[valid,1],a[valid,2],a[valid,3],color='b',scale=100, width=0.0025)
plt.draw()
plt.savefig(file_name_png, format="png")
with open(file_name_text, "rb") as resultFileText:
file_reader_text = resultFileText.read()
text_encode = base64.encodestring(file_reader_text)
base64_string_text = str(text_encode, 'utf-8')
with open(file_name_png, "rb") as resultFilePng:
file_reader_image = resultFilePng.read()
image_encode = base64.encodestring(file_reader_image)
base64_string_image = str(image_encode, 'utf-8')
return base64_string_text, base64_string_image
def _piv_frame(self, img1, img2, show=False, **kwargs):
"""
calculate velocity using piv method on two frames
"""
from openpiv.process import extended_search_area_piv, get_coordinates
# from openpiv.scaling import uniform
if self._debug:
print('... [PIV] window size: {}'.format(self._windowSize))
print('... [PIV] overlap: {}'.format(self._overlap))
print('... [PIV] search area size: {}'.format(self._searchArea))
print('... [PIV] threshold: {}'.format(self._piv_threshold))
u, v, sig2noise = extended_search_area_piv(
img1,
img2,
window_size=self._windowSize,
overlap=self._overlap,
dt=self._exposuretime,
search_area_size=self._searchArea,
sig2noise_method='peak2peak')
self._pivx, self._pivy = get_coordinates(image_size=img1.shape,
window_size=self._windowSize,
overlap=self._overlap)
#self._pivy = np.flipud(self._pivy)
#self._pivx, self._pivy, u, v = uniform(self._pivx, self._pivy, u, v, scaling_factor=self._mpp)
if show:
from openpiv.validation import sig2noise_val
from openpiv.filters import replace_outliers
u, v, mask = sig2noise_val(u,
v,
sig2noise,
threshold=self._piv_threshold)
u, v = replace_outliers(u,
v,
method='localmean',
max_iter=10,
kernel_size=2)
# show quiver plot
plt.figure(figsize=(12, 6))
plt.imshow(img1)
plt.quiver(self._pivx, self._pivy, u, v, color='w', pivot='mid')
plt.savefig(self._fname[:-4] + '_piv.png', dpi=100)
if self._debug:
print(
"... [PIV] mean velocity [um/sec]: ({:4.2f}, {:4.2f})".format(
np.mean(u) * self._mpp,
np.mean(v) * self._mpp))
print("... [PIV] mean velocity [pixel/frame]: ({:4.2f}, {:4.2f})".
format(
np.mean(u) * self._exposuretime,
np.mean(v) * self._exposuretime))
return (u, v, sig2noise)
def test_process_extended_search_area():
""" test of the extended area PIV from Cython """
frame_a = np.zeros((64,64))
frame_a = random_noise(frame_a)
frame_a = img_as_ubyte(frame_a)
frame_b = np.roll(np.roll(frame_a,3,axis=1),2,axis=0)
u,v = process.extended_search_area_piv(frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=16,search_area_size=32,dt=1,overlap=0)
# print u,v
assert(np.max(np.abs(u[:-1,:-1]-3)+np.abs(v[:-1,:-1]+2)) <= 0.2)
def test_process_extended_search_area():
""" test of the extended area PIV from Cython """
frame_a = np.zeros((64, 64))
frame_a = random_noise(frame_a)
frame_a = img_as_ubyte(frame_a)
frame_b = np.roll(np.roll(frame_a, 3, axis=1), 2, axis=0)
u, v = process.extended_search_area_piv(frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=16,
search_area_size=32,
dt=1,
overlap=0)
# print u,v
assert (np.max(np.abs(u[:-1, :-1] - 3) + np.abs(v[:-1, :-1] + 2)) <= 0.2)
def analyzer(frame_a, frame_b, text, plot, num_scene, pathout, scal, zre, xre,
dt):
winsize = 16 # pixels
searchsize = 32 # pixels, search in image b
overlap = 8 # pixels
frame_a = cv2.adaptiveThreshold(frame_a, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY, 5, 5)
frame_b = cv2.adaptiveThreshold(frame_b, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY, 5, 5)
#frame_a = cv2.adaptiveThreshold(frame_a,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
#frame_b = cv2.adaptiveThreshold(frame_b,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
plt.imshow(np.c_[frame_a, frame_b], cmap='gray')
plt.savefig(pathout + '/filtered' + str(num_scene) + '.png', dpi=800)
u0, v0, sig2noise = process.extended_search_area_piv(
frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=winsize,
overlap=overlap,
dt=dt,
search_area_size=searchsize,
sig2noise_method='peak2peak')
x, y = process.get_coordinates(image_size=frame_a.shape,
window_size=winsize,
overlap=overlap)
u1, v1, mask = validation.sig2noise_val(u0, v0, sig2noise, threshold=1.3)
u2, v2 = filters.replace_outliers(u1,
v1,
method='localmean',
max_iter=10,
kernel_size=2)
x, y, u3, v3 = scaling.uniform(
x, y, u2, v2, scaling_factor=scal) # scaling_factor (pixel per meter)
u3 = np.flip(u3, axis=0)
v3 = np.flip(v3, axis=0)
xre = np.linspace(0, xre / 100, len(x[0, :]))
zre = np.linspace(0, zre / 100, len(x[:, 0]))
if plot == 1:
piv_plotting(xre, zre, u3, v3, num_scene, pathout)
if text == 0:
tools.save(x, y, u3, v3, mask,
pathout + '/piv' + str(num_scene) + '.txt')
def process_frame(self, frame_a, frame_b, s2n_thresh=1.3):
frame_a = frame_a.astype(np.int32)
frame_b = frame_b.astype(np.int32)
u, v, sig2noise = process.extended_search_area_piv(
frame_a,
frame_b,
window_size=self.window_size,
overlap=self.overlap,
dt=1,
search_area_size=self.search_area_size,
sig2noise_method='peak2peak')
#u, v, mask = validation.sig2noise_val( u, v, sig2noise, threshold = s2n_thresh )
return u, v
def update(winsize, overlap, s2n, s2n_method):
u, v, sig2noise = process.extended_search_area_piv(
frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=winsize,
overlap=overlap,
dt=1.0,
search_area_size=64,
sig2noise_method=s2n_method)
x, y = process.get_coordinates(image_size=frame_a.shape,
window_size=winsize,
overlap=overlap)
u, v, mask = validation.sig2noise_val(u, v, sig2noise, threshold=s2n)
# u, v = filters.replace_outliers( u, v, method='localmean', max_iter=10, kernel_size=2)
# x, y, u, v = scaling.uniform(x, y, u, v, scaling_factor = 1.0 )
# tools.save(x, y, u, v, mask, 'tutorial-part3.txt' )
fig, ax = plt.subplots()
ax.imshow(tools.imread('20110919 exp3 x10 stream 488570.TIF'),
cmap=plt.cm.gray,
origin='upper')
ax.quiver(x, np.flipud(y), u / 10., v / 10., scale=10, color='r', lw=3)
plt.show()
# %%
# for whatever reason the shape of frame_a is (3, 284, 256)
# so we first tranpose to the RGB image and then convert to the gray scale
# frame_a = img_as_uint(rgb2gray(frame_a))
# frame_b = img_as_uint(rgb2gray(frame_b))
plt.imshow(np.c_[frame_a, frame_b], cmap=plt.cm.gray)
# %%
# Use Cython version: process.pyx
u, v, sig2noise = process.extended_search_area_piv(
frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=32,
overlap=8,
dt=.1,
sig2noise_method='peak2peak')
x, y = process.get_coordinates(image_size=frame_a.shape,
window_size=32,
overlap=8)
u, v, mask = validation.sig2noise_val(u, v, sig2noise, threshold=1.3)
u, v = filters.replace_outliers(u,
v,
method='localmean',
max_iter=10,
kernel_size=2)
x, y, u, v = scaling.uniform(x, y, u, v, scaling_factor=96.52)
#!/usr/bin/env ipython
import sys
if 'OpenPIV' not in sys.path:
sys.path.append('/Users/alex/Documents/OpenPIV/alexlib/openpiv-python')
from openpiv import tools, validation, process, filters, scaling, pyprocess
import numpy as np
frame_a = tools.imread('exp1_001_a.bmp')
frame_b = tools.imread('exp1_001_b.bmp')
u, v, sig2noise = process.extended_search_area_piv(
frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=24,
overlap=12,
dt=0.02,
search_area_size=64,
sig2noise_method='peak2peak')
x, y = process.get_coordinates(image_size=frame_a.shape,
window_size=24,
overlap=12)
u, v, mask = validation.sig2noise_val(u, v, sig2noise, threshold=2.5)
u, v = filters.replace_outliers(u,
v,
method='localmean',
max_iter=10,
kernel_size=2)
x, y, u, v = scaling.uniform(x, y, u, v, scaling_factor=96.52)
tools.save(x, y, u, v, mask, 'exp1_001.txt')
tools.display_vector_field('exp1_001.txt', scale=100, width=0.0025)
# frame_a = img_as_ubyte(resize(frame_a,(1024,256)))
# frame_b = img_as_ubyte(resize(frame_b,(1024,256)))
frame_a = frame_a[:512, -200:]
frame_b = frame_b[:512, -200:]
#frame_a = frame_a[:256,:]
#frame_b = frame_b[:256,:]
plt.figure()
plt.imshow(np.c_[frame_a, frame_b], cmap=plt.cm.gray)
plt.show()
u, v = process.extended_search_area_piv(frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=24,
overlap=12,
search_area_size=32,
dt=1.)
plt.figure()
plt.quiver(u, v)
plt.axis('equal')
plt.show()
u1, v1 = pyprocess.piv(frame_a,
frame_b,
window_size=32,
search_size=48,
overlap=24)
# x, y = process.get_coordinates( image_size=frame_a.shape, window_size=24, overlap=0)
#!/usr/bin/env ipython
import sys
if 'OpenPIV' not in sys.path:
sys.path.append('/Users/alex/Documents/OpenPIV/alexlib/openpiv-python')
from openpiv import tools, validation, process, filters, scaling, pyprocess
import numpy as np
frame_a = tools.imread( 'exp1_001_a.bmp' )
frame_b = tools.imread( 'exp1_001_b.bmp' )
u, v, sig2noise = process.extended_search_area_piv( frame_a.astype(np.int32),
frame_b.astype(np.int32), window_size=24, overlap=12, dt=0.02, search_area_size=64,
sig2noise_method='peak2peak' )
x, y = process.get_coordinates( image_size=frame_a.shape, window_size=24, overlap=12 )
u, v, mask = validation.sig2noise_val( u, v, sig2noise, threshold = 2.5 )
u, v = filters.replace_outliers( u, v, method='localmean', max_iter=10, kernel_size=2)
x, y, u, v = scaling.uniform(x, y, u, v, scaling_factor = 96.52 )
tools.save(x, y, u, v, mask, 'exp1_001.txt' )
tools.display_vector_field('exp1_001.txt', scale=100, width=0.0025)
u, v, s2n= pyprocess.piv(frame_a, frame_b, corr_method='fft', window_size=24, overlap=12,
dt=0.02, sig2noise_method='peak2peak' )
x, y = pyprocess.get_coordinates( image_size=frame_a.shape, window_size=24, overlap=12 )
u, v, mask = validation.sig2noise_val( u, v, s2n, threshold = 2.5 )
u, v = filters.replace_outliers( u, v, method='localmean', max_iter=10, kernel_size=2.5)
x, y, u, v = scaling.uniform(x, y, u, v, scaling_factor = 96.52 )
tools.save(x, y, u, v, mask, 'exp1_002.txt' )
def piv_analysis(contr,
relax,
outfolder,
scale,
winsize_um=10,
overlap_um=None,
searchsize_um=None,
drift_correction=True,
threshold=1.2,
scale_quiver=None):
"""
Computes deformations between 2 images by crosscorrelation using openpiv (must be installed - see Readme).
Saves several quiver plots and the maximal found deformation for later analysis.
contr: Path to active/contracted image file to calculate deformations between contracted and relaxed state
relax: Path to relaxed image file to calculate deformations between contracted and relaxed state
scale: resolution of image in µm per pixel
winsize_um: size of the search window to be applied in µm
drift_correction: Applies a drift correction before piv analysis
threshold: filters displacement
scale_quiver: can be used to scale the arrows in quiver plot (only for visualization)
Default is None meaning automatically scaling , scale is inverse
"""
from openpiv import tools, process, validation, filters, scaling
winsize = int(winsize_um / scale) # for pixel
# if not specified use defaults
if not overlap_um:
overlap = winsize / 2
else:
overlap = int(overlap_um / scale)
if not searchsize_um:
searchsize = winsize
else:
searchsize = int(searchsize_um / scale)
print(winsize, overlap, searchsize)
# odd winsize raise problems due to the overlap, thefore decrease by one pixel if odd and give warning
if not (winsize % 2) == 0:
print(
'Odd pixelnumbers raise problems due to the overlap: Winsize changed to '
+ str((winsize - 1) * scale) + ' um')
winsize -= 1
# creates folder if it doesn't exist
if not os.path.exists(outfolder):
os.makedirs(outfolder)
#read in images
relax = tools.imread(relax)
contr = tools.imread(contr)
# convert for openpiv
relax = relax.astype(np.int32)
contr = contr.astype(np.int32)
dt = 1 # sec
u0, v0, sig2noise = process.extended_search_area_piv(
relax,
contr,
window_size=winsize,
overlap=overlap,
dt=dt,
search_area_size=searchsize,
sig2noise_method='peak2peak')
x, y = process.get_coordinates(image_size=relax.shape,
window_size=winsize,
overlap=overlap)
# drift correction
if drift_correction:
u0 -= np.nanmean(u0)
v0 -= np.nanmean(v0)
# filtered deformations
u1, v1, mask = validation.sig2noise_val(u0,
v0,
sig2noise,
threshold=threshold)
# save deformations + coords
np.save(outfolder + "/u.npy", u1)
np.save(outfolder + "/v.npy", v1)
np.save(outfolder + "/x.npy", x)
np.save(outfolder + "/y.npy", y)
# show filtered+unfiltered data
plt.figure(figsize=(6, 3))
plt.subplot(121)
plt.quiver(x,
y[::-1],
u0,
v0,
alpha=1,
facecolor='orange',
scale_units='xy',
scale=scale_quiver)
plt.title('unfiltered')
plt.subplot(122)
plt.title('filtered')
plt.quiver(x,
y[::-1],
u1,
v1,
alpha=1,
facecolor='b',
scale_units='xy',
scale=scale_quiver)
plt.savefig(outfolder + '/filtered+unfilterd.png',
bbox_inches='tight',
pad_inches=0)
plt.close()
# save overlay
# different color channels
plt.figure()
overlay = np.zeros((contr.shape[0], contr.shape[1], 3), 'uint8')
overlay[..., 1] = contr #1
overlay[..., 2] = relax #2
plt.imshow(overlay, origin='upper'
) #extent=[0, contr.shape[0], contr.shape[1], 0]) # turn Y
plt.quiver(x,
y,
u1,
v1,
facecolor='orange',
alpha=1,
scale_units='xy',
scale=scale_quiver)
plt.axis('off')
plt.savefig(outfolder + '/overlay-filtered.png',
bbox_inches='tight',
pad_inches=0)
# difference image
plt.figure()
plt.imshow(np.abs(contr - relax), cmap='viridis', origin='upper')
plt.quiver(x,
y,
u1,
v1,
facecolor='orange',
alpha=1,
scale_units='xy',
scale=scale_quiver)
plt.axis('off')
plt.savefig(outfolder + '/difference-img-filtered.png',
bbox_inches='tight',
pad_inches=0)
plt.close()
# save deformation and image data
deformation_unfiltered = np.sqrt(u0**2 + v0**2)
deformation_filtered = np.sqrt(u1**2 + v1**2)
maxdefo_um_unfiltered = np.nanmax(deformation_unfiltered) * scale
maxdefo_um_filtered = np.nanmax(deformation_filtered) * scale
np.savetxt(outfolder + '/maxdefo_um_unfiltered.txt',
[maxdefo_um_unfiltered])
np.savetxt(outfolder + '/maxdefo_um_filtered.txt', [maxdefo_um_filtered])
print('Maximal deformation unfiltered: ', maxdefo_um_unfiltered,
'Maximal deformation filtered: ', maxdefo_um_filtered)
plt.imsave(outfolder + '/raw_contr.png', contr, cmap='gray')
plt.imsave(outfolder + '/raw_relax.png', relax, cmap='gray')
plt.close()
return
frame_b = im_b[380:1980,0:1390]
plt.imshow(np.c_[frame_a,frame_b],cmap='gray')
# Process the original cropped image and see the OpenPIV result:
# typical parameters:
window_size = 32 #pixels
overlap = 16 # pixels
search_area_size = 64 # pixels
frame_rate = 40 # fps
# process again with the masked images, for comparison# process once with the original images
u, v, sig2noise = process.extended_search_area_piv(
frame_a.astype(np.int32) , frame_b.astype(np.int32),
window_size = window_size,
overlap = overlap,
dt=1./frame_rate,
search_area_size = search_area_size,
sig2noise_method = 'peak2peak')
x, y = process.get_coordinates( image_size = frame_a.shape, window_size = window_size, overlap = overlap )
u, v, mask = validation.global_val( u, v, (-300.,300.),(-300.,300.))
u, v, mask = validation.sig2noise_val( u, v, sig2noise, threshold = 1.1 )
u, v = filters.replace_outliers( u, v, method='localmean', max_iter = 3, kernel_size = 3)
x, y, u, v = scaling.uniform(x, y, u, v, scaling_factor = 96.52 )
# save to a file
tools.save(x, y, u, v, mask, 'test.txt', fmt='%9.6f', delimiter='\t')
tools.display_vector_field('test.txt', scale=50, width=0.002)
# masking using not optimal choice of the methods or parameters:
frame_b = tools.imread( '../test1/exp1_001_b.bmp' ) # %% fig,ax = plt.subplots(1,2) ax[0].imshow(frame_a,cmap=plt.cm.gray) ax[1].imshow(frame_b,cmap=plt.cm.gray) # %% winsize = 24 # pixels searchsize = 64 # pixels, search in image B overlap = 12 # pixels dt = 0.02 # sec u0, v0, sig2noise = process.extended_search_area_piv( frame_a.astype(np.int32), frame_b.astype(np.int32), window_size=winsize, overlap=overlap, dt=dt, search_area_size=searchsize, sig2noise_method='peak2peak' ) # %% x, y = process.get_coordinates( image_size=frame_a.shape, window_size=winsize, overlap=overlap ) # %% u1, v1, mask = validation.sig2noise_val( u0, v0, sig2noise, threshold = 1.3 ) # %% u2, v2 = filters.replace_outliers( u1, v1, method='localmean', max_iter=10, kernel_size=2) # %% x, y, u3, v3 = scaling.uniform(x, y, u2, v2, scaling_factor = 96.52 ) # %% tools.save(x, y, u3, v3, mask, 'exp1_001.txt' )
def run(self):
self.is_to_stop = False
self.piv.piv_results_list = []
for i in range(0, len(self.frames_list) - 1, abs(self.jump)):
if self.piv.xy_zoom[0][0] and self.piv.xy_zoom[1][0]:
"""try:"""
frame_a = self.frames_list[i][2][
int(self.piv.xy_zoom[1][0]):int(self.piv.xy_zoom[1][1]),
int(self.piv.xy_zoom[0][0]):int(self.piv.xy_zoom[0][1])]
frame_b = self.frames_list[i + 1][2][
int(self.piv.xy_zoom[1][0]):int(self.piv.xy_zoom[1][1]),
int(self.piv.xy_zoom[0][0]):int(self.piv.xy_zoom[0][1])]
"""
except ValueError:
frame_a = self.frames_list[i][2][int(self.frames_list[i][2].shape[1] - self.piv.xy_zoom[1][0]): int(
self.frames_list[i][2].shape[1] - self.piv.xy_zoom[1][1]),
int(self.piv.xy_zoom[0][0]): int(
self.piv.xy_zoom[0][1])]
frame_b = self.frames_list[i + 1][2][
int(self.frames_list[i + 1][2].shape[1] - self.piv.xy_zoom[1][0]): int(
self.frames_list[i + 1][2].shape[1] - self.piv.xy_zoom[1][1]),
int(self.piv.xy_zoom[0][0]): int(
self.piv.xy_zoom[0][1])]
"""
else:
frame_a = self.frames_list[i][2]
frame_b = self.frames_list[i + 1][2]
try:
self.u, self.v, self.sig2noise = extended_search_area_piv(
frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=self.winsize,
overlap=self.overlap,
dt=self.dt,
search_area_size=self.searchsize,
sig2noise_method='peak2peak')
self.x, self.y = get_coordinates(image_size=frame_a.shape,
window_size=self.winsize,
overlap=self.overlap)
self.u, self.v, self.mask = sig2noise_val(self.u,
self.v,
self.sig2noise,
threshold=1.0)
self.u, self.v = replace_outliers(self.u,
self.v,
method='localmean',
max_iter=10,
kernel_size=2)
# self.x, self.y, self.u, self.v = uniform(self.x, self.y, self.u, self.v, scaling_factor=5)
if self.piv.xy_zoom[0][0] and self.piv.xy_zoom[1][0]:
self.x += int(self.piv.xy_zoom[0][0])
self.y += int(self.piv.xy_zoom[1][0])
self.y = np.flip(self.y, 0)
self.x = np.flip(self.x, 0)
except ValueError:
if self.searchsize < self.winsize:
print("0")
self.error_message.setText(
"the search size cannot be smaller than the window size"
)
elif self.overlap > self.winsize:
print("1")
self.error_message.setText(
"Overlap has to be smaller than the window_size")
else:
print("2")
self.error_message.setText("ROI window to small")
self.error_message.exec()
break
self.piv.piv_results_list.append(
[self.x, self.y, self.u, self.v, self.mask])
self.piv.piv_images_list[i][3] = self.piv.piv_results_list[
i // abs(self.jump)]
# data = np.zeros((len(np.ravel(self.u)), 5))
# res_list = [np.ravel(self.x), np.ravel(self.y), np.ravel(self.u), np.ravel(self.v), np.ravel(self.mask)]
# for j in range(0, 4):
# for k in range(len(res_list[j])):
# data[k][j] = res_list[j][k]
# self.piv.piv_images_list[i][4] = data
# save_openpiv_vec(self.piv.piv_images_list[i][1].split('.')[0], data, 'pix', 'dt',
# len(data[0]), len(data))
self.piv.show_plot(i, self.piv.bit, True)
if i == len(self.frames_list) - 2 and self.jump == 1:
self.piv.piv_results_list.append(
[self.x, self.y, self.u, self.v, self.mask])
self.piv.piv_images_list[i +
1][3] = self.piv.piv_results_list[i +
1]
# self.piv.piv_images_list[i + 1][4] = data
self.piv.show_plot(i + 1, self.piv.bit, True)
if self.is_to_stop:
break
self.piv_finished_signal.emit()
# frame_a = img_as_ubyte(resize(frame_a,(1024,256)))
# frame_b = img_as_ubyte(resize(frame_b,(1024,256)))
frame_a = frame_a[:512,-200:]
frame_b = frame_b[:512,-200:]
#frame_a = frame_a[:256,:]
#frame_b = frame_b[:256,:]
plt.figure()
plt.imshow(np.c_[frame_a,frame_b],cmap=plt.cm.gray)
plt.show()
u, v = process.extended_search_area_piv(frame_a.astype(np.int32),
frame_b.astype(np.int32), window_size=24, overlap=12, search_area_size=32, dt = 1.)
plt.figure()
plt.quiver(u,v)
plt.axis('equal')
plt.show()
u1, v1 = pyprocess.piv(frame_a, frame_b, window_size=32, search_size=48, overlap=24)
# x, y = process.get_coordinates( image_size=frame_a.shape, window_size=24, overlap=0)
plt.figure()
plt.quiver(u1,v1,v1)
plt.axis('equal')
plt.show()
def piv():
"""
Simplest PIV run on the pair of images using default settings
piv(im1,im2) will create a tmp.vec file with the vector filed in pix/dt (dt=1) from
two images, im1,im2 provided as full path filenames (TIF is preferable, whatever imageio can read)
"""
import imageio
import numpy as np
import matplotlib.pyplot as plt
from openpiv import process
import pkg_resources as pkg
import numpy as np
import matplotlib.animation as animation
# if im1 is None and im2 is None:
im1 = pkg.resource_filename('openpiv', 'examples/test5/frame_a.tif')
im2 = pkg.resource_filename('openpiv', 'examples/test5/frame_b.tif')
frame_a = imageio.imread(im1)
frame_b = imageio.imread(im2)
frame_a[0:32, 512 - 32:] = 255
images = []
images.extend([frame_a, frame_b])
fig, ax = plt.subplots()
# ims is a list of lists, each row is a list of artists to draw in the
# current frame; here we are just animating one artist, the image, in
# each frame
ims = []
for i in range(2):
im = ax.imshow(images[i % 2], animated=True, cmap=plt.cm.gray)
ims.append([im])
_ = animation.ArtistAnimation(fig,
ims,
interval=200,
blit=False,
repeat_delay=0)
plt.show()
# import os
u, v = process.extended_search_area_piv(frame_a.astype(np.int32),
frame_b.astype(np.int32),
window_size=32,
overlap=16)
x, y = process.get_coordinates(image_size=frame_a.shape,
window_size=32,
overlap=16)
fig, ax = plt.subplots(1, 2, figsize=(11, 8))
ax[0].imshow(frame_a, cmap=plt.get_cmap('gray'), alpha=0.8, origin='upper')
ax[0].quiver(x, y, u, v, scale=50, color='r')
ax[1].quiver(x, y, u, v, scale=50, color='b')
ax[1].set_aspect(1.1)
ax[1].invert_yaxis()
plt.show()
return x, y, u, v
from openpiv import tools, process, scaling, validation, filters
import numpy as np
import os
# we can run it from any folder
path = os.path.dirname(os.path.abspath(__file__))
frame_a = tools.imread(os.path.join(path, '../test1/exp1_001_a.bmp'))
frame_b = tools.imread(os.path.join(path, '../test1/exp1_001_b.bmp'))
frame_a = (frame_a * 1024).astype(np.int32)
frame_b = (frame_b * 1024).astype(np.int32)
u, v, sig2noise = process.extended_search_area_piv( frame_a, frame_b, \
window_size=32, overlap=16, dt=0.02, search_area_size=64, sig2noise_method='peak2peak' )
x, y = process.get_coordinates(image_size=frame_a.shape,
window_size=32,
overlap=16)
u, v, mask = validation.sig2noise_val(u, v, sig2noise, threshold=1.3)
u, v, mask = validation.global_val(u, v, (-1000, 2000), (-1000, 1000))
u, v = filters.replace_outliers(u,
v,
method='localmean',
max_iter=10,
kernel_size=2)
x, y, u, v = scaling.uniform(x, y, u, v, scaling_factor=96.52)
tools.save(x, y, u, v, mask, 'test1.vec')
tools.display_vector_field('test1.vec', scale=75, width=0.0035)