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, 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 __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)) mask = transforms.get_mask(kspace, self.mask_func, seed) masked_kspace = mask * kspace # Inverse Fourier Transform to get zero filled solution image_precrop = transforms.ifft2(masked_kspace) masked_kspace, _, _ = transforms.normalize_instance_complex( masked_kspace, eps=1e-11) kspace, _, _ = transforms.normalize_instance_complex(kspace, eps=1e-11) # Crop input image image = transforms.complex_center_crop( image_precrop, (self.resolution, self.resolution)) image_abs = transforms.complex_abs(image) _, mean_abs, std_abs = transforms.normalize_instance(image_abs, eps=1e-11) # Normalize input image, mean, std = transforms.normalize_instance_complex(image, eps=1e-11) image = image.clamp(-6, 6) target = transforms.to_tensor(target) target_train = target if not TRAIN_COMPLEX: # Normalize target if RENORM: target_train = transforms.normalize(target, mean_abs, std_abs, eps=1e-11) target_train = target_train.clamp( -6, 6 ) # Return target (for viz) and target_clamped (for training) else: target_train = transforms.ifft2(kspace) target_train = transforms.complex_center_crop( target_train, (self.resolution, self.resolution)) if RENORM: target_train = transforms.normalize(target_train, mean, std, eps=1e-11) return image, target_train, mean, std, attrs['norm'].astype( np.float32 ), target, mean_abs, std_abs, kspace, masked_kspace, image_precrop