Slice grappa with in plane acceleration¶
Author: Zimu Huo¶
Date: 05.2022¶
In this case, the sms data is acquired with slice fatctor of ns, and in plane factor of R. To unfold the aliasing, one could arrange the data in the sense/grappa fashion or as two separate steps. Here, the later one is shown.
1. the slice grappa is used to separate the slice
2. the conventional grappa is then used along with reference data to unfold each individual slice.
References
[1]
Author: Setsompop K et al.
Title: Blipped-controlled aliasing in parallel imaging for simultaneous multislice echo planar imaging with reduced g-factor penalty
Link: https://onlinelibrary.wiley.com/doi/10.1002/mrm.23097
In [1]:
import sys
sys.path.insert(1, '../')
import matplotlib.pyplot as plt
import numpy as np
from scipy import io
import util.simulator as simulate
from util.coil import *
from util.fft import *
import util.mask as undersample
from util.sg import *
from util.grappa import *
In [2]:
numSlice = 4
R = 8 # sms factor 4, grappa factor 2
slice1 = np.load("../lib/slice1_grappa1.npy")
slice2 = np.load("../lib/slice2_grappa1.npy")
slice3 = np.load("../lib/slice3_grappa1.npy")
slice4 = np.load("../lib/slice4_grappa1.npy")
data = np.concatenate((slice1[...,None], slice2[...,None], slice3[...,None], slice4[...,None]), -1)[...,:numSlice]
rawImage = ifft2c(data)
fovHeight, fovWidth, numCoil, _ = rawImage.shape
In [3]:
rawData = np.zeros(rawImage.shape, dtype = complex)
for sli in range (numSlice):
rawData[:,:,:,sli] = fft2c(rawImage[:,:,:,sli])
In [4]:
cycle = np.arange(0,1,1/numSlice) * 2* np.pi
numAccq = int(numSlice*fovHeight/R)
In [5]:
shift = cycle*numAccq/(2*np.pi)
dataR = fft2c(simulate.multiSliceCAIPI(rawImage, cycle, R))
In [6]:
ncx = 64
ncy = 64
acsshift = cycle*int(numSlice* ncy/R)/(2*np.pi)
acsK = simulate.acs(rawData, (ncy, ncx))
acsK = acsK[::2]
acsIm = ifft2c(acsK)
calib = fft2c(simulate.singleSliceFov(acsIm,acsshift))
In [7]:
fig = plt.figure(figsize=(12, 12), dpi=80)
plt.subplot(121)
plt.imshow(np.abs(rsos(ifft2c(dataR))), cmap = "gray")
plt.subplot(122)
plt.imshow(np.abs(stitch(rsos(ifft2c(calib)),1)), cmap = "gray")
Out[7]:
<matplotlib.image.AxesImage at 0x7f9e51a59460>
In [8]:
recon = sg(dataR,calib)
In [9]:
fig = plt.figure(figsize=(8, 6), dpi=80)
fig.subplots_adjust(wspace=0, hspace=0)
plt.subplot(211)
plt.imshow(np.abs(stitch(rsos(rawImage), 1)), cmap = "gray")
plt.subplot(212)
plt.imshow(np.abs(stitch(rsos(ifft2c(recon)),1)), cmap = "gray")
Out[9]:
<matplotlib.image.AxesImage at 0x7f9e508fe550>
In [10]:
acsK = simulate.acs(rawData, (32, 32))
acsIm = ifft2c(acsK)
acsshift = cycle*(32*2/4)/(2*np.pi)
acsIm = simulate.singleSliceFov(acsIm, acsshift)
acs = fft2c(acsIm)
In [11]:
recon2 = np.zeros([fovHeight, fovWidth, numCoil, numSlice], dtype = complex)
for sli in range(numSlice):
tmp = np.zeros([fovHeight, fovWidth, numCoil], dtype = complex)
tmp[::2] = recon[...,sli]
recon2[...,sli] = grappa(tmp, acs[...,sli], combine = False)
In [12]:
fig = plt.figure(figsize=(8, 6), dpi=80)
plt.subplot(211)
plt.imshow(np.abs(stitch(rsos(rawImage), 1)), cmap = "gray")
plt.subplot(212)
plt.imshow(np.abs(stitch(rsos((recon2)),1)), cmap = "gray")
Out[12]:
<matplotlib.image.AxesImage at 0x7f9e509ec1f0>
In [13]:
reconshift = cycle*int(numSlice* fovHeight/R)/(2*np.pi)
recon3 = simulate.singleSliceFov((recon2), - reconshift)
fig = plt.figure(figsize=(8, 6), dpi=80)
plt.subplot(211)
plt.imshow(np.abs(stitch(rsos(rawImage), 1)), cmap = "gray")
plt.subplot(212)
plt.imshow(np.abs(stitch(rsos((recon3)),1)), cmap = "gray")
Out[13]:
<matplotlib.image.AxesImage at 0x7f9e51f6bd30>
In [ ]: