def test_columnFFT_forward(self): """Test the forward operator of ColumnFFT.""" column_indexes = np.arange(64) mask = np.ones(self.shape) for nc in self.n_coils: fourier_op = FFT(mask=mask, shape=self.shape, n_coils=nc) column_fft = ColumnFFT(shape=self.shape, line_index=0, n_coils=nc) data = np.squeeze(np.random.rand(fourier_op.n_coils, *self.shape)) k_data = fourier_op.op(data) for col in column_indexes: column_fft.mask = col np.testing.assert_allclose(column_fft.op(data), k_data[..., column_fft.mask]) print("Test forward operator of columnFFT")
def test_self_calibrating_reconstruction(self): """ Test all the registered transformations. """ self.num_channels = 2 print("Process test for SelfCalibratingReconstructor ::") for i in range(len(self.test_cases)): print("Test Case " + str(i) + " " + str(self.test_cases[i])) image, nb_scale, optimizer, recon_type, name = self.test_cases[i] image_multichannel = np.repeat(image.data[np.newaxis], self.num_channels, axis=0) if optimizer == 'condatvu': formulation = "analysis" else: formulation = "synthesis" if recon_type == 'cartesian': fourier = FFT(samples=convert_mask_to_locations(self.mask), shape=image.shape, n_coils=self.num_channels) else: fourier = NonCartesianFFT(samples=convert_mask_to_locations( self.mask), shape=image.shape, n_coils=self.num_channels) kspace_data = fourier.op(image_multichannel) linear_op, regularizer_op = \ self.get_linear_n_regularization_operator( wavelet_name=name, dimension=len(fourier.shape), nb_scale=2, n_coils=self.num_channels, gradient_formulation=formulation, ) # For self calibrating reconstruction the n_coils # for wavelet operation is 1 linear_op.n_coils = 1 reconstructor = SelfCalibrationReconstructor( fourier_op=fourier, linear_op=linear_op, regularizer_op=regularizer_op, gradient_formulation=formulation, verbose=0, ) x_final, costs, _ = reconstructor.reconstruct( kspace_data=kspace_data, optimization_alg=optimizer, num_iterations=self.num_iter, ) fourier_0 = FFT( samples=convert_mask_to_locations(self.mask), shape=image.shape, n_coils=self.num_channels, ) recon = fourier_0.adj_op(fourier_0.op(image_multichannel)) np.testing.assert_allclose(np.abs(x_final), np.sqrt(np.sum(np.abs(recon)**2, axis=0)), rtol=1e-3)
def test_sparse_calibrationless_reconstruction(self): """ Test all the registered transformations. """ self.num_channels = 2 print("Process test for SparseCalibrationlessReconstructor ::") for i in range(len(self.test_cases)): print("Test Case " + str(i) + " " + str(self.test_cases[i])) image, nb_scale, optimizer, recon_type, name = self.test_cases[i] image_multichannel = np.repeat(image.data[np.newaxis], self.num_channels, axis=0) if optimizer == 'condatvu': formulation = "analysis" else: formulation = "synthesis" if recon_type == 'cartesian': fourier = FFT(samples=convert_mask_to_locations(self.mask), shape=image.shape, n_coils=self.num_channels) else: fourier = NonCartesianFFT(samples=convert_mask_to_locations( self.mask), shape=image.shape, n_coils=self.num_channels) kspace_data = fourier.op(image_multichannel) linear_op, regularizer_op = \ self.get_linear_n_regularization_operator( wavelet_name=name, dimension=len(fourier.shape), nb_scale=2, n_coils=2, n_jobs=2, gradient_formulation=formulation, ) reconstructor = CalibrationlessReconstructor( fourier_op=fourier, linear_op=linear_op, regularizer_op=regularizer_op, gradient_formulation=formulation, verbose=1, ) x_final, costs, _ = reconstructor.reconstruct( kspace_data=kspace_data, optimization_alg=optimizer, num_iterations=self.num_iter, ) fourier_0 = FFT( samples=convert_mask_to_locations(self.mask), shape=image.shape, n_coils=self.num_channels, ) data_0 = fourier_0.op(image_multichannel) # mu is 0 for above single channel reconstruction and # hence we expect the result to be the inverse fourier transform np.testing.assert_allclose(x_final, fourier_0.adj_op(data_0))
def test_columnFFT_adjoint(self): """Test the adjoint operator of column FFT. """ column_indexes = np.arange(0, 64) mask = np.ones(self.shape) for nc in self.n_coils: fft2d = FFT(mask=mask, shape=self.shape, n_coils=nc) column_fft = ColumnFFT(shape=self.shape, line_index=0, n_coils=nc) k_data = np.squeeze( np.random.rand(fft2d.n_coils, *self.shape) + 1j * np.random.rand(fft2d.n_coils, *self.shape)) for col in column_indexes: column_fft.mask = col mask = np.zeros(self.shape) mask[:, column_fft.mask] = 1 fft2d.mask = mask print(np.nonzero(fft2d.mask[0, :])) print(column_fft.mask) print(column_fft.adj_op(k_data[..., column_fft._mask])[0, :5]) print(fft2d.adj_op(k_data)[0, :5]) np.testing.assert_allclose( column_fft.adj_op(k_data[..., column_fft._mask]), fft2d.adj_op(k_data)) print("Test adjoint operator of columnFFT")
def test_stack3d_self_calibration_recon(self): # This test carries out a self calibration recon using Stack3D self.num_channels = 2 self.z_size = 10 for i in range(len(self.test_cases)): image, nb_scale, optimizer, recon_type, name = self.test_cases[i] if recon_type == 'cartesian' or name == 24: continue # Make a dummy 3D image from 2D image = np.moveaxis( np.repeat(image.data[np.newaxis], self.z_size, axis=0), 0, 2) # Make dummy multichannel image image = np.repeat(image[np.newaxis], self.num_channels, axis=0) sampling_z = np.random.randint(2, size=image.shape[3]) sampling_z[self.z_size // 2 - 3:self.z_size // 2 + 3] = 1 Nz = sampling_z.sum() mask = convert_mask_to_locations(self.mask) z_locations = np.repeat(convert_mask_to_locations(sampling_z), mask.shape[0]) z_locations = z_locations[:, np.newaxis] kspace_loc = np.hstack([np.tile(mask, (Nz, 1)), z_locations]) fourier = Stacked3DNFFT(kspace_loc=kspace_loc, shape=image.shape[1:], implementation='cpu', n_coils=self.num_channels) kspace_obs = fourier.op(image) if optimizer == 'condatvu': formulation = "analysis" else: formulation = "synthesis" linear_op, regularizer_op = \ self.get_linear_n_regularization_operator( wavelet_name=name, dimension=len(fourier.shape), nb_scale=2, n_coils=2, n_jobs=2, gradient_formulation=formulation, ) # For self calibrating reconstruction the n_coils # for wavelet operation is 1 linear_op.n_coils = 1 reconstructor = SelfCalibrationReconstructor( fourier_op=fourier, linear_op=linear_op, regularizer_op=regularizer_op, gradient_formulation=formulation, num_check_lips=0, smaps_extraction_mode='Stack', verbose=1, ) x_final, _, _, = reconstructor.reconstruct( kspace_data=kspace_obs, optimization_alg=optimizer, num_iterations=5, ) fourier_0 = FFT( samples=kspace_loc, shape=image.shape[1:], n_coils=self.num_channels, ) recon = fourier_0.adj_op(fourier_0.op(image)) np.testing.assert_allclose( np.abs(x_final), np.sqrt(np.sum(np.abs(recon)**2, axis=0)), 0.1)
def test_online_accumulating_calibrationless(self): self.num_channels = 2 for i in range(len(self.test_cases)): image, nb_scale, optimizer, recon_type, name = self.test_cases[i] if recon_type != 'cartesian': continue if optimizer == 'condatvu': formulation = "analysis" else: formulation = "synthesis" image_multichannel = np.repeat(image.data[np.newaxis], self.num_channels, axis=0) fourier = FFT(samples=convert_mask_to_locations(self.mask), shape=image.shape, n_coils=self.num_channels) kspace_data = fourier.op(image_multichannel) linear_op, _ = \ self.get_linear_n_regularization_operator( wavelet_name=name, dimension=len(fourier.shape), nb_scale=2, n_coils=2, n_jobs=2, image_shape=image.shape, ) regularizer_op_gl = GroupLASSO(weights=0) linear_op.op(image_multichannel) regularizer_op_owl = OWL( alpha=0, beta=0, mode='band_based', n_coils=self.num_channels, bands_shape=linear_op.coeffs_shape, ) for regularizer_op in [regularizer_op_gl, regularizer_op_owl]: print(image, nb_scale, optimizer, recon_type, name, regularizer_op) kspace_gen = KspaceGeneratorBase(full_kspace=kspace_data, mask=fourier.mask, max_iter=10) reconstructor = CalibrationlessReconstructor( fourier_op=fourier, linear_op=linear_op, regularizer_op=regularizer_op, gradient_formulation=formulation, num_check_lips=0, verbose=1, ) x_final, costs, _ = reconstructor.reconstruct( kspace_data=kspace_gen, optimization_alg=optimizer, ) fourier_0 = FFT( samples=convert_mask_to_locations(self.mask), shape=image.shape, n_coils=self.num_channels, ) data_0 = fourier_0.op(image_multichannel) # mu is 0 for above single channel reconstruction and # hence we expect the result to be the inverse fourier # transform np.testing.assert_allclose(x_final, fourier_0.adj_op(data_0), 0.01)