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_sinusoidal_mixture(n_slices=10, n_rows=3, n_columns=2,
introduce_artefact_in_these_volumes=None,
artefact_std=4.,
white_noise_std=1e-2):
"""STC for time phase-shifted sinusoidal mixture in the presence of
white-noise and volume-specific artefacts. This is supposed to be a
BOLD time-course from a single voxel.
Parameters
----------
n_slices: int (optional)
number of slices per 3D volume of the acquisition
n_rows: int (optional)
number of rows in simulated acquisition
n_columns: int (optional)
number of columns in simmulated acquisition
white_noise_std: float (optional, default 1e-2)
amplitude of white noise to add to phase-shifted sample (spatial
corruption)
artefact_std: float (optional, default 4)
amplitude of artefact
introduce_artefact_in_these_volumesS: string, integer, or list of integers
(optional, "middle")
TR/volume index or indices to corrupt with an artefact (a spontaneous
stray spike, probably due to instability of scanner B-field) of
amplitude artefact_std
"""
print("\r\n\t\t ---demo_sinusoid_mixture---")
slice_indices = np.arange(n_slices, dtype=int)
timescale = .01
sine_freq = [.5, .8, .11, .7]
def my_sinusoid(t):
"""Creates mixture of sinusoids with different frequencies
"""
res = t * 0
for f in sine_freq:
res += np.sin(2 * np.pi * t * f)
return res
time = np.arange(0, 24 + timescale, timescale)
# define timing vars
freq = 10
TR = freq * timescale
# sample the time
acquisition_time = time[::freq]
# 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_signal = np.array([
[[my_sinusoid(shifted_acquisition_time[j])
for j in xrange(n_slices)]
for _ in xrange(n_columns)] for _ in xrange(n_rows)]
)
# add white noise
acquired_signal += white_noise_std * np.random.randn(
*acquired_signal.shape)
n_scans = len(acquisition_time)
# add artefacts to specific volumes/TRs
if introduce_artefact_in_these_volumes is None:
introduce_artefact_in_these_volumes = []
if isinstance(introduce_artefact_in_these_volumes, int):
introduce_artefact_in_these_volumes = [
introduce_artefact_in_these_volumes]
elif introduce_artefact_in_these_volumes == "middle":
introduce_artefact_in_these_volumes = [n_scans // 2]
else:
assert hasattr(introduce_artefact_in_these_volumes, '__len__')
introduce_artefact_in_these_volumes = np.array(
introduce_artefact_in_these_volumes, dtype=int) % n_scans
acquired_signal[:, :, :, introduce_artefact_in_these_volumes
] += artefact_std * np.random.randn(
n_rows, n_columns, n_slices,
len(introduce_artefact_in_these_volumes))
# fit STC
stc = STC()
stc.fit(n_slices=n_slices, n_scans=n_scans)
# apply STC
st_corrected_signal = stc.transform(acquired_signal)
# QA clinic
generate_stc_thumbnails(acquired_signal,
st_corrected_signal, '/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)