Single anatomical volume with 2D EPI with SNAKE-fMRI

This examples walks through the elementary components of SNAKE.

Here we proceed step by step and use the Python interface. A more integrated alternative is to use the CLI snake-main

# Imports
import numpy as np
from snake.core.simulation import SimConfig, default_hardware, GreConfig
from snake.core.phantom import Phantom
from snake.core.smaps import get_smaps
from snake.core.sampling import EPI3dAcquisitionSampler

Setting up the base simulation Config. This configuration holds all key parameters for the simulation, describing the scanner parameters.

sim_conf = SimConfig(
    max_sim_time=3,
    seq=GreConfig(TR=50, TE=30, FA=3),
    hardware=default_hardware,
)
sim_conf.hardware.n_coils = 8

sim_conf.fov.res_mm = (3,3,3)
sim_conf

SimConfig

max_sim_time(float)	3
seq(GreConfig)	GreConfig TR (float) TE (float) FA (float) 50 30 3
hardware(HardwareConfig)	HardwareConfig gmax (float) smax (float) n_coils (int) dwell_time_ms (float) raster_time_ms (float) field (float) 40 200 8 0.001 0.005 3.0
fov(FOVConfig)	FOVConfig size (ThreeFloats) offset (ThreeFloats) angles (ThreeFloats) res_mm (ThreeFloats) (181, 217, 181) (-90.25, -126.25, -72.25) (0, 0, 0) (3, 3, 3)
rng_seed(int)	19290506

Creating the base Phantom

The simulation acquires the data describe in a phantom. A phantom consists of fuzzy segmentation of head tissue, and their MR intrinsic parameters (density, T1, T2, T2*, magnetic susceptibilities)

Here we use Brainweb reference mask and values for convenience.

phantom = Phantom.from_brainweb(sub_id=4, sim_conf=sim_conf, output_res=1)

# Here are the tissue availables and their parameters
phantom

Phantom[brainweb-{sub_id:02d}]: (12, 5)
tissue name   PropTissueEnum.T1PropTissueEnum.T2PropTissueEnum.T2sPropTissueEnum.rhoPropTissueEnum.chi
vessels       1600.080.070.0 1.0-9.0
wm            500.070.061.00.7699999809265137-9.050000190734863
muscles       900.050.040.0 1.0-9.050000190734863
skull         300.0 1.0 1.00.10000000149011612-8.859999656677246
dura          1000.0100.050.00.6000000238418579-9.050000190734863
marrow        1000.050.040.0 1.0-9.050000190734863
csf           4000.02000.02000.0 1.0-9.050000190734863
muscles_skin  2569.0329.058.0 1.0-9.050000190734863
gm            900.090.069.00.8600000143051147-9.050000190734863
fat           250.070.060.0 1.0-7.789999961853027
bck           800.0800.0800.0 0.00.36000001430511475
fat2          250.070.060.0 1.0-7.789999961853027

Setting up Acquisition Pattern and Initializing Result file.

# The next piece of simulation is the acquisition trajectory.
# Here nothing fancy, we are using a EPI (fully sampled), that samples a 3D
# k-space (this akin to the 3D EPI sequence of XXXX)

sampler = EPI3dAcquisitionSampler(accelz=1, acsz=0.1, orderz="top-down")

smaps = None
if sim_conf.hardware.n_coils > 1:
    smaps = get_smaps(sim_conf.shape, n_coils=sim_conf.hardware.n_coils)

Acquisition with Cartesian Engine

The generated file example_EPI.mrd does not contains any k-space data for now, only the sampling trajectory. let’s put some in. In order to do so, we need to setup the acquisition engine that models the MR physics, and get sampled at the specified k-space trajectory.

Here, we have a single frame to acquire with 60 slice (one EPI per slice), so a single worker will be enough.

from snake.core.engine import EPIAcquisitionEngine

engine = EPIAcquisitionEngine(model="T2s", slice_2d=True)  # use the 2D epi.

engine(
    "example_EPI2D.mrd",
    sampler=sampler,
    phantom=phantom,
    sim_conf=sim_conf,
    worker_chunk_size=20,
    n_workers=2,
)

Traceback (most recent call last):
  File "/volatile/github-ci-mind-inria/gpu_mind_runner/_work/snake-fmri/snake-fmri/examples/anatomical/example_EPI_2D.py", line 83, in <module>
    engine(
  File "/volatile/github-ci-mind-inria/gpu_mind_runner/_work/snake-fmri/snake-fmri/src/snake/core/engine/base.py", line 223, in __call__
    if any(h.__updates_sim_conf__ for h in handlers) and resample_early:
TypeError: 'NoneType' object is not iterable

Simple reconstruction

Getting k-space data is nice, but SNAKE also provides rudimentary reconstruction tools to get images (and check that we didn’t mess up the acquisition process). This is available in the companion package snake.toolkit.

Loading the .mrd file to retrieve all information can be done using the ismrmd python package, but SNAKE provides convenient dataloaders, which are more efficient, and take cares of managing underlying files access. As we are showcasing the API, we will do things manually here, and use only core SNAKE.

from snake.mrd_utils import CartesianFrameDataLoader

with CartesianFrameDataLoader("example_EPI2D.mrd") as data_loader:
    mask, kspace_data = data_loader.get_kspace_frame(0)

Reconstructing a Single Frame of fully sampled EPI boils down to performing a 3D IFFT:

from scipy.fft import ifftn, ifftshift, fftshift

axes = (-2,-1)
image_data = ifftshift(
    ifftn(fftshift(kspace_data, axes=axes), axes=axes, norm="ortho"), axes=axes
)

# Take the square root sum of squares to get the magnitude image (SSOS)
image_data = np.sqrt(np.sum(np.abs(image_data) ** 2, axis=0))

import matplotlib.pyplot as plt
from snake.toolkit.plotting import axis3dcut

fig, ax = plt.subplots()

axis3dcut(image_data.squeeze().T, None, None, cbar=False, cuts=(0.5,0.5,0.5), ax=ax)
plt.show()