def demo_random_brain(output_dir,
n_rows=62,
n_columns=40,
n_slices=10,
n_scans=240):
"""Now, how about STC for brain packed with white-noise ? ;)
"""
print("\r\n\t\t ---demo_random_brain---")
# populate brain with white-noise (for BOLD values)
brain_data = np.random.randn(n_rows, n_columns, n_slices, n_scans)
# instantiate STC object
stc = STC()
# fit STC
stc.fit(raw_data=brain_data)
# re-slice random brain
stc.transform(brain_data)
# QA clinic
generate_stc_thumbnails([brain_data], [stc.get_last_output_data()],
output_dir,
close=False)
def demo_random_brain(n_rows=62, n_columns=40, n_slices=10, n_scans=240):
"""Now, how about STC for brain packed with white-noise ? ;)
"""
print("\r\n\t\t ---demo_random_brain---")
# populate brain with white-noise (for BOLD values)
brain_data = np.random.randn(n_rows, n_columns, n_slices, n_scans)
# instantiate STC object
stc = STC()
# fit STC
stc.fit(raw_data=brain_data)
# re-slice random brain
stc.transform(brain_data)
# QA clinic
generate_stc_thumbnails([brain_data], [stc.get_last_output_data()],
'/tmp/', close=False)
def demo_HRF(n_slices=10,
n_rows=2,
n_columns=3,
white_noise_std=1e-4,
):
"""STC for phase-shifted HRF in the presence of white-noise
Parameters
----------
n_slices: int (optional, default 21)
number of slices per 3D volume of the acquisition
n_voxels_per_slice: int (optional, default 1)
the number of voxels per slice in the simulated brain
(setting this to 1 is sufficient for most QA since STC works
slice-wise, and not voxel-wise)
white_noise_std: float (optional, default 1e-4)
STD of white noise to add to phase-shifted sample (spatial corruption)
"""
print("\r\n\t\t ---demo_HRF---")
import math
slice_indices = np.arange(n_slices, dtype=int)
# create time values scaled at 1%
timescale = .01
n_timepoints = 24
time = np.linspace(0, n_timepoints, num=1 + (n_timepoints - 0) / timescale)
# create gamma functions
n1 = 4
lambda1 = 2
n2 = 7
lambda2 = 2
a = .3
c1 = 1
c2 = .5
def compute_hrf(t):
"""Auxiliary function to compute HRF at given times (t)
"""
hx = (t ** (n1 - 1)) * np.exp(
-t / lambda1) / ((lambda1 ** n1) * math.factorial(n1 - 1))
hy = (t ** (n2 - 1)) * np.exp(
-t / lambda2) / ((lambda2 ** n2) * math.factorial(n2 - 1))
# create hrf = weighted difference of two gammas
hrf = a * (c1 * hx - c2 * hy)
return hrf
# sample the time and the signal
freq = 100
TR = 3.
acquisition_time = time[::TR * freq]
n_scans = len(acquisition_time)
# corrupt the sampled time by shifting it to the right
slice_TR = 1. * TR / n_slices
time_shift = slice_indices * slice_TR
shifted_acquisition_time = np.array([tau + acquisition_time
for tau in time_shift])
# acquire the signal at the corrupt sampled time points
acquired_sample = np.array([np.vectorize(compute_hrf)(
shifted_acquisition_time[j])
for j in xrange(n_slices)])
acquired_sample = np.array([acquired_sample, ] * n_columns)
acquired_sample = np.array([acquired_sample, ] * n_rows)
# add white noise
acquired_sample += white_noise_std * np.random.randn(
*acquired_sample.shape)
# fit STC
stc = STC()
stc.fit(n_scans=n_scans, n_slices=n_slices)
# apply STC
stc.transform(acquired_sample)
# QA clinic
generate_stc_thumbnails(acquired_sample,
stc.get_last_output_data(), '/tmp/',
close=False)
