def local_df(img_folder, seg_length=50, winsize=50, step=25):
"""
Compute local density fluctuations of given image sequence in img_folder
Args:
img_folder -- folder containing .tif image sequence
seg_length -- number of frames of each segment of video, for evaluating standard deviations
winsize --
step --
Returns:
df -- dict containing 't' and 'local_df', 't' is a list of time (frame), 'std' is a list of 2d array
with local standard deviations corresponding to 't'
"""
l = corrLib.readseq(img_folder)
num_frames = len(l)
assert (num_frames > seg_length)
stdL = []
tL = range(0, num_frames, seg_length)
for n in tL:
img_nums = range(n, min(n + seg_length, num_frames))
l_sub = l.loc[img_nums]
img_seq = []
for num, i in l_sub.iterrows():
img = io.imread(i.Dir)
X, Y, I = corrLib.divide_windows(img, windowsize=[50, 50], step=25)
img_seq.append(I)
img_stack = np.stack([img_seq], axis=0)
img_stack = np.squeeze(img_stack)
std = np.std(img_stack, axis=0)
stdL.append(std)
return {'t': tL, 'std': stdL}
def convection(pivData, image, winsize, step=None, shape=None):
"""
Compute convection term u.grad(c) based on piv data (x, y, u, v) and image.
Args:
pivData -- DataFrame of (x, y, u, v)
image -- the image corresponding to pivData
winsize -- coarse-graining scheme of image
step -- (optional) distance (pixel) between adjacent PIV vectors
shape -- (optional) shape of piv matrices
Returns:
udc -- convection term u.grad(c). unit: [u][c]/pixel, [u] is the unit of u, usually px/s, [c] is the unit of concentration
measured from image intensity, arbitrary.
"""
x = pivData.sort_values(by=['x']).x.drop_duplicates()
if step == None:
# Need to infer the step size from pivData
step = x.iat[1] - x.iat[0]
if shape == None:
# Need to infer shape from pivData
y = pivData.y.drop_duplicates()
shape = (len(y), len(x))
# check coarse-grained image shape
X, Y, I = corrLib.divide_windows(image,
windowsize=[winsize, winsize],
step=step)
assert (I.shape == shape)
X = np.array(pivData.x).reshape(shape)
Y = np.array(pivData.y).reshape(shape)
U = np.array(pivData.u).reshape(shape)
V = np.array(pivData.v).reshape(shape)
# compute gradient of concentration
# NOTE: concentration is negatively correlated with intensity.
# When computing gradient of concentration, the shifting direction should reverse.
dcx = np.gradient(I, -step, axis=1)
dcy = np.gradient(I, -step, axis=0)
udc = U * dcx + V * dcy
return udc
def PIV_masked(I0, I1, winsize, overlap, dt, mask):
"""Apply PIV analysis on masked images
Args:
I0, I1 -- adjacent images in a sequence
winsize, overlap, dt -- PIV parameters
mask -- a boolean array, False marks masked region and True marks the region of interest
mask_procedure -- the option chosen to apply the mask, used for testing, remove in the future.
Returns:
frame_data -- x, y, u, v DataFrame, here x, y is wrt original image, (u, v) are in px/s
This function is rewritten based on the PIV_droplet() function in piv_droplet.py script.
The intended usage is just to pass one additional `mask` parameter, on top of conventional parameter set.
EDIT
====
Dec 14, 2021 -- Initial commit.
Dec 15, 2021 -- After testing 2 masking procedure, option 1 is better.
Two procedures produce similar results, but option 1 is faster.
So this function temporarily uses option 1, until a better procedure comes.
Jan 07, 2022 -- Change mask threshold from 1 to 0.5, this will include more velocities.
MASKING PROCEDURE
=================
Option 1:
i) Mask on raw image: I * mask, perform PIV
ii) Divide mask into windows: mask_w
iii) use mask_w to mask resulting velocity field: u[~mask_w] = np.nan
---
Option 2:
i) Perform PIV on raw images
ii) Divide mask into windows:mask_w
iii) use mask_w to mask resulting velocity field: u[~mask_w] = np.nan
---
"""
assert (mask.shape == I0.shape)
mask = mask >= mask.mean() # convert mask to boolean array
I0_mask = I0 * mask
I1_mask = I1 * mask
x, y, u, v = PIV(I0_mask, I1_mask, winsize, overlap, dt)
mask_w = divide_windows(
mask, windowsize=[winsize, winsize], step=winsize - overlap)[2] >= 0.5
assert (mask_w.shape == x.shape)
u[~mask_w] = np.nan
v[~mask_w] = np.nan
return x, y, u, v
def divcn(pivData, img, winsize, step=None, shape=None):
"""
Compute the div(cn) term from PIV and image.
Args:
pivData -- (X, Y, U, V)
img -- 2d matrix
winsize -- window size of PIV, used to scale down image
step -- step of PIV, used to scale down image
Returns:
div_cn -- 2d matrix
"""
x = pivData.sort_values(by=['x']).x.drop_duplicates()
if step == None:
# Need to infer the step size from pivData
step = x.iat[1] - x.iat[0]
if shape == None:
# Need to infer shape from pivData
y = pivData.y.drop_duplicates()
shape = (len(y), len(x))
X, Y, I = corrLib.divide_windows(img,
windowsize=[winsize, winsize],
step=step)
c = 186 - 0.19 * I
assert (I.shape == shape)
X = np.array(pivData.x).reshape(shape)
Y = np.array(pivData.y).reshape(shape)
U = np.array(pivData.u).reshape(shape)
V = np.array(pivData.v).reshape(shape)
cu = c * U
cv = c * V
dudx = np.gradient(cu, step, axis=1)
dvdy = np.gradient(cv, step, axis=0)
div_cn = dudx + dvdy
return div_cn
def down_size_imseq(folder, windowsize=[50, 50], step=25):
"""
Downsizing an image sequence of k images in given folder and save them as an numpy array of size k*m*n,
where m and n are the downsized dimension of each image.
Args:
folder -- folder of image sequence
windowsize -- parameter of corrLib.divide_windows(), pixel
step -- parameter of corrLib.divide_windows(), pixel
Returns:
stack -- numpy array of size k*m*n
"""
l = corrLib.readseq(folder)
I_list = []
for num, i in l.iterrows():
img = io.imread(i.Dir)
X, Y, I = corrLib.divide_windows(img, windowsize=windowsize, step=step)
I_list.append(I)
stack = np.stack(I_list, axis=0)
return stack
f.write('fps = {:d}\n'.format(fps))
f.write('step = {:d}\n'.format(step))
limg = cl.readseq(folder_img)
# load piv and corresponding images
l = cl.readdata(folder_piv)
for num, i in l.iterrows():
if num >= int(len(l)/3*2):
name = i.Name
n0 = int(name.split('-')[0])
n1 = n0 + interval
if n1 <= len(limg) - 1:
I0 = io.imread(os.path.join(folder_img, '{:04d}.tif'.format(n0)))
I1 = io.imread(os.path.join(folder_img, '{:04d}.tif'.format(n1)))
X, Y, I0s = cl.divide_windows(I0, windowsize=[50, 50], step=25)
X, Y, I1s = cl.divide_windows(I1, windowsize=[50, 50], step=25)
pivData = pd.read_csv(i.Dir)
ux = np.array(pivData.u).reshape(I0s.shape)
uy = np.array(pivData.v).reshape(I0s.shape)
dcx = I0s - np.roll(I0s, 1, axis=1)
dcy = I0s - np.roll(I0s, 1, axis=0)
dc = -(I1s - I0s) # high concentration -> low intensity, so intensity increase -> concentration decrease
adv = dc/interval + ux/fps*dcx/step + uy/fps*dcy/step # unit: /frame
vdc = ux/fps*dcx/step + uy/fps*dcy/step # unit: /frame
data = pd.DataFrame().assign(x=pivData.x, y=pivData.y, dcx=dcx.flatten(), dcy=dcy.flatten(), dc=dc.flatten(), adv=adv.flatten(), vdc=vdc.flatten())
data.to_csv(os.path.join(folder_out, '{:04d}-{:04d}.csv'.format(n0, n1)), index=False)
with open(os.path.join(folder_out, 'log.txt'), 'a') as f:
f.write(time.asctime() + ' // {:04d}-{:04d} calculated\n'.format(n0, n1))
l = readseq(folder)
img = io.imread(l.Dir.loc[0])
size_min = 20
L = min(img.shape)
boxsize = np.unique(np.floor(np.logspace(np.log10(size_min),
np.log10((L-size_min)/2),100)))
df = pd.DataFrame()
for num, i in l.iterrows():
with open(os.path.join(output_folder, 'log.txt'), 'a') as f:
f.write(time.asctime() + ' // ' + i.Name + ' calculated\n')
img = io.imread(i.Dir)
bp = bpass(img, 3, 100)
bp_mh = match_hist(bp, img)
framedf = pd.DataFrame()
for bs in boxsize:
X, Y, I = divide_windows(bp_mh, windowsize=[bs, bs], step=50*size_min)
tempdf = pd.DataFrame().assign(I=I.flatten(), t=int(i.Name), size=bs,
number=range(0, len(I.flatten())))
framedf = framedf.append(tempdf)
df = df.append(framedf)
df_out = pd.DataFrame()
for number in df.number.drop_duplicates():
subdata1 = df.loc[df.number==number]
for s in subdata1['size'].drop_duplicates():
subdata = subdata1.loc[subdata1['size']==s]
d = s**2 * np.log(np.array(subdata.I)).std()
n = s**2
tempdf = pd.DataFrame().assign(n=[n], d=d, size=s, number=number)
df_out = df_out.append(tempdf)
100)))
if os.path.exists(output_folder) == False:
os.makedirs(output_folder)
with open(os.path.join(output_folder, 'log.txt'), 'w') as f:
f.write('size_min = {0:d}\n'.format(size_min))
f.write('step = {0:d}\n'.format(step))
df = pd.DataFrame()
for num, i in l.iterrows():
with open(os.path.join(output_folder, 'log.txt'), 'a') as f:
f.write(time.asctime() + ' // ' + i.Name + ' calculated\n')
img = io.imread(i.Dir)
framedf = pd.DataFrame()
for bs in boxsize:
X, Y, I = divide_windows(img, windowsize=[bs, bs], step=step)
tempdf = pd.DataFrame().assign(I=I.flatten(),
t=int(i.Name),
size=bs,
number=range(0, len(I.flatten())))
framedf = framedf.append(tempdf)
df = df.append(framedf)
df_out = pd.DataFrame()
for number in df.number.drop_duplicates():
subdata1 = df.loc[df.number == number]
for s in subdata1['size'].drop_duplicates():
subdata = subdata1.loc[subdata1['size'] == s]
d = s**2 * np.array(subdata.I).std()
n = s**2
tempdf = pd.DataFrame().assign(n=[n], d=d, size=s, number=number)
img_name = str('{:04d}'.format(int(name) - tau))
if os.path.exists(os.path.join(folder_den,
img_name + '.tif')) == False:
print('no match image')
continue
img = io.imread(os.path.join(folder_den, img_name + '.tif'))
if options == 'raw':
print('performing bpass on ' + img_name)
img = cl.match_hist(mil.bpass(img, 3, 500), img)
print('tau={:d}'.format(tau) + ', div-' + name + ' x img-' + img_name)
xlen = len(div.x.drop_duplicates())
ylen = len(div.y.drop_duplicates())
divfield = np.array(div['div']).reshape(ylen, xlen)
divfield = divfield - divfield.mean()
divfield_crop = divfield #[20:36, 8:24]
X, Y, I = cl.divide_windows(img, windowsize=[50, 50], step=25)
I_norm = I / abs(I).max()
I_norm = I_norm - I_norm.mean()
I_crop = I_norm #[20:36, 8:24]
tL.append(int(img_name))
C = (divfield_crop *
I_crop).mean() / divfield_crop.std() / I_crop.std()
CL.append(C)
data = pd.DataFrame().assign(t=tL, autocorr=CL)
saveDir = os.path.join(folder_ixdiv, 'tau={:d}'.format(tau))
if os.path.exists(saveDir) == False:
os.makedirs(saveDir)
data.to_csv(os.path.join(saveDir, 'data.csv'), index=False)
with open(os.path.join(folder_ixdiv, 'log.txt'), 'a') as f:
f.write(time.asctime() + ' // tau=' + str(tau) + ' calculated\n')
CLL.append(CL)
if os.path.exists(output_folder) == 0:
os.makedirs(output_folder)
with open(os.path.join(output_folder, 'log.txt'), 'w') as f:
f.write('Input folder: ' + str(input_folder) + '\n')
f.write('Output folder: ' + str(output_folder) + '\n')
f.write('wsize: ' + str(wsize) + '\n')
f.write('step: ' + str(step) + '\n')
l = readseq(input_folder)
num_frames = len(l)
num_sample = 100 # can modify in the future
if num_sample <= num_frames:
for num, i in l.iterrows():
if num % int(num_frames / num_sample) == 0:
img = io.imread(i.Dir)
X, Y, I = divide_windows(img, windowsize=[wsize, wsize], step=step)
XI, YI, CI = corrI(X, Y, I)
dc = distance_corr(XI, YI, CI)
dc.to_csv(os.path.join(output_folder, i.Name + '.csv'),
index=False)
with open(os.path.join(output_folder, 'log.txt'), 'a') as f:
f.write(time.asctime() + ' // ' + i.Name + ' calculated\n')
else:
for num, i in l.iterrows():
img = io.imread(i.Dir)
X, Y, I = divide_windows(img, windowsize=[wsize, wsize], step=step)
XI, YI, CI = corrI(X, Y, I)
dc = distance_corr(XI, YI, CI)
dc.to_csv(os.path.join(output_folder, i.Name + '.csv'), index=False)
with open(os.path.join(output_folder, 'log.txt'), 'a') as f:
f.write(time.asctime() + ' // ' + i.Name + ' calculated\n')
if os.path.exists(output_folder) == 0:
os.makedirs(output_folder)
with open(os.path.join(output_folder, 'log.txt'), 'w') as f:
pass
count = 0
ld = corrLib.readdata(piv_folder)
for num, i in ld.iterrows():
pivData = pd.read_csv(os.path.join(piv_folder, i.Dir))
folder, file = os.path.split(i.Dir)
name = file.split('-')[0]
img = io.imread(os.path.join(folder_img, name + '.tif'))
c, v, divcn, divcv, divv = corrLib.div_field(img, pivData, winsize, step)
X, Y, I = corrLib.divide_windows(img,
windowsize=[winsize, winsize],
step=step)
data = pd.DataFrame().assign(x=X.flatten(),
y=Y.flatten(),
divcn=divcn.flatten(),
divcv=divcv.flatten(),
divv=divv.flatten())
data.to_csv(os.path.join(output_folder, i.Name + '.csv'), index=False)
with open(os.path.join(output_folder, 'log.txt'), 'a') as f:
f.write(time.asctime() + ' // ' + name + ' calculated\n')
""" SYNTAX
python div2.py piv_folder folder_img output_folder winsize step
"""
""" TEST PARAMS
piv_folder = I:\Github\Python\Correlation\test_images\div
folder_img = I:\Github\Python\Correlation\test_images\div
