def get_coil_sensitivity_maps():
# get simple coil sensitivity maps (1,4,8,16,32 coil combinations)
params = get_numerical_phantom_params()
dim = params['dim']
dims = (dim, dim)
coil_nums = params['coil_nums']
csms = []
for ii, coil_num in enumerate(coil_nums):
csms.append(
generate_birdcage_sensitivities(dim, number_of_coils=coil_num))
return (csms)
def get_coil_sensitivity_maps():
'''Simulate coil sensitivity maps.
Returns
-------
csms : list
List of coil sensitivity maps (arrays), one for each coil.
'''
# get simple coil sensitivity maps (1,4,8,16,32 coil combinations)
params = get_numerical_phantom_params()
dim = params['dim']
coil_nums = params['coil_nums']
csms = []
for coil_num in coil_nums:
csms.append(
generate_birdcage_sensitivities(dim, number_of_coils=coil_num))
return csms
def setUp(self):
# Simple numerical phantom
self.im0 = bssfp_2d_cylinder(phase_cyc=0)
self.im1 = bssfp_2d_cylinder(phase_cyc=np.pi/2)
self.im2 = bssfp_2d_cylinder(phase_cyc=np.pi)
self.im3 = bssfp_2d_cylinder(phase_cyc=3*np.pi/2)
# Get coil images
self.num_coils = 64
self.coil_sens = generate_birdcage_sensitivities(self.im0.shape[0],number_of_coils=self.num_coils)
self.coil_ims0 = self.im0*self.coil_sens
self.coil_ims1 = self.im1*self.coil_sens
self.coil_ims2 = self.im2*self.coil_sens
self.coil_ims3 = self.im3*self.coil_sens
# Get kspace coil images
self.kspace_coil_ims0 = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(self.coil_ims0,axes=(1,2)),axes=(1,2)),axes=(1,2))
self.kspace_coil_ims1 = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(self.coil_ims1,axes=(1,2)),axes=(1,2)),axes=(1,2))
self.kspace_coil_ims2 = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(self.coil_ims2,axes=(1,2)),axes=(1,2)),axes=(1,2))
self.kspace_coil_ims3 = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(self.coil_ims3,axes=(1,2)),axes=(1,2)),axes=(1,2))
sp.io.savemat('tmp_data.mat',{'pat_py': pat,'data_py': data,'csm_py': csm,'alias_img_py':alias_img,'unmix_grappa_py':unmix_grappa})
#%%
#Reload some modules
reload(show)
reload(sense)
reload(grappa)
reload(simulation)
reload(transform)
reload(coils)
#%%
reload(simulation)
matrix_size = 256
csm = simulation.generate_birdcage_sensitivities(matrix_size)
phan = simulation.phantom(matrix_size)
coil_images = np.tile(phan,(8, 1, 1)) * csm
show.imshow(abs(coil_images),tile_shape=(4,2),colorbar=True)
#%%
#Undersample
reload(simulation)
acc_factor = 2
ref_lines = 16
(data,pat) = simulation.sample_data(phan,csm,acc_factor,ref_lines)
#%%
#Add noise
noise = np.random.standard_normal(data.shape) + 1j*np.random.standard_normal(data.shape)
noise = (5.0/matrix_size)*noise
M0 = 1
PD, T1s, T2s = cylinder_2d(dims=(N, N),
radius=.75,
params={
'T1': T1,
'T2': T2,
'M0': M0
})
# Use a linear off-resonance
fx = np.linspace(min_df, max_df, N)
fy = np.zeros(N)
df, _ = np.meshgrid(fx, fy)
# Create true coil sensitivity maps
csm = generate_birdcage_sensitivities(N, number_of_coils=ncoils)
phi_rf = np.angle(csm)
plt.imshow(phi_rf[0, ...])
plt.title('Coil sensitivity phase (rad)')
plt.colorbar()
plt.show()
plt.imshow(np.abs(csm[0, ...]))
plt.title('Coil sensitivity mag')
plt.colorbar()
plt.show()
csm_mag = np.tile(np.abs(csm), (
npcs,
1,
1,
1,
)).transpose((1, 0, 2, 3))
def create(filename='testdata.h5',
matrix_size=256,
coils=8,
oversampling=2,
repetitions=1,
acceleration=1,
noise_level=0.05):
# Generate the phantom and coil sensitivity maps
phan = simulation.phantom(matrix_size)
csm = simulation.generate_birdcage_sensitivities(matrix_size, coils)
coil_images = np.tile(phan, (coils, 1, 1)) * csm
# Oversample if needed
if oversampling > 1:
padding = round((oversampling * phan.shape[1] - phan.shape[1]) / 2)
phan = np.pad(phan, ((0, 0), (padding, padding)), mode='constant')
csm = np.pad(csm, ((0, 0), (0, 0), (padding, padding)),
mode='constant')
coil_images = np.pad(coil_images, ((0, 0), (0, 0), (padding, padding)),
mode='constant')
# The number of points in x,y,kx,ky
nx = matrix_size
ny = matrix_size
nkx = oversampling * nx
nky = ny
# Open the dataset
dset = ismrmrd.Dataset(filename, "dataset", create_if_needed=True)
# Create the XML header and write it to the file
header = ismrmrd.xsd.ismrmrdHeader()
# Experimental Conditions
exp = ismrmrd.xsd.experimentalConditionsType()
exp.H1resonanceFrequency_Hz = 128000000
header.experimentalConditions = exp
# Acquisition System Information
sys = ismrmrd.xsd.acquisitionSystemInformationType()
sys.receiverChannels = coils
header.acquisitionSystemInformation = sys
# Encoding
encoding = ismrmrd.xsd.encoding()
encoding.trajectory = ismrmrd.xsd.trajectoryType.cartesian
# encoded and recon spaces
efov = ismrmrd.xsd.fieldOfView_mm()
efov.x = oversampling * 256
efov.y = 256
efov.z = 5
rfov = ismrmrd.xsd.fieldOfView_mm()
rfov.x = 256
rfov.y = 256
rfov.z = 5
ematrix = ismrmrd.xsd.matrixSize()
ematrix.x = nkx
ematrix.y = nky
ematrix.z = 1
rmatrix = ismrmrd.xsd.matrixSize()
rmatrix.x = nx
rmatrix.y = ny
rmatrix.z = 1
espace = ismrmrd.xsd.encodingSpaceType()
espace.matrixSize = ematrix
espace.fieldOfView_mm = efov
rspace = ismrmrd.xsd.encodingSpaceType()
rspace.matrixSize = rmatrix
rspace.fieldOfView_mm = rfov
# Set encoded and recon spaces
encoding.encodedSpace = espace
encoding.reconSpace = rspace
# Encoding limits
limits = ismrmrd.xsd.encodingLimitsType()
limits1 = ismrmrd.xsd.limitType()
limits1.minimum = 0
limits1.center = round(ny / 2)
limits1.maximum = ny - 1
limits.kspace_encoding_step_1 = limits1
limits_rep = ismrmrd.xsd.limitType()
limits_rep.minimum = 0
limits_rep.center = round(repetitions / 2)
limits_rep.maximum = repetitions - 1
limits.repetition = limits_rep
limits_rest = ismrmrd.xsd.limitType()
limits_rest.minimum = 0
limits_rest.center = 0
limits_rest.maximum = 0
limits.kspace_encoding_step_0 = limits_rest
limits.slice = limits_rest
limits.average = limits_rest
limits.contrast = limits_rest
limits.kspaceEncodingStep2 = limits_rest
limits.phase = limits_rest
limits.segment = limits_rest
limits.set = limits_rest
encoding.encodingLimits = limits
header.encoding.append(encoding)
dset.write_xml_header(header.toxml('utf-8'))
# Synthesize the k-space data
Ktrue = transform.transform_image_to_kspace(coil_images, (1, 2))
# Create an acquistion and reuse it
acq = ismrmrd.Acquisition()
acq.resize(nkx, coils)
acq.version = 1
acq.available_channels = coils
acq.center_sample = round(nkx / 2)
acq.read_dir[0] = 1.0
acq.phase_dir[1] = 1.0
acq.slice_dir[2] = 1.0
# Initialize an acquisition counter
counter = 0
# Write out a few noise scans
for n in range(32):
noise = noise_level * (np.random.randn(coils, nkx) +
1j * np.random.randn(coils, nkx))
# here's where we would make the noise correlated
acq.scan_counter = counter
acq.clearAllFlags()
acq.setFlag(ismrmrd.ACQ_IS_NOISE_MEASUREMENT)
acq.data[:] = noise
dset.append_acquisition(acq)
counter += 1 # increment the scan counter
# Loop over the repetitions, add noise and write to disk
# simulating a T-SENSE type scan
for rep in range(repetitions):
noise = noise_level * (np.random.randn(coils, nky, nkx) +
1j * np.random.randn(coils, nky, nkx))
# here's where we would make the noise correlated
K = Ktrue + noise
acq.idx.repetition = rep
for acc in range(acceleration):
for line in np.arange(acc, nky, acceleration):
# set some fields in the header
acq.scan_counter = counter
acq.idx.kspace_encode_step_1 = line
acq.clearAllFlags()
if line == 0:
acq.setFlag(ismrmrd.ACQ_FIRST_IN_ENCODE_STEP1)
acq.setFlag(ismrmrd.ACQ_FIRST_IN_SLICE)
acq.setFlag(ismrmrd.ACQ_FIRST_IN_REPETITION)
elif line == nky - 1:
acq.setFlag(ismrmrd.ACQ_LAST_IN_ENCODE_STEP1)
acq.setFlag(ismrmrd.ACQ_LAST_IN_SLICE)
acq.setFlag(ismrmrd.ACQ_LAST_IN_REPETITION)
# set the data and append
acq.data[:] = K[:, line, :]
dset.append_acquisition(acq)
counter += 1
# Clean up
dset.close()
from mr_utils.test_data.phantom import bssfp_2d_cylinder
from mr_utils.recon.ssfp import gs_recon
from mr_utils.utils import sos
from mr_utils import view
if __name__ == '__main__':
# Simple numerical phantom
im0 = bssfp_2d_cylinder(phase_cyc=0)
im1 = bssfp_2d_cylinder(phase_cyc=np.pi / 2)
im2 = bssfp_2d_cylinder(phase_cyc=np.pi)
im3 = bssfp_2d_cylinder(phase_cyc=3 * np.pi / 2)
# Get coil images
num_coils = 64
coil_sens = generate_birdcage_sensitivities(im0.shape[0],
number_of_coils=num_coils)
coil_ims0 = im0 * coil_sens
coil_ims1 = im1 * coil_sens
coil_ims2 = im2 * coil_sens
coil_ims3 = im3 * coil_sens
# Get kspace coil images
kspace_coil_ims0 = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(coil_ims0,
axes=(1,
2)),
axes=(1, 2)),
axes=(1, 2))
kspace_coil_ims1 = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(coil_ims1,
axes=(1,
2)),
axes=(1, 2)),
TR = 10e-3
alpha = np.deg2rad(20)
M0 = 1
lpcs = 8
pcs = np.linspace(0, 2*np.pi, lpcs, endpoint=False)
dim = 64
ncoils = 4
# Set up the tissue and environment nuissances
T1 = .750
T2 = .035
df = 40 # only positive because pcs are (0, 2 pi)
# Get coil sensitivities and coil channels for 1 voxel
xx, yy = int(dim/4), int(dim/3)
csm = generate_birdcage_sensitivities(
dim, number_of_coils=ncoils)[:, xx, yy]
phi_rf = np.angle(csm)
# phi_rf = np.zeros(csm.shape)
csm = np.abs(csm)
# Run the experiment for one voxel, all coils
I = np.zeros((ncoils, lpcs), dtype='complex')
I0 = np.zeros(I.shape, dtype='complex')
phis = np.zeros((ncoils))
for cc in range(ncoils):
for nn in range(lpcs):
# Get center pixel
I[cc, nn] = csm[cc]*ssfp(
T1, T2, TR, alpha, df, pcs[nn], M0,
phi_rf=phi_rf[cc])
def create(filename='testdata.h5', matrix_size=256, coils=8, oversampling=2, repetitions=1, acceleration=1, noise_level=0.05):
# Generate the phantom and coil sensitivity maps
phan = simulation.phantom(matrix_size)
csm = simulation.generate_birdcage_sensitivities(matrix_size, coils)
coil_images = np.tile(phan,(coils, 1, 1)) * csm
# Oversample if needed
if oversampling>1:
padding = (oversampling*phan.shape[1] - phan.shape[1])/2
phan = np.pad(phan,((0,0),(padding,padding)),mode='constant')
csm = np.pad(csm,((0,0),(0,0),(padding,padding)),mode='constant')
coil_images = np.pad(coil_images,((0,0),(0,0),(padding,padding)),mode='constant')
# The number of points in x,y,kx,ky
nx = matrix_size
ny = matrix_size
nkx = oversampling*nx
nky = ny
# Open the dataset
dset = ismrmrd.Dataset(filename, "dataset", create_if_needed=True)
# Create the XML header and write it to the file
header = ismrmrd.xsd.ismrmrdHeader()
# Experimental Conditions
exp = ismrmrd.xsd.experimentalConditionsType()
exp.H1resonanceFrequency_Hz = 128000000
header.experimentalConditions = exp
# Acquisition System Information
sys = ismrmrd.xsd.acquisitionSystemInformationType()
sys.receiverChannels = coils
header.acquisitionSystemInformation = sys
# Encoding
encoding = ismrmrd.xsd.encoding()
encoding.trajectory = ismrmrd.xsd.trajectoryType.cartesian
# encoded and recon spaces
efov = ismrmrd.xsd.fieldOfView_mm()
efov.x = oversampling*256
efov.y = 256
efov.z = 5
rfov = ismrmrd.xsd.fieldOfView_mm()
rfov.x = 256
rfov.y = 256
rfov.z = 5
ematrix = ismrmrd.xsd.matrixSize()
ematrix.x = nkx
ematrix.y = nky
ematrix.z = 1
rmatrix = ismrmrd.xsd.matrixSize()
rmatrix.x = nx
rmatrix.y = ny
rmatrix.z = 1
espace = ismrmrd.xsd.encodingSpaceType()
espace.matrixSize = ematrix
espace.fieldOfView_mm = efov
rspace = ismrmrd.xsd.encodingSpaceType()
rspace.matrixSize = rmatrix
rspace.fieldOfView_mm = rfov
# Set encoded and recon spaces
encoding.encodedSpace = espace
encoding.reconSpace = rspace
# Encoding limits
limits = ismrmrd.xsd.encodingLimitsType()
limits1 = ismrmrd.xsd.limitType()
limits1.minimum = 0
limits1.center = ny/2
limits1.maximum = ny - 1
limits.kspace_encoding_step_1 = limits1
limits_rep = ismrmrd.xsd.limitType()
limits_rep.minimum = 0
limits_rep.center = repetitions / 2
limits_rep.maximum = repetitions - 1
limits.repetition = limits_rep
limits_rest = ismrmrd.xsd.limitType()
limits_rest.minimum = 0
limits_rest.center = 0
limits_rest.maximum = 0
limits.kspace_encoding_step_0 = limits_rest
limits.slice = limits_rest
limits.average = limits_rest
limits.contrast = limits_rest
limits.kspaceEncodingStep2 = limits_rest
limits.phase = limits_rest
limits.segment = limits_rest
limits.set = limits_rest
encoding.encodingLimits = limits
header.encoding.append(encoding)
dset.write_xml_header(header.toxml('utf-8'))
# Synthesize the k-space data
Ktrue = transform.transform_image_to_kspace(coil_images,(1,2))
# Create an acquistion and reuse it
acq = ismrmrd.Acquisition()
acq.resize(nkx, coils)
acq.version = 1
acq.available_channels = coils
acq.center_sample = nkx/2
acq.read_dir[0] = 1.0
acq.phase_dir[1] = 1.0
acq.slice_dir[2] = 1.0
# Initialize an acquisition counter
counter = 0
# Write out a few noise scans
for n in range(32):
noise = noise_level * (np.random.randn(coils, nkx) + 1j * np.random.randn(coils, nkx))
# here's where we would make the noise correlated
acq.scan_counter = counter
acq.clearAllFlags()
acq.setFlag(ismrmrd.ACQ_IS_NOISE_MEASUREMENT)
acq.data[:] = noise
dset.append_acquisition(acq)
counter += 1 # increment the scan counter
# Loop over the repetitions, add noise and write to disk
# simulating a T-SENSE type scan
for rep in range(repetitions):
noise = noise_level * (np.random.randn(coils, nky, nkx) + 1j * np.random.randn(coils, nky, nkx))
# here's where we would make the noise correlated
K = Ktrue + noise
acq.idx.repetition = rep
for acc in range(acceleration):
for line in np.arange(acc,nky,acceleration):
# set some fields in the header
acq.scan_counter = counter
acq.idx.kspace_encode_step_1 = line
acq.clearAllFlags()
if line == 0:
acq.setFlag(ismrmrd.ACQ_FIRST_IN_ENCODE_STEP1)
acq.setFlag(ismrmrd.ACQ_FIRST_IN_SLICE)
acq.setFlag(ismrmrd.ACQ_FIRST_IN_REPETITION)
elif line == nky - 1:
acq.setFlag(ismrmrd.ACQ_LAST_IN_ENCODE_STEP1)
acq.setFlag(ismrmrd.ACQ_LAST_IN_SLICE)
acq.setFlag(ismrmrd.ACQ_LAST_IN_REPETITION)
# set the data and append
acq.data[:] = K[:,line,:]
dset.append_acquisition(acq)
counter += 1
# Clean up
dset.close()
# -*- coding: utf-8 -*-
#%%
#Basic setup
import time
import numpy as np
from ismrmrdtools import simulation, coils, show
matrix_size = 256
csm = simulation.generate_birdcage_sensitivities(matrix_size)
phan = simulation.phantom(matrix_size)
coil_images = phan[np.newaxis, :, :] * csm
show.imshow(abs(coil_images), tile_shape=(4, 2))
tstart = time.time()
(csm_est, rho) = coils.calculate_csm_walsh(coil_images)
print("Walsh coil estimation duration: {}s".format(time.time() - tstart))
combined_image = np.sum(csm_est * coil_images, axis=0)
show.imshow(abs(csm_est), tile_shape=(4, 2), scale=(0, 1))
show.imshow(abs(combined_image), scale=(0, 1))
tstart = time.time()
(csm_est2, rho2) = coils.calculate_csm_inati_iter(coil_images)
print("Inati coil estimation duration: {}s".format(time.time() - tstart))
combined_image2 = np.sum(csm_est2 * coil_images, axis=0)
show.imshow(abs(csm_est2), tile_shape=(4, 2), scale=(0, 1))
show.imshow(abs(combined_image2), scale=(0, 1))
