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 __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 __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.
"""
target = T.to_tensor(target)
kspace = T.to_tensor(kspace)
seed = None if not self.use_seed else tuple(map(ord, fname))
acq_start = attrs['padding_left']
acq_end = attrs['padding_right']
masked_kspace, mask = T.apply_mask(kspace, self.mask_func, seed,
(acq_start, acq_end))
max_value = attrs['max']
return masked_kspace, mask.byte(), target, fname, slice, max_value
def test_apply_mask(shape, center_fractions, accelerations):
mask_func = MaskFunc(center_fractions, accelerations)
expected_mask = mask_func(shape, seed=123)
input = create_input(shape)
output, mask = transforms.apply_mask(input, mask_func, seed=123)
assert output.shape == input.shape
assert mask.shape == expected_mask.shape
assert np.all(expected_mask.numpy() == mask.numpy())
assert np.all(np.where(mask.numpy() == 0, 0, output.numpy()) == output.numpy())
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 __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 __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 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:
masked_kspace (torch.Tensor): Masked k-space
mask (torch.Tensor): Mask
target (torch.Tensor): Target image converted to a torch Tensor.
fname (str): File name
slice (int): Serial number of the slice.
max_value (numpy.array): Maximum value in the image volume
"""
if target is not None:
target = T.to_tensor(target)
max_value = attrs['max']
else:
target = torch.tensor(0)
max_value = 0.0
kspace = T.to_tensor(kspace)
seed = None if not self.use_seed else tuple(map(ord, fname))
acq_start = attrs['padding_left']
acq_end = attrs['padding_right']
if self.mask_func:
masked_kspace, mask = T.apply_mask(kspace, self.mask_func, seed,
(acq_start, acq_end))
else:
masked_kspace = kspace
shape = np.array(kspace.shape)
num_cols = shape[-2]
shape[:-3] = 1
mask_shape = [1 for _ in shape]
mask_shape[-2] = num_cols
mask = torch.from_numpy(
mask.reshape(*mask_shape).astype(np.float32))
mask[:, :, :acq_start] = 0
mask[:, :, acq_end:] = 0
return masked_kspace, mask.byte(), target, fname, slice, max_value
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))
masked_kspace, mask = transforms.apply_mask(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 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)
target = transforms.to_tensor(target)
# Normalize target
target = transforms.normalize(target, mean, std, eps=1e-11)
target = target.clamp(-6, 6)
#augment data
if self.use_aug:
image, target = self.augment_data(image, target)
return image, target, mean, std, attrs['norm'].astype(np.float32)
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, optional): 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:
masked_kspace (torch.Tensor): Sub-sampled k-space with the same shape as kspace.
fname (str): File name containing the current data item
slice (int): The index of the current slice in the volume
"""
kspace = transforms.to_tensor(kspace)
seed = tuple(map(ord, fname))
# Apply mask to raw k-space
masked_kspace, mask = transforms.apply_mask(kspace, self.mask_func, seed)
return masked_kspace, fname, slice
def data_transform(kspace, mask_function, target, data_attributes, filename,
slice_num):
"""
Perform preprocessing of the kspace image, in order to get a proper input for the net. Should be invoked from
the SliceData class.
Args:
- kspace: complete sampled kspace image
- mask_func: masking function to apply mask to kspace (TODO not working: we are passing from outside)
- target: the target image to be reconstructed from the kspace
- data_attributes: attributes of the whole HDF5 file
Returns:
- normalized_masked_image: original kspace with mask applied and cropped to 320 x 320
- mask: mask generated by masking function
- normalized_target: normalized target
- max_value: highest entry in target tensor (for SSIM loss)
"""
kspace_t = transforms.to_tensor(kspace)
kspace_t = transforms.normalize_instance(kspace_t)[0]
masked_kspace, mask = transforms.apply_mask(
data=kspace_t, mask_func=mask_func
) # apply mask: returns masked space and generated mask
masked_image = fastmri.ifft2c(
masked_kspace
) # Apply Inverse Fourier Transform to get the complex image
masked_image = transforms.complex_center_crop(
masked_image, (320, 320)) # center crop masked image
masked_image = masked_image.permute(
2, 0, 1) # permuting the masked image fot pytorch n x c x h x w format
masked_image = transforms.normalize_instance(masked_image)[0] # normalize
target = transforms.to_tensor(target)
target = transforms.normalize_instance(target)[0] # normalize
target = torch.unsqueeze(target, 0) # add dimension
return kspace_t, masked_image, target, mask, data_attributes[
'max'], slice_num
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)
gt = transforms.ifft2(kspace)
gt = transforms.complex_center_crop(gt, (self.resolution, self.resolution))
kspace = transforms.fft2(gt)
# Apply mask
seed = None if not self.use_seed else tuple(map(ord, fname))
masked_kspace, mask = transforms.apply_mask(kspace, self.mask_func, seed)
# Inverse Fourier Transform to get zero filled solution
image = transforms.ifft2(masked_kspace)
masked_kspace = transforms.fft2_nshift(image)
# Crop input image
image = transforms.complex_center_crop(image, (self.resolution, self.resolution))
# Absolute value
image_mod = transforms.complex_abs(image).max()
image_r = image[:, :, 0]*6.0/image_mod
image_i = image[:, :, 1]*6.0/image_mod
# image_r = image[:, :, 0]
# image_i = image[:, :, 1]
# Apply Root-Sum-of-Squares if multicoil data
if self.which_challenge == 'multicoil':
image = transforms.root_sum_of_squares(image)
# Normalize input
image = np.stack((image_r, image_i), axis=-1)
image = image.transpose((2, 0, 1))
image = transforms.to_tensor(image)
target = transforms.ifft2(kspace)
target = transforms.complex_center_crop(target, (self.resolution, self.resolution))
# Normalize target
target_r = target[:, :, 0]*6.0/image_mod
target_i = target[:, :, 1]*6.0/image_mod
# target_r = target[:, :, 0]
# target_i = target[:, :, 1]
target = np.stack((target_r, target_i), axis=-1)
target = target.transpose((2, 0, 1))
target = transforms.to_tensor(target)
image_mod = np.stack((image_mod, image_mod), axis=0)
image_mod = transforms.to_tensor(image_mod)
norm = attrs['norm'].astype(np.float32)
norm = np.stack((norm, norm), axis=-1)
norm = transforms.to_tensor(norm)
mask = mask.expand(kspace.shape)
mask = mask.transpose(0, 2).transpose(1, 2)
mask = transforms.ifftshift(mask)
masked_kspace = masked_kspace.transpose(0, 2).transpose(1, 2)
return image, target
def get_attack_loss_new(model, ori_target, loss_f=torch.nn.MSELoss(reduction='none'),
xs=np.random.randint(low=100, high=320-100, size=(16,)),
ys=np.random.randint(low=100, high=320-100, size=(16,)),
shape=(320, 320), n_pixel_range=(10, 11), train=False, optimizer=None):
input_o = ori_target.unsqueeze(1).to(args.device)
input_o = input_o.clone()
#input_o = transforms.complex_abs(ori_input.clone())
#input_o, mean, std = transforms.normalize_instance(ori_target.unsqueeze(1).clone())
#input_o = torch.clamp(input_o, -6, 6)
#perturb_noise = perturb_noise_init(x=x, y=y, shape=shape, n_pixel_range=n_pixel_range)
p_max = input_o.max().cpu()
#p_min = (p_max - input.min()) / 2
#p_min = (p_max - input_o.min())
p_min = input_o.min().cpu()
perturb_noise = [perturb_noise_init(x=x, y=y, shape=shape, n_pixel_range=n_pixel_range, pixel_value_range=(p_min, p_max)) for x, y in zip(xs, ys)]
perturb_noise = np.stack(perturb_noise)
# perturb the target to get the perturbed image
#perturb_noise = np.expand_dims(perturb_noise, axis=0)
#perturb_noise = np.stack((perturb_noise,)*ori_target.shape(0), -1)
seed = np.random.randint(999999999)
perturb_noise = transforms.to_tensor(perturb_noise).unsqueeze(1).to(args.device)
if not args.fnaf_eval_control:
input_o += perturb_noise
target = input_o.clone()
#print(input_o.shape)
input_o = np.complex64(input_o.cpu().numpy())
input_o = transforms.to_tensor(input_o)
input_o = transforms.fft2(input_o)
input_o, mask = transforms.apply_mask(input_o, mask_f, seed)
input_o = transforms.ifft2(input_o)
image = transforms.complex_abs(input_o).to(args.device)
image, mean, std = transforms.normalize_instance(image, eps=1e-11)
image = image.clamp(-6, 6)
target = transforms.normalize(target, mean, std, eps=1e-11)
target = target.clamp(-6, 6)
#information_loss = loss_f(og_image.squeeze(1), image.squeeze(1)).mean(-1).mean(-1).cpu().numpy()
#information_loss = np.array([0]*len(xs))
# apply the perturbed image to the model to get the loss
if train:
output = model(image).squeeze(1)
else:
with torch.no_grad():
output = model(image).squeeze(1)
#perturb_noise_tensor = transforms.to_tensor(perturb_noise).to(args.device, dtype=torch.double)
perturb_noise = perturb_noise.squeeze(1)
perturb_noise_tensor = perturb_noise
perturb_noise = perturb_noise.cpu().numpy()
mask = adjusted_mask((perturb_noise > 0).astype(np.double))
#mask = (perturb_noise > 0).astype(np.double)
target = target.squeeze(1)
mask_0 = transforms.to_tensor(mask).to(args.device)
loss = loss_f((output*mask_0), (target*mask_0))
if train:
b_loss = loss.sum() / mask_0.sum() * 1 + loss_f(output, target).mean()
b_loss.backward()
optimizer.step()
loss = loss.detach()
loss = loss.mean(-1).mean(-1).cpu().numpy()
#loss = loss.mean(-1).mean(-1).numpy()
# information_loss_list.append(information_loss)
# xs_list.append(xs)
# ys_list.append(ys)
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.
"""
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 = transforms.fft2(image_square) ##kspace of square iamge
if self.augmentation:
kspace_square = self.augmentation.apply(kspace_square)
image_square = transforms.ifft2(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 = transforms.ifft2(
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 __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
image_square2 = ifft_c3(kspace_square) ##for training domain_transform
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)
us_image_square = 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)
us_image_square_abs = transforms.complex_abs(
us_image_square) ## US square real image
us_image_square_rss = transforms.root_sum_of_squares(
us_image_square_abs, dim=0)
stacked_kspace_square = []
for i in (range(len(kspace_square[:, 0, 0, 0]))):
stacked_kspace_square.append(kspace_square[i, :, :, 0])
stacked_kspace_square.append(kspace_square[i, :, :, 1])
stacked_kspace_square = torch.stack(stacked_kspace_square)
stacked_masked_kspace_square = []
# masked_kspace_square = transforms.to_tensor(masked_kspace_square)
# for i in range(len(masked_kspace_square[:,0,0,0])):
# stacked_masked_kspace_square.stack(masked_kspace_square[i,:,:,0],masked_kspace_square[i,:,:,1])
for i in (range(len(masked_kspace_square[:, 0, 0, 0]))):
stacked_masked_kspace_square.append(masked_kspace_square[i, :, :,
0])
stacked_masked_kspace_square.append(masked_kspace_square[i, :, :,
1])
stacked_masked_kspace_square = torch.stack(
stacked_masked_kspace_square)
stacked_image_square = []
for i in (range(len(image_square[:, 0, 0, 0]))):
stacked_image_square.append(image_square2[i, :, :, 0])
stacked_image_square.append(image_square2[i, :, :, 1])
stacked_image_square = torch.stack(stacked_image_square)
return stacked_kspace_square,stacked_masked_kspace_square , stacked_image_square , \
us_image_square_rss , \
target *10000 \
#mean, std, attrs['norm'].astype(np.float32)
'''
# In[12]:
plt.imshow(np.abs(slice_image_rss.numpy()), cmap='gray')
# So far, we have been looking at fully-sampled data. We can simulate under-sampled data by creating a mask and applying it to k-space.
# In[13]:
from common.subsample import MaskFunc
mask_func = MaskFunc(center_fractions=[0.04],
accelerations=[8]) # Create the mask function object
# In[14]:
masked_kspace, mask = T.apply_mask(slice_kspace2,
mask_func) # Apply the mask to k-space
# Let's see what the subsampled image looks like:
# In[15]:
sampled_image = T.ifft2(
masked_kspace) # Apply Inverse Fourier Transform to get the complex image
sampled_image_abs = T.complex_abs(
sampled_image) # Compute absolute value to get a real image
sampled_image_rss = T.root_sum_of_squares(sampled_image_abs, dim=0)
# In[16]:
plt.imshow(np.abs(sampled_image_rss.numpy()), cmap='gray')
