def test_multiply(self):
video = fromarrays((vid, ))
with self.assertRaises(ValueError):
list(multiply(video, ((window, window), ) * 128))
video = fromarrays((vid, ))
out = multiply(video, ((window, ), ) * 128)
for frames, true_frame in zip(out, vid_multiply):
self.assertTrue(np.allclose(frames[0], true_frame))
def calculate():
out = None
bgs = []
vars = []
for i in range(NRUN):
print("Run {}/{}".format(i + 1, NRUN))
seed(i)
importlib.reload(video_simulator) #recreates iterator with new seed
video = multiply(video_simulator.video, window_video)
fft = rfft2(video, kimax=51, kjmax=0)
fft_array, = asarrays(fft, NFRAMES_RANDOM)
data = acorr(fft_array)
bg, var = stats(fft_array)
bgs.append(bg)
vars.append(var)
for norm in (1, 2, 3, 5, 6, 7, 9, 10, 11):
y = normalize(data, bg, var, norm=norm, scale=True)
if out is None:
out = np.empty(shape=(NRUN, 12) + y.shape, dtype=y.dtype)
out[i, norm] = y
return out, bgs, vars
def test_multiple(self):
video = fromarrays((vid, ))
video = subtract(video, ((bg, ), ) * 128, dtype=FDTYPE)
video = multiply(video, ((window, ), ) * 128, inplace=True)
video = add(video, ((bg, ), ) * 128, inplace=True)
video = subtract(video, ((bg, ), ) * 128, inplace=True)
out = normalize_video(video, inplace=True)
for frames, true_frame in zip(out, vid_multiple):
self.assertTrue(np.allclose(frames[0], true_frame))
def calculate():
out = None
bgs = []
vars = []
for i in range(NRUN):
print("Run {}/{}".format(i+1,NRUN))
seed(i)
importlib.reload(video_simulator) #recreates iterator with new seed
t1,t2 = video_simulator.t1,video_simulator.t2
video = multiply(video_simulator.video, window_video)
#: if the intesity of light source flickers you can normalize each frame to the intensity of the frame
#video = normalize_video(video)
#: perform rfft2 and crop results, to take only first kimax and first kjmax wavenumbers.
fft = rfft2(video, kimax = KIMAX, kjmax = 0)
#: you can also normalize each frame with respect to the [0,0] component of the fft
#: this it therefore equivalent to normalize_video
#fft = normalize_fft(fft)
f1, f2 = asarrays(fft,NFRAMES)
bg, var = stats(f1,f2)
bg, var = stats(f1,f2)
data = ccorr(f1,f2, t1 = t1,t2=t2, n = NFRAMES)
#: now perform auto correlation calculation with default parameters and show live
#data, bg, var = iacorr(fft, t, auto_background = True, n = NFRAMES)
#perform normalization and merge data
bgs.append(bg)
vars.append(var)
#5 and 7 are redundand, but we are calulating it for easier indexing
for norm in (1,2,3,5,6,7,9,10,11):
# weighted (subtracted and compensated)
if norm in (7,11):
y = normalize(data, bg, var, norm = norm, scale = True, weight = np.moveaxis(w,0,-1))
#weighted prime
elif norm in (3,):
y = normalize(data, bg, var, norm = norm, scale = True, weight = np.moveaxis(wp,0,-1))
else:
y = normalize(data, bg, var, norm = norm, scale = True)
if out is None:
out = np.empty(shape = (NRUN,12)+ y.shape, dtype = y.dtype)
out[i,norm] = y
return out, bgs, vars
def calculate():
out = None
bgs = []
vars = []
for i in range(NRUN):
print("Run {}/{}".format(i + 1, NRUN))
seed(i)
importlib.reload(video_simulator) #recreates iterator with new seed
t1, t2 = video_simulator.t1, video_simulator.t2
video = multiply(video_simulator.video, window_video)
fft = rfft2(video, kimax=KIMAX, kjmax=0)
f1, f2 = asarrays(fft, NFRAMES)
bg, var = stats(f1, f2)
bg, var = stats(f1, f2)
data = ccorr(f1, f2, t1=t1, t2=t2, n=NFRAMES)
bgs.append(bg)
vars.append(var)
for norm in (1, 2, 3, 5, 6, 7, 9, 10, 11):
# weighted (subtracted)
if norm in (7, 11):
y = normalize(data,
bg,
var,
norm=norm,
scale=True,
weight=np.moveaxis(w, 0, -1))
# weighted prime (baseline)
elif norm in (3, ):
y = normalize(data,
bg,
var,
norm=norm,
scale=True,
weight=np.moveaxis(wp, 0, -1))
else:
y = normalize(data, bg, var, norm=norm, scale=True)
if out is None:
out = np.empty(shape=(NRUN, 12) + y.shape, dtype=y.dtype)
out[i, norm] = y
return out, bgs, vars
def calculate(binning=1):
out = None
for i in range(NRUN):
print("Run {}/{}".format(i + 1, NRUN))
importlib.reload(dual_video_simulator) #recreates iterator
#reset seed... because we use seed(0) in dual_video_simulator
seed(i)
t1, t2 = dual_video_simulator.t1, dual_video_simulator.t2
video = multiply(dual_video_simulator.video, window_video)
#: if the intesity of light source flickers you can normalize each frame to the intensity of the frame
#video = normalize_video(video)
#: perform rfft2 and crop results, to take only first kimax and first kjmax wavenumbers.
fft = rfft2(video, kimax=51, kjmax=0)
#: you can also normalize each frame with respect to the [0,0] component of the fft
#: this it therefore equivalent to normalize_video
#fft = normalize_fft(fft)
#: now perform auto correlation calculation with default parameters and show live
data, bg, var = iccorr_multi(fft,
t1,
t2,
level_size=16,
binning=binning,
period=PERIOD,
auto_background=True)
#perform normalization and merge data
#5 and 7 are redundand, but we are calulating it for easier indexing
for norm in (1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15):
fast, slow = normalize_multi(data, bg, var, norm=norm, scale=True)
#we merge with binning (averaging) of linear data enabled/disabled
x, y = log_merge(fast, slow, binning=binning)
if out is None:
out = np.empty(shape=(NRUN, 16) + y.shape, dtype=y.dtype)
out[0, norm] = y
else:
out[i, norm] = y
return x, out
def calculate():
out = None
bgs = []
vars = []
for i in range(NRUN):
print("Run {}/{}".format(i + 1, NRUN))
seed(i)
importlib.reload(video_simulator) #recreates iterator with new seed
t = video_simulator.t
video = multiply(video_simulator.video, window_video)
#: perform rfft2 and crop results, to take only first kimax and first kjmax wavenumbers.
fft = rfft2(video, kimax=KIMAX, kjmax=0)
fft_array, = asarrays(fft, NFRAMES_RANDOM)
data = acorr(fft_array, t=t, n=int(NFRAMES / DT_RANDOM))
bg, var = stats(fft_array)
bgs.append(bg)
vars.append(var)
for norm in (1, 2, 3, 5, 6, 7, 9, 10, 11):
# weighted (subtracted)
if norm in (7, 11):
y = normalize(data,
bg,
var,
norm=norm,
scale=True,
weight=np.moveaxis(w, 0, -1))
# weighted prime (baseline)
elif norm in (3, ):
y = normalize(data,
bg,
var,
norm=norm,
scale=True,
weight=np.moveaxis(wp, 0, -1))
else:
y = normalize(data, bg, var, norm=norm, scale=True)
if out is None:
out = np.empty(shape=(NRUN, 12) + y.shape, dtype=y.dtype)
out[i, norm] = y
return out, bgs, vars
video = add(video1, video2)
#video = (move_pixels(frames) for frames in video)
#: crop video to selected region of interest
video = crop(video, roi=((0, SHAPE[0]), (0, SHAPE[1])))
# apply dust particles
if APPLY_DUST:
dust1 = plt.imread(DUST1_PATH)[0:SHAPE[0], 0:SHAPE[1],
0] #float normalized to (0,1)
dust2 = plt.imread(DUST2_PATH)[0:SHAPE[0], 0:SHAPE[1],
0] #float normalized to (0,1)
dust = ((dust1, dust2), ) * NFRAMES_DUAL
video = multiply(video, dust, dtype="uint16")
noise_model = (NOISE_MODEL, NOISE_MODEL)
video = (tuple((adc(f,
noise_model=noise_model[i],
saturation=SATURATION,
readout_noise=READOUT_NOISE,
bit_depth=BIT_DEPTH) for i, f in enumerate(frames)))
for frames in video)
#video = load(video, NFRAMES_DUAL)
if __name__ == "__main__":
#: no need to load video, but this way we load video into memory, and we
import numpy as np
from examples.conf import NFRAMES, SHAPE, KIMAX, KJMAX, DATA_PATH
#: see video_simulator for details, loads sample video
import examples.video_simulator as video_simulator
import importlib
importlib.reload(video_simulator) #recreates iterator
#: create window for multiplication...
window = blackman(SHAPE)
#: we must create a video of windows for multiplication
window_video = ((window, ), ) * NFRAMES
#:perform the actual multiplication
video = multiply(video_simulator.video, window_video)
#: if the intesity of light source flickers you can normalize each frame to the intensity of the frame
#video = normalize_video(video)
#: perform rfft2 and crop results, to take only first kimax and first kjmax wavenumbers.
fft = rfft2(video, kimax=KIMAX, kjmax=KJMAX)
#: you can also normalize each frame with respect to the [0,0] component of the fft
#: this it therefore equivalent to normalize_video
#fft = normalize_fft(fft)
if __name__ == "__main__":
import os.path as p
#: now perform auto correlation calculation with default parameters using iterative algorithm
background=BACKGROUND,
dt=DT_FULL,
sigma=SIGMA,
delta=DELTA,
intensity=INTENSITY,
dtype="uint16")
#: crop video to selected region of interest
video = crop(video, roi=((0, SHAPE[0]), (0, SHAPE[1])))
#: apply dust particles
if APPLY_DUST:
dust = plt.imread(DUST1_PATH)[0:SHAPE[0], 0:SHAPE[1],
0] #float normalized to (0,1)
dust = ((dust, ), ) * NFRAMES_FULL
video = multiply(video, dust)
video = (tuple((adc(f,
noise_model=NOISE_MODEL,
saturation=SATURATION,
readout_noise=READOUT_NOISE,
bit_depth=BIT_DEPTH) for f in frames)) for frames in video)
if __name__ == "__main__":
#: no need to load video, but this way we load video into memory, and we
#: can scroll back and forth with the viewer. Uncomment the line below.
#video = load(video, NFRAMES) # loads and displays progress bar
#: VideoViewer either expects a multi_frame iterator, or a numpy array
viewer = VideoViewer(video,
count=NFRAMES_FULL,
t1, t2 = dual_video_simulator.t1, dual_video_simulator.t2
#: create window for multiplication...
window = blackman(SHAPE)
#: we must create a video of windows for multiplication
window_video = ((window,window),)*NFRAMES
video = dual_video_simulator.video
#video = load(video,count = NFRAMES)
#video = show_diff(video, dt = (5,7,8,9,10), t1= t1, t2 = t2)
video = show_video(video)
#:perform the actual multiplication
video = multiply(video, window_video)
#: if the intesity of light source flickers you can normalize each frame to the intensity of the frame
#video = normalize_video(video)
#: perform rfft2 and crop results, to take only first kimax and first kjmax wavenumbers.
fft = rfft2(video, kimax = KIMAX, kjmax = KJMAX)
#: you can also normalize each frame with respect to the [0,0] component of the fft
#: this it therefore equivalent to normalize_video
#fft = normalize_fft(fft)
fft = play_threaded(fft)
if __name__ == "__main__":
import os.path as p
#: see video_simulator for details, loads sample video
import examples.paper.simple_video.dual_video as dual_video
importlib.reload(dual_video) #recreates iterator
t1, t2 = dual_video.t1, dual_video.t2
#: create window for multiplication...
window = blackman(SHAPE)
#: we must create a video of windows for multiplication
window_video = ((window,window),)*NFRAMES_DUAL
#:perform the actual multiplication
if APPLY_WINDOW:
video = multiply(dual_video.video, window_video)
else:
video = dual_video.video
#: if the intesity of light source flickers you can normalize each frame to the intensity of the frame
#video = normalize_video(video)
#: perform rfft2 and crop results, to take only first kimax and first kjmax wavenumbers.
fft = rfft2(video, kimax = KIMAX, kjmax = KJMAX)
#load in numpy array
fft1,fft2 = asarrays(fft, NFRAMES_DUAL)
if __name__ == "__main__":
import os.path as p
