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_check_asserts(self):
# Tests to check for asserts
image, nb_scale, optimizer, recon_type, name = self.test_cases[0]
fourier = NonCartesianFFT(
samples=convert_mask_to_locations(self.mask),
shape=image.shape,
)
kspace_data = fourier.op(image.data)
linear_op, regularizer_op = \
self.get_linear_n_regularization_operator(
wavelet_name=name,
dimension=len(fourier.shape),
nb_scale=2,
gradient_formulation="synthesis",
)
reconstructor = CalibrationlessReconstructor(
fourier_op=fourier,
linear_op=linear_op,
regularizer_op=regularizer_op,
gradient_formulation="synthesis",
verbose=1,
)
np.testing.assert_raises(
ValueError,
reconstructor.reconstruct,
kspace_data=kspace_data,
optimization_alg="test_fail",
num_iterations=self.num_iter,
)
fourier.n_coils = 10
reconstructor = SelfCalibrationReconstructor(
fourier_op=fourier,
linear_op=linear_op,
regularizer_op=regularizer_op,
gradient_formulation="synthesis",
verbose=1,
)
np.testing.assert_raises(
ValueError,
reconstructor.reconstruct,
kspace_data=kspace_data,
optimization_alg=optimizer,
num_iterations=self.num_iter,
)
#############################################################################
# FISTA optimization
# ------------------
#
# We now want to refine the zero order solution using a FISTA optimization.
# The cost function is set to Proximity Cost + Gradient Cost
# Setup the operators
linear_op = WaveletN(
wavelet_name='sym8',
nb_scale=4,
)
regularizer_op = SparseThreshold(Identity(), 1.5e-8, thresh_type="soft")
# Setup Reconstructor
reconstructor = SelfCalibrationReconstructor(
fourier_op=fourier_op,
linear_op=linear_op,
regularizer_op=regularizer_op,
gradient_formulation='synthesis',
kspace_portion=0.01,
verbose=1,
)
x_final, costs, metrics = reconstructor.reconstruct(
kspace_data=kspace_obs,
optimization_alg='fista',
num_iterations=10,
)
image_rec = pysap.Image(data=x_final)
recon_ssim = ssim(image_rec, image)
print('The Reconstruction SSIM is : ' + str(recon_ssim))
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)