def test_auto_corr_scat_factor():
num_levels, num_bufs = 3, 4
tot_channels, lags, dict_lags = utils.multi_tau_lags(num_levels, num_bufs)
beta = 0.5
relaxation_rate = 10.0
baseline = 1.0
g2 = auto_corr_scat_factor(lags, beta, relaxation_rate, baseline)
assert_array_almost_equal(g2, np.array([1.5, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0]), decimal=8)
def test_auto_corr_scat_factor():
num_levels, num_bufs = 3, 4
tot_channels, lags, dict_lags = utils.multi_tau_lags(num_levels, num_bufs)
beta = 0.5
relaxation_rate = 10.0
baseline = 1.0
g2 = auto_corr_scat_factor(lags, beta, relaxation_rate, baseline)
assert_array_almost_equal(g2, np.array([1.5, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0]), decimal=8)
def test_multi_tau_lags():
levels = 3
channels = 8
delay_steps = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28]
dict_dly = {}
dict_dly[1] = (0, 1, 2, 3, 4, 5, 6, 7)
dict_dly[3] = (16, 20, 24, 28)
dict_dly[2] = (8, 10, 12, 14)
tot_channels, lag_steps, dict_lags = core.multi_tau_lags(levels, channels)
assert_array_equal(16, tot_channels)
assert_array_equal(delay_steps, lag_steps)
assert_array_equal(dict_dly[1], dict_lags[1])
assert_array_equal(dict_dly[3], dict_lags[3])
def test_multi_tau_lags():
levels = 3
channels = 8
delay_steps = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28]
dict_dly = {}
dict_dly[1] = (0, 1, 2, 3, 4, 5, 6, 7)
dict_dly[3] = (16, 20, 24, 28)
dict_dly[2] = (8, 10, 12, 14)
tot_channels, lag_steps, dict_lags = core.multi_tau_lags(levels, channels)
assert_array_equal(16, tot_channels)
assert_array_equal(delay_steps, lag_steps)
assert_array_equal(dict_dly[1], dict_lags[1])
assert_array_equal(dict_dly[3], dict_lags[3])
def _validate_and_transform_inputs(num_bufs, num_levels, labels):
"""
This is a helper function to validate inputs and create initial state
inputs for both one time and two time correlation
Parameters
----------
num_bufs : int
num_levels : int
labels : array
labeled array of the same shape as the image stack;
each ROI is represented by a distinct label (i.e., integer)
Returns
-------
label_array : array
labels of the required region of interests(ROI's)
pixel_list : array
1D array of indices into the raveled image for all
foreground pixels (labeled nonzero)
e.g., [5, 6, 7, 8, 14, 15, 21, 22]
num_rois : int
number of region of interests (ROI)
num_pixels : array
number of pixels in each ROI
lag_steps : array
the times at which the correlation was computed
buf : array
image data for correlation
img_per_level : array
to track how many images processed in each level
track_level : array
to track processing each level
cur : array
to increment the buffer
norm : dict
to track bad images
lev_len : array
length of each levels
"""
if num_bufs % 2 != 0:
raise ValueError("There must be an even number of `num_bufs`. You "
"provided %s" % num_bufs)
label_array, pixel_list = extract_label_indices(labels)
# map the indices onto a sequential list of integers starting at 1
label_mapping = {label: n+1
for n, label in enumerate(np.unique(label_array))}
# remap the label array to go from 1 -> max(_labels)
for label, n in label_mapping.items():
label_array[label_array == label] = n
# number of ROI's
num_rois = len(label_mapping)
# stash the number of pixels in the mask
num_pixels = np.bincount(label_array)[1:]
# Convert from num_levels, num_bufs to lag frames.
tot_channels, lag_steps, dict_lag = multi_tau_lags(num_levels, num_bufs)
# these norm and lev_len will help to find the one time correlation
# normalization norm will updated when there is a bad image
norm = {key: [0] * len(dict_lag[key]) for key in (dict_lag.keys())}
lev_len = np.array([len(dict_lag[i]) for i in (dict_lag.keys())])
# Ring buffer, a buffer with periodic boundary conditions.
# Images must be keep for up to maximum delay in buf.
buf = np.zeros((num_levels, num_bufs, len(pixel_list)),
dtype=np.float64)
# to track how many images processed in each level
img_per_level = np.zeros(num_levels, dtype=np.int64)
# to track which levels have already been processed
track_level = np.zeros(num_levels, dtype=bool)
# to increment buffer
cur = np.ones(num_levels, dtype=np.int64)
return (label_array, pixel_list, num_rois, num_pixels,
lag_steps, buf, img_per_level, track_level, cur,
norm, lev_len)
def _validate_and_transform_inputs(num_bufs, num_levels, labels):
"""
This is a helper function to validate inputs and create initial state
inputs for both one time and two time correlation
Parameters
----------
num_bufs : int
num_levels : int
labels : array
labeled array of the same shape as the image stack;
each ROI is represented by a distinct label (i.e., integer)
Returns
-------
label_array : array
labels of the required region of interests(ROI's)
pixel_list : array
1D array of indices into the raveled image for all
foreground pixels (labeled nonzero)
e.g., [5, 6, 7, 8, 14, 15, 21, 22]
num_rois : int
number of region of interests (ROI)
num_pixels : array
number of pixels in each ROI
lag_steps : array
the times at which the correlation was computed
buf : array
image data for correlation
img_per_level : array
to track how many images processed in each level
track_level : array
to track processing each level
cur : array
to increment the buffer
norm : dict
to track bad images
lev_len : array
length of each levels
"""
if num_bufs % 2 != 0:
raise ValueError("There must be an even number of `num_bufs`. You "
"provided %s" % num_bufs)
label_array, pixel_list = extract_label_indices(labels)
# map the indices onto a sequential list of integers starting at 1
label_mapping = {
label: n + 1
for n, label in enumerate(np.unique(label_array))
}
# remap the label array to go from 1 -> max(_labels)
for label, n in label_mapping.items():
label_array[label_array == label] = n
# number of ROI's
num_rois = len(label_mapping)
# stash the number of pixels in the mask
num_pixels = np.bincount(label_array)[1:]
# Convert from num_levels, num_bufs to lag frames.
tot_channels, lag_steps, dict_lag = multi_tau_lags(num_levels, num_bufs)
# these norm and lev_len will help to find the one time correlation
# normalization norm will updated when there is a bad image
norm = {key: [0] * len(dict_lag[key]) for key in (dict_lag.keys())}
lev_len = np.array([len(dict_lag[i]) for i in (dict_lag.keys())])
# Ring buffer, a buffer with periodic boundary conditions.
# Images must be keep for up to maximum delay in buf.
buf = np.zeros((num_levels, num_bufs, len(pixel_list)), dtype=np.float64)
# to track how many images processed in each level
img_per_level = np.zeros(num_levels, dtype=np.int64)
# to track which levels have already been processed
track_level = np.zeros(num_levels, dtype=bool)
# to increment buffer
cur = np.ones(num_levels, dtype=np.int64)
return (label_array, pixel_list, num_rois, num_pixels, lag_steps, buf,
img_per_level, track_level, cur, norm, lev_len)
