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))