def train_step(model, data, device):
input, target, mean, std, mean_image, std_image, mask = data
input = input.to(device)
mask = mask.to(device)
target = target.to(device)
output = model(input.permute(0, 3, 1, 2)).permute(0, 2, 3, 1)
# Projection to consistent K-space
output = input * mask + (1-mask) * output
# Consistent K-space loss (with the normalized output and target)
loss_k_consistent = F.l1_loss(output, target)
mean = mean.to(device)
std = std.to(device)
target = transforms.unnormalize(target, mean, std)
output = transforms.unnormalize(output, mean, std)
output_image = transforms.ifft2(output)
target_image = transforms.ifft2(target)
output_image = transforms.complex_center_crop(output_image, (320, 320))
output_image = transforms.complex_abs(output_image)
target_image = transforms.complex_center_crop(target_image, (320, 320))
target_image = transforms.complex_abs(target_image)
mean_image = mean_image.unsqueeze(1).unsqueeze(2).to(device)
std_image = std_image.unsqueeze(1).unsqueeze(2).to(device)
output_image = transforms.normalize(output_image, mean_image, std_image)
target_image = transforms.normalize(target_image, mean_image, std_image)
target_image = target_image.clamp(-6, 6)
# Consistent image loss (with the unnormalized output and target)
loss_image = F.l1_loss(output_image, target_image)
loss = loss_k_consistent + loss_image
return loss
def __call__(self, kspace, target, attrs, fname, slice):
"""
Args:
kspace (numpy.array): Input k-space of shape (num_coils, rows, cols, 2) for multi-coil
data or (rows, cols, 2) for single coil data.
target (numpy.array): Target image
attrs (dict): Acquisition related information stored in the HDF5 object.
fname (str): File name
slice (int): Serial number of the slice.
Returns:
(tuple): tuple containing:
image (torch.Tensor): Zero-filled input image.
target (torch.Tensor): Target image converted to a torch Tensor.
mean (float): Mean value used for normalization.
std (float): Standard deviation value used for normalization.
norm (float): L2 norm of the entire volume.
"""
target_inference = transforms.to_tensor(target)
kspace = transforms.to_tensor(kspace)
target = transforms.ifft2(kspace)
# Apply mask
seed = None if not self.use_seed else tuple(map(ord, fname))
if self.use_mask:
mask = transforms.get_mask(kspace, self.mask_func, seed)
masked_kspace = mask * kspace
else:
masked_kspace = kspace
image = transforms.ifft2(masked_kspace)
image_crop = transforms.complex_center_crop(
image, (self.resolution, self.resolution))
_, mean, std = transforms.normalize_instance_complex(image_crop,
eps=1e-11)
image_abs = transforms.complex_abs(image_crop)
image_abs, mean_abs, std_abs = transforms.normalize_instance(image_abs,
eps=1e-11)
image = transforms.normalize(image, mean, std)
target_image_complex_norm = transforms.normalize(target, mean, std)
target_kspace_train = transforms.fft2(target_image_complex_norm)
target = transforms.complex_center_crop(target, (320, 320))
target = transforms.complex_abs(target)
target_train = target
if RENORM:
target_train = transforms.normalize(target_train, mean_abs,
std_abs)
if CLAMP:
image = image.clamp(-6, 6)
target_train = target_train.clamp(-6, 6)
return image, target_train, target_kspace_train, mean, std, mask, mean_abs, std_abs, target_inference, attrs[
'max'], attrs['norm'].astype(np.float32)
def forward(self, masked_kspace, mask):
sens_maps = self.sens_net(masked_kspace, mask)
kspace_pred = masked_kspace.clone()
for cascade in self.cascades:
kspace_pred = cascade(kspace_pred, masked_kspace, mask, sens_maps)
return T.root_sum_of_squares(T.complex_abs(T.ifft2(kspace_pred)),
dim=1)
def __call__(self, k_space, mask, target, attrs, f_name, slice):
"""
Args:
kspace (numpy.array): Input k-space of shape (num_coils, rows, cols, 2) for multi-coil
data or (rows, cols, 2) for single coil data.
mask (numpy.array): Mask from the test dataset
target (numpy.array): Target image
attrs (dict): Acquisition related information stored in the HDF5 object.
fname (str): File name
slice (int): Serial number of the slice.
Returns:
(tuple): tuple containing:
k_space (torch.Tensor): k-space(resolution x resolution x 2)
target (torch.Tensor): Target image converted to a torch Tensor.
fname (str): File name
slice (int): Serial number of the slice.
"""
k_space = transforms.to_tensor(k_space)
full_image = transforms.ifft2(k_space)
cropped_image = transforms.complex_center_crop(
full_image, (self.resolution, self.resolution))
k_space = transforms.fft2(cropped_image)
# Normalize input
cropped_image, mean, std = transforms.normalize_instance(cropped_image,
eps=1e-11)
cropped_image = cropped_image.clamp(-6, 6)
# Normalize target
target = transforms.to_tensor(target)
target = transforms.center_crop(target,
(self.resolution, self.resolution))
target = transforms.normalize(target, mean, std, eps=1e-11)
target = target.clamp(-6, 6)
return k_space, target, f_name, slice
def __call__(self, kspace, target, attrs, fname, slice):
"""
Args:
kspace (numpy.array): Input k-space of shape (num_coils, rows, cols, 2) for multi-coil
data or (rows, cols, 2) for single coil data.
target (numpy.array): Target image
attrs (dict): Acquisition related information stored in the HDF5 object.
fname (str): File name
slice (int): Serial number of the slice.
Returns:
(tuple): tuple containing:
image (torch.Tensor): Zero-filled input image.
target (torch.Tensor): Target image converted to a torch Tensor.
mean (float): Mean value used for normalization.
std (float): Standard deviation value used for normalization.
norm (float): L2 norm of the entire volume.
"""
kspace = transforms.to_tensor(kspace)
# Apply mask
seed = None if not self.use_seed else tuple(map(ord, fname))
if self.use_mask:
mask = transforms.get_mask(kspace, self.mask_func, seed)
masked_kspace = mask * kspace
else:
masked_kspace = kspace
image = transforms.ifft2(masked_kspace)
_, mean_image, std_image = transforms.normalize_instance(image, eps=1e-11)
masked_kspace, mean, std = transforms.normalize_instance_complex(masked_kspace)
kspace = transforms.normalize(kspace, mean, std)
return masked_kspace, kspace, mean, std, mean_image, std_image, mask
def __call__(self, kspace, target, challenge, fname, slice_index):
original_kspace = transforms.to_tensor(kspace)
if self.reduce:
original_kspace = reducedimension(original_kspace, self.resolution)
# Apply mask
seed = None if not self.use_seed else tuple(map(ord, fname))
masked_kspace, mask = transforms.apply_mask(original_kspace,
self.mask_func, seed)
# Inverse Fourier Transform to get zero filled solution
image = transforms.ifft2(masked_kspace)
# Crop input image
image = transforms.complex_center_crop(
image, (self.resolution, self.resolution))
# Absolute value
image = transforms.complex_abs(image)
# Apply Root-Sum-of-Squares if multicoil data
if challenge == 'multicoil':
image = transforms.root_sum_of_squares(image)
# Normalize input
image, mean, std = transforms.normalize_instance(image, eps=1e-11)
target = transforms.to_tensor(target)
# Normalize target
target = transforms.normalize(target, mean, std, eps=1e-11)
target = target.clamp(-6, 6)
if self.polar:
original_kspace = cartesianToPolar(original_kspace)
masked_kspace = cartesianToPolar(masked_kspace)
return original_kspace, masked_kspace, mask, target, fname, slice_index
def nufft_adjoint(input, coord, oshape, oversamp=1.25, width=4.0, n=128, device='cuda'):
ndim = coord.shape[-1]
beta = numpy.pi * (((width / oversamp) * (oversamp - 0.5)) ** 2 - 0.8) ** 0.5
oshape = list(oshape)
os_shape = _get_oversamp_shape(oshape, ndim, oversamp)
# Gridding
coord = _scale_coord(coord, oshape, oversamp, device)
kernel = _get_kaiser_bessel_kernel(n, width, beta, coord.dtype, device)
output = interp.gridding(input, os_shape, width, kernel, coord, device)
# IFFT
output = output.permute(0, 2, 3, 1)
# plt.figure()
# plt.imshow(print_complex_kspace_tensor(output[0].detach().cpu()), cmap='gray')
# plt.show()
output = transforms.ifft2(output)
# plt.figure()
# plt.imshow(print_complex_image_tensor(output[0].detach().cpu()), cmap='gray')
# plt.show()
# Crop
output = output.permute(0, 3, 1, 2)
output = util.resize(output, oshape, device=device)
output *= util.prod(os_shape[-ndim:]) / util.prod(oshape[-ndim:]) ** 0.5
# Apodize
output = _apodize(output, ndim, oversamp, width, beta, device)
return output.permute(0, 2, 3, 1)
def __call__(self, ksp, sens, mask, fname, slice):
mask = torch.from_numpy(mask)
mask = (torch.stack((mask, mask), dim=-1)).float()
ksp_cmplx = ksp[:, :, ::2] + 1j * ksp[:, :, 1::2]
sens_t = T.to_tensor(sens)
ksp_t = T.to_tensor(ksp_cmplx)
ksp_us = ksp_t.permute(2, 0, 1, 3)
img_us = T.ifft2(ksp_us)
img_us_sens = T.combine_all_coils(img_us, sens_t)
pha_us = T.phase(img_us_sens)
mag_us = T.complex_abs(img_us_sens)
mag_us_pad = T.pad(mag_us, [256, 256])
pha_us_pad = T.pad(pha_us, [256, 256])
ksp_us_np = ksp
ksp_us_np = ksp_us_np[:, :, ::2] + 1j * ksp_us_np[:, :, 1::2]
img_us_np = T.zero_filled_reconstruction(ksp_us_np)
return mag_us_pad / mag_us_pad.max(
), pha_us_pad, ksp_us / mag_us_pad.max(
), sens_t, mask, fname.name, slice, img_us_np.max()
def __call__(self, kspace, target, attrs, fname, slice):
"""
Args:
kspace (numpy.Array): k-space measurements
target (numpy.Array): Target image
attrs (dict): Acquisition related information stored in the HDF5 object
fname (pathlib.Path): Path to the input file
slice (int): Serial number of the slice
Returns:
(tuple): tuple containing:
image (torch.Tensor): Normalized zero-filled input image
mean (float): Mean of the zero-filled image
std (float): Standard deviation of the zero-filled image
fname (pathlib.Path): Path to the input file
slice (int): Serial number of the slice
"""
kspace = transforms.to_tensor(kspace)
image = transforms.ifft2(kspace)
image = transforms.complex_center_crop(
image, (self.resolution, self.resolution))
# Apply Root-Sum-of-Squares if multicoil data
if self.which_challenge == 'multicoil':
image = transforms.root_sum_of_squares(image)
image = transforms.complex_abs(image)
image, mean, std = transforms.normalize_instance(image, eps=1e-11)
image = image.clamp(-6, 6)
kspace = transforms.rfft2(image)
return kspace, mean, std, fname, slice
def __call__(self, kspace, target, attrs, fname, slice):
"""
Args:
kspace (numpy.Array): k-space measurements
target (numpy.Array): Target image
attrs (dict): Acquisition related information stored in the HDF5 object
fname (pathlib.Path): Path to the input file
slice (int): Serial number of the slice
Returns:
(tuple): tuple containing:
image (torch.Tensor): Normalized zero-filled input image
mean (float): Mean of the zero-filled image
std (float): Standard deviation of the zero-filled image
fname (pathlib.Path): Path to the input file
slice (int): Serial number of the slice
"""
kspace = transforms.to_tensor(kspace)
if self.mask_func is not None:
seed = tuple(map(ord, fname))
masked_kspace, _ = transforms.apply_mask(kspace, self.mask_func, seed)
else:
masked_kspace = kspace
# Inverse Fourier Transform to get zero filled solution
image = transforms.ifft2(masked_kspace)
# Crop input image
image = transforms.complex_center_crop(image, (self.resolution, self.resolution))
# Absolute value
image = transforms.complex_abs(image)
# Apply Root-Sum-of-Squares if multicoil data
if self.which_challenge == 'multicoil':
image = transforms.root_sum_of_squares(image)
# Normalize input
image, mean, std = transforms.normalize_instance(image)
image = image.clamp(-6, 6)
return image, mean, std, fname, slice
def data_for_training(rawdata, sensitivity, mask_func, norm=True):
''' normalize each slice using complex absolute max value'''
rawdata = T.to_tensor(np.complex64(rawdata.transpose(2, 0, 1)))
sensitivity = T.to_tensor(sensitivity.transpose(2, 0, 1))
coils, Ny, Nx, ps = rawdata.shape
# shift data
shift_kspace = rawdata
x, y = np.meshgrid(np.arange(1, Nx + 1), np.arange(1, Ny + 1))
adjust = (-1)**(x + y)
shift_kspace = T.ifftshift(shift_kspace, dim=(
-3, -2)) * torch.from_numpy(adjust).view(1, Ny, Nx, 1).float()
# apply masks
shape = np.array(shift_kspace.shape)
shape[:-3] = 1
mask = mask_func(shape)
mask = T.ifftshift(mask) # shift mask
# undersample
masked_kspace = torch.where(mask == 0, torch.Tensor([0]), shift_kspace)
masks = mask.repeat(coils, Ny, 1, ps)
img_gt, img_und = T.ifft2(shift_kspace), T.ifft2(masked_kspace)
if norm:
# perform k space raw data normalization
# during inference there is no ground truth image so use the zero-filled recon to normalize
norm = T.complex_abs(img_und).max()
if norm < 1e-6: norm = 1e-6
# normalized recon
else:
norm = 1
# normalize data to learn more effectively
img_gt, img_und = img_gt / norm, img_und / norm
rawdata_und = masked_kspace / norm # faster
sense_gt = cobmine_all_coils(img_gt, sensitivity)
sense_und = cobmine_all_coils(img_und, sensitivity)
return sense_und, sense_gt, rawdata_und, masks, sensitivity
def forward_adjoint_helper(device, hparams, mask_func, kspace, target=None):
masked_kspace, _ = apply_mask(device, mask_func, kspace, hparams.seed)
if not torch.is_tensor(masked_kspace):
kspace_tensor = transforms.to_tensor(masked_kspace)
else:
kspace_tensor = masked_kspace
image = transforms.ifft2(kspace_tensor)
image, image_abs, _, _, _ = resize(hparams, image, target)
return image, image_abs
def k_space_to_image_with_mask(kspace, mask_func=None, seed=None):
#use_seed = False
#seed = None if not use_seed else tuple(map(ord, fname))
#seed = 42
#print(fname)
#kspace = transforms.to_tensor(kspace)
if mask_func:
masked_kspace, mask = transforms.apply_mask(kspace, mask_func, seed)
# Inverse Fourier Transform to get zero filled solution
image = transforms.ifft2(masked_kspace)
else:
image = transforms.ifft2(kspace)
image = transforms.complex_abs(image)
image = transforms.center_crop(image, (320, 320))
# Normalize input
image, mean, std = transforms.normalize_instance(image, eps=1e-11)
image = image.clamp(-6, 6)
return image
def __call__(self, kspace, mask, target, attrs, fname, slice):
"""
Args:
kspace (numpy.array): Input k-space of shape (num_coils, rows, cols, 2) for multi-coil
data or (rows, cols, 2) for single coil data.
mask (numpy.array): Mask from the test dataset
target (numpy.array): Target image
attrs (dict): Acquisition related information stored in the HDF5 object.
fname (str): File name
slice (int): Serial number of the slice.
Returns:
(tuple): tuple containing:
image (torch.Tensor): Zero-filled input image.
target (torch.Tensor): Target image converted to a torch Tensor.
mean (float): Mean value used for normalization.
std (float): Standard deviation value used for normalization.
"""
kspace = transforms.to_tensor(kspace)
# Apply mask
if self.mask_func:
seed = None if not self.use_seed else tuple(map(ord, fname))
masked_kspace, mask = transforms.apply_mask(
kspace, self.mask_func, seed)
else:
masked_kspace = kspace
# Inverse Fourier Transform to get zero filled solution
image = transforms.ifft2(masked_kspace)
# Crop input image to given resolution if larger
smallest_width = min(self.resolution, image.shape[-2])
smallest_height = min(self.resolution, image.shape[-3])
if target is not None:
smallest_width = min(smallest_width, target.shape[-1])
smallest_height = min(smallest_height, target.shape[-2])
crop_size = (smallest_height, smallest_width)
image = transforms.complex_center_crop(image, crop_size)
# Absolute value
image = transforms.complex_abs(image)
# Apply Root-Sum-of-Squares if multicoil data
if self.which_challenge == 'multicoil':
image = transforms.root_sum_of_squares(image)
# Normalize input
image, mean, std = transforms.normalize_instance(image, eps=1e-11)
image = image.clamp(-6, 6)
# Normalize target
if target is not None:
target = transforms.to_tensor(target)
target = transforms.center_crop(target, crop_size)
target = transforms.normalize(target, mean, std, eps=1e-11)
target = target.clamp(-6, 6)
else:
target = torch.Tensor([0])
return image, target, mean, std, fname, slice
def data_for_training(rawdata, sensitivity, mask, norm=True):
''' normalize each slice using complex absolute max value'''
coils, Ny, Nx, ps = rawdata.shape
# shift data
shift_kspace = rawdata
x, y = np.meshgrid(np.arange(1, Nx + 1), np.arange(1, Ny + 1))
adjust = (-1)**(x + y)
shift_kspace = T.ifftshift(shift_kspace, dim=(
-3, -2)) * torch.from_numpy(adjust).view(1, Ny, Nx, 1).float()
#masked_kspace = torch.where(mask == 0, torch.Tensor([0]), shift_kspace)
mask = T.ifftshift(mask)
mask = mask.unsqueeze(0).unsqueeze(-1).float()
mask = mask.repeat(coils, 1, 1, ps)
masked_kspace = shift_kspace * mask
img_gt, img_und = T.ifft2(shift_kspace), T.ifft2(masked_kspace)
if norm:
# perform k space raw data normalization
# during inference there is no ground truth image so use the zero-filled recon to normalize
norm = T.complex_abs(img_und).max()
if norm < 1e-6: norm = 1e-6
# normalized recon
else:
norm = 1
# normalize data to learn more effectively
img_gt, img_und = img_gt / norm, img_und / norm
rawdata_und = masked_kspace / norm # faster
sense_gt = cobmine_all_coils(img_gt, sensitivity)
sense_und = cobmine_all_coils(img_und, sensitivity)
sense_und_kspace = T.fft2(sense_und)
return sense_und, sense_gt, sense_und_kspace, rawdata_und, mask, sensitivity
def imagenormalize(data, divisor=None):
"""kspace generated by normalizing image space"""
#getting image from masked data
image = transforms.ifft2(data)
#normalizing the image
nimage, divisor = normalize(image, divisor)
#getting kspace data from normalized image
data = transforms.ifftshift(image, dim=(-3, -2))
data = torch.fft(data, 2)
data = transforms.fftshift(data, dim=(-3, -2))
return data, divisor
def __call__(self, kspace, target, attrs, fname, slice):
kspace_rect = transforms.to_tensor(kspace) ##rectangular kspace
image_rect = transforms.ifft2(kspace_rect) ##rectangular FS image
image_square = transforms.complex_center_crop(
image_rect,
(self.resolution, self.resolution)) ##cropped to FS square image
kspace_square = self.c3object.apply(
transforms.fft2(image_square)) #* 10000 ##kspace of square iamge
if self.augmentation:
kspace_square = self.augmentation.apply(kspace_square)
image_square = ifft_c3(kspace_square)
# Apply mask
seed = None if not self.use_seed else tuple(map(ord, fname))
masked_kspace_square, mask = transforms.apply_mask(
kspace_square, self.mask_func, seed) ##ZF square kspace
# Inverse Fourier Transform to get zero filled solution
# image = transforms.ifft2(masked_kspace)
image_square_us = ifft_c3(
masked_kspace_square) ## US square complex image
# Crop input image
# image = transforms.complex_center_crop(image, (self.resolution, self.resolution))
# Absolute value
# image = transforms.complex_abs(image)
image_square_abs = transforms.complex_abs(
image_square_us) ## US square real image
# Apply Root-Sum-of-Squares if multicoil data
# if self.which_challenge == 'multicoil':
# image = transforms.root_sum_of_squares(image)
# Normalize input
# image, mean, std = transforms.normalize_instance(image, eps=1e-11)
_, mean, std = transforms.normalize_instance(image_square_abs,
eps=1e-11)
# image = image.clamp(-6, 6)
# target = transforms.to_tensor(target)
target = image_square.permute(2, 0, 1)
# Normalize target
# target = transforms.normalize(target, mean, std, eps=1e-11)
# target = target.clamp(-6, 6)
# return image, target, mean, std, attrs['norm'].astype(np.float32)
# return masked_kspace_square.permute((2,0,1)), image, image_square.permute(2,0,1), mean, std, attrs['norm'].astype(np.float32)
# ksp, zf, target, me, st, nor
return masked_kspace_square.permute((2,0,1)), image_square_us.permute((2,0,1)), \
target, \
mean, std, attrs['norm'].astype(np.float32)
def test_ifft2(shape):
shape = shape + [2]
input = create_input(shape)
out_torch = transforms.ifft2(input).numpy()
out_torch = out_torch[..., 0] + 1j * out_torch[..., 1]
input_numpy = utils.tensor_to_complex_np(input)
input_numpy = np.fft.ifftshift(input_numpy, (-2, -1))
out_numpy = np.fft.ifft2(input_numpy, norm='ortho')
out_numpy = np.fft.fftshift(out_numpy, (-2, -1))
assert np.allclose(out_torch, out_numpy)
def mnormalize(masked_kspace):
#getting image from masked data
image = transforms.ifft2(masked_kspace)
#normalizing the image
nimage, mean, std = transforms.normalize_instance(image, eps=1e-11)
#getting kspace data from normalized image
maksed_kspace_fni = transforms.ifftshift(nimage, dim=(-3, -2))
maksed_kspace_fni = torch.fft(maksed_kspace_fni, 2)
maksed_kspace_fni = transforms.fftshift(maksed_kspace_fni, dim=(-3, -2))
maksed_kspace_fni, mean, std = transforms.normalize_instance(masked_kspace,
eps=1e-11)
return maksed_kspace_fni, mean, std
def __call__(self, kspace, target, attrs, fname, slice):
"""
Args:
kspace (numpy.array): Input k-space of shape (num_coils, rows, cols, 2) for multi-coil
data or (rows, cols, 2) for single coil data.
target (numpy.array): Target image
attrs (dict): Acquisition related information stored in the HDF5 object.
fname (str): File name
slice (int): Serial number of the slice.
Returns:
(tuple): tuple containing:
image (torch.Tensor): Zero-filled input image.
target (torch.Tensor): Target image converted to a torch Tensor.
mean (float): Mean value used for normalization.
std (float): Standard deviation value used for normalization.
norm (float): L2 norm of the entire volume.
"""
kspace = transforms.to_tensor(kspace)
# Apply mask
seed = None if not self.use_seed else tuple(map(ord, fname))
if self.use_mask:
mask = transforms.get_mask(kspace, self.mask_func, seed)
masked_kspace = mask * kspace
else:
masked_kspace = kspace
# Inverse Fourier Transform to get zero filled solution
image = transforms.ifft2(masked_kspace)
# Crop input image
image = transforms.complex_center_crop(
image, (self.resolution, self.resolution))
# Absolute value
image = transforms.complex_abs(image)
# Apply Root-Sum-of-Squares if multicoil data
if self.which_challenge == 'multicoil':
image = transforms.root_sum_of_squares(image)
# Normalize input
image, mean, std = transforms.normalize_instance(image, eps=1e-11)
if CLAMP:
image = image.clamp(-6, 6)
# Normalize target
target = transforms.to_tensor(target)
target_train = transforms.normalize(target, mean, std, eps=1e-11)
if CLAMP:
target_train = target_train.clamp(
-6,
6) # Return target (for viz) and target_clamped (for training)
return image, target_train, mean, std, attrs['norm'].astype(
np.float32), target
def __call__(self, kspace, target, attrs, fname, slice):
"""
Args:
kspace (numpy.Array): k-space measurements
target (numpy.Array): Target image
attrs (dict): Acquisition related information stored in the HDF5 object
fname (pathlib.Path): Path to the input file
slice (int): Serial number of the slice
Returns:
(tuple): tuple containing:
image (torch.Tensor): Normalized zero-filled input image
mean (float): Mean of the zero-filled image
std (float): Standard deviation of the zero-filled image
fname (pathlib.Path): Path to the input file
slice (int): Serial number of the slice
"""
kspace = transforms.to_tensor(kspace)
if self.mask_func is not None:
seed = tuple(map(ord, fname))
masked_kspace, _ = transforms.apply_mask(kspace, self.mask_func, seed)
else:
masked_kspace = kspace
# Inverse Fourier Transform to get zero filled solution
image = transforms.ifft2(masked_kspace)
# Crop input image
image = transforms.complex_center_crop(image, (self.resolution, self.resolution))
# Absolute value
image = transforms.complex_abs(image)
# Apply Root-Sum-of-Squares if multicoil data
if self.which_challenge == 'multicoil':
image = transforms.root_sum_of_squares(image)
# Normalize input
image, mean, std = transforms.normalize_instance(image)
image = image.clamp(-6, 6)
# difference between kspace actual and target dim
extra = int(masked_kspace.shape[1] - self.kspace_x)
# clip kspace at input dim
if extra > 0:
masked_kspace = masked_kspace[:, (extra//2):-(extra//2), :]
# zero pad if necessary
elif extra < 0:
empty_kspace = torch.zeros((masked_kspace.shape[0], self.kspace_x, masked_kspace.shape[2]))
empty_kspace[:, -(extra//2):(extra//2), :] = masked_kspace
masked_kspace = empty_kspace
#TODO return mask as well for exclusive updates
return masked_kspace, image, mean, std, fname, slice
def to_spatial(self, kspace, resolution):
'''
k space: pytorch tensor post enchancement
'''
# Inverse Fourier Transform to get interpolated solution
image = transforms.ifft2(kspace)
# Crop input image
image = transforms.complex_center_crop(image, (resolution, resolution))
# Absolute value
image = transforms.complex_abs(image)
# Normalize input
image, mean, std = transforms.normalize_instance(image, eps=1e-11)
image = image.clamp(-6, 6)
return image
def onormalize(original_kspace, mean, std, eps=1e-11):
#getting image from masked data
image = transforms.ifft2(original_kspace)
#normalizing the image
nimage = transforms.normalize(image, mean, std, eps=1e-11)
#getting kspace data from normalized image
original_kspace_fni = transforms.ifftshift(nimage, dim=(-3, -2))
original_kspace_fni = torch.fft(original_kspace_fni, 2)
original_kspace_fni = transforms.fftshift(original_kspace_fni,
dim=(-3, -2))
original_kspace_fni = transforms.normalize(original_kspace,
mean,
std,
eps=1e-11)
return original_kspace_fni
def inference(model, data, device):
with torch.no_grad():
input, target, mean, std, _, _, mask = data
input = input.to(device)
mask = mask.to(device)
output = model(input.permute(0, 3, 1, 2)).permute(0, 2, 3, 1)
output = input * mask + (1-mask) * output
target = target.to(device)
mean = mean.to(device)
std = std.to(device)
output = transforms.unnormalize(output, mean, std)
target = transforms.unnormalize(target, mean, std)
output = transforms.ifft2(output)
target = transforms.ifft2(target)
output = transforms.complex_center_crop(output, (320, 320))
output = transforms.complex_abs(output)
target = transforms.complex_center_crop(target, (320, 320))
target = transforms.complex_abs(target)
return output, target
def kspacetoimage(kspace, args):
# Inverse Fourier Transform to get zero filled solution
image = transforms.ifft2(kspace)
# Crop input image
image = transforms.complex_center_crop(image,
(args.resolution, args.resolution))
# Absolute value
image = transforms.complex_abs(image)
# Apply Root-Sum-of-Squares if multicoil data
if args.challenge == 'multicoil':
image = transforms.root_sum_of_squares(image)
# Normalize input
image, mean, std = transforms.normalize_instance(image, eps=1e-11)
image = image.clamp(-6, 6)
return image
def main():
torch.manual_seed(0)
args = Args().parse_args()
args.data_path = "../" + args.data_path
index = 3
train_data_loader, val_data_loader, display_data_loader = load_data(args)
for k_space, target, f_name, slice in display_data_loader:
sampling_vector = [[[i, j] for i in range(k_space.shape[1])]
for j in range(k_space.shape[2])]
sampling_vector = torch.tensor(sampling_vector).float()
sampling_vector = sampling_vector - 0.5 * k_space.shape[1]
sampling_vector = sampling_vector.reshape(-1, 2)
sampling_vector = sampling_vector.expand(k_space.shape[0], -1, -1)
images = sample_vector(k_space, sampling_vector)
break
for i in range(images.shape[0]):
show(ifft2(images[i]))
def kspaceto2dimage(kspace, polar, cropping=False, resolution=None):
if polar:
kspace = polarToCartesian(kspace)
if cropping:
if not resolution:
raise Exception(
"If cropping = True, pass the value for resolution for the function: kspaceto2dimage"
)
image = croppedimage(kspace, resolution)
else:
image = transforms.ifft2(kspace)
# Absolute value
image = transforms.complex_abs(image)
# Normalize input
image, mean, std = transforms.normalize_instance(image, eps=1e-11)
image = image.clamp(-6, 6)
return image
def save_zero_filled(data_dir, out_dir, which_challenge, resolution):
reconstructions = {}
for file in data_dir.iterdir():
print("file:{}".format(file))
with h5py.File(file, "r") as hf:
masked_kspace = transforms.to_tensor(hf['kspace'][()])
# Inverse Fourier Transform to get zero filled solution
image = transforms.ifft2(masked_kspace)
# Crop input image
smallest_width = min(resolution, image.shape[-2])
smallest_height = min(resolution, image.shape[-3])
image = transforms.complex_center_crop(image, (smallest_height, smallest_width))
# Absolute value
image = transforms.complex_abs(image)
# Apply Root-Sum-of-Squares if multicoil data
if which_challenge == 'multicoil':
image = transforms.root_sum_of_squares(image, dim=1)
reconstructions[file.name] = image
save_reconstructions(reconstructions, out_dir)
def forward(self, masked_kspace, mask):
def get_low_frequency_lines(mask):
l = r = mask.shape[-2] // 2
while mask[..., r, :]:
r += 1
while mask[..., l, :]:
l -= 1
return l + 1, r
l, r = get_low_frequency_lines(mask)
num_low_freqs = r - l
pad = (mask.shape[-2] - num_low_freqs + 1) // 2
x = T.mask_center(masked_kspace, pad, pad + num_low_freqs)
x = T.ifft2(x)
x, b = self.chans_to_batch_dim(x)
x = self.norm_unet(x)
x = self.batch_chans_to_chan_dim(x, b)
x = self.divide_root_sum_of_squares(x)
return x
def __call__(self, kspace, target, attrs, fname, slice_info):
"""
Args:
kspace (numpy.array): Input k-space of shape (num_coils, rows, cols, 2) for multi-coil
data or (rows, cols, 2) for single coil data.
target (numpy.array): Target image
attrs (dict): Acquisition related information stored in the HDF5 object.
fname (str): File name
slice (int): Serial number of the slice.
Returns:
(tuple): tuple containing:
image (torch.Tensor): Zero-filled input image.
target (torch.Tensor): Target image converted to a torch Tensor.
mean (float): Mean value used for normalization.
std (float): Standard deviation value used for normalization.
"""
kspace = transforms.to_tensor(kspace)
# Inverse Fourier Transform to get zero filled solution
image = transforms.ifft2(kspace)
# Crop input image to given resolution if larger
image, _, target, mean, std = resize(self.hparams, image, target)
return image, target, kspace, mean, std, fname, slice_info
