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