def __call__(self, x, Kx=None, tmp=None, **kwargs):
if type(x) is list:
x = x[0]
k = self.iter_count
if k in self.iter_save:
if Kx is None:
Kx = K(x)
x_smoothed = smoothing(x)
obj = KL(Kx, tmp=tmp)
psnr_opt = fom.psnr(x, x_opt)
psnr_opt_smoothed = fom.psnr(x_smoothed, x_opt_smoothed)
self.out.append({
'obj': obj,
'psnr_opt': psnr_opt,
'psnr_opt_smoothed': psnr_opt_smoothed
})
if k in self.iter_plot:
save_image(
x, '{}_{}'.format(self.alg, int(k / self.niter_per_epoch)),
'{}/pics'.format(folder_today))
self.iter_count += 1
def __call__(self, w):
if self.iter in self.iter_save:
obj = obj_fun(w[0])
psnr = fom.psnr(w[0], groundtruth)
psnr_opt = fom.psnr(w[0], x_opt)
dx = dist_x(w[0])
dy = dist_y(w[1])
dist = dx + dy
self.out.append({
'obj': obj,
'dist': dist,
'dist_x': dx,
'dist_y': dy,
'psnr': psnr,
'psnr_opt': psnr_opt,
'iter': self.iter
})
if self.iter in self.iter_plot:
fname = '{}_{}'.format(self.alg, self.iter)
spdhg.save_image(w[0], fname, folder_today, 1, clim=clim)
self.iter += 1
def test_psnr(space):
"""Test the ``psnr`` fom."""
true = odl.phantom.white_noise(space)
data = odl.phantom.white_noise(space)
zero = space.zero()
# Check the corner cases
assert fom.psnr(true, true) == np.inf
assert fom.psnr(zero, zero) == np.inf
assert fom.psnr(data, zero) == -np.inf
# Compute the true value
mse = np.mean((true - data) ** 2)
maxi = np.max(np.abs(true))
expected = 10 * np.log10(maxi ** 2 / mse)
# Test regular call
result = fom.psnr(data, true)
assert result == pytest.approx(expected, abs=1e-6)
# Test with arrays as input
result = fom.psnr(data.asarray(), true.asarray())
assert result == pytest.approx(expected, abs=1e-6)
# Test with force_lower_is_better giving negative of expected
result = fom.psnr(data, true, force_lower_is_better=True)
assert result == pytest.approx(-expected, abs=1e-6)
# Test with Z-score that result is independent of affine transformation
result = fom.psnr(data * 3.7 + 1.234, true, use_zscore=True)
expected = fom.psnr(data, true, use_zscore=True)
assert result == pytest.approx(expected, abs=1e-5)
def __call__(self, x, Kx=None, tmp=None, **kwargs):
if type(x) is list:
x = x[0]
k = self.iter_count
if k in self.iter_save:
obj = obj_fun(x)
psnr_opt = fom.psnr(x[0], x_opt[0])
diff_opt = (x[0] - x_opt[0]).norm() / x_opt[0].norm()
diff_opt_v = (x[1] - x_opt[1]).norm() / x_opt[1].norm()
self.out.append({
'obj': obj,
'psnr_opt': psnr_opt,
'diff_opt': diff_opt,
'diff_opt_v': diff_opt_v
})
if k in self.iter_plot:
save_image(
x, '{}_{}'.format(self.alg, int(k / niter_per_epoch)),
'{}/pics'.format(folder_today))
self.iter_count += 1
def __call__(self, x, Kx=None, tmp=None, **kwargs):
if type(x) is list:
x = x[0]
k = self.iter_count
if k in self.iter_save:
obj = obj_fun(x)
psnr_opt = fom.psnr(x, x_opt)
self.out.append({'obj': obj, 'psnr_opt': psnr_opt})
if k in self.iter_plot:
file = '{}_{}'.format(self.alg, int(k / niter_per_epoch))
folder = '{}/pics'.format(folder_today)
save_image(x, file, folder)
self.iter_count += 1
def __call__(self, x, **kwargs):
if len(x) == 2:
x = x[0]
k = self.iter_count
if k in self.iter_save:
if self.obj_fun is not None:
self.obj.append(self.obj_fun(x))
if k in self.iter_plot:
name = '{}{:04d}'.format(self.prefix, k)
gtruth = self.gtruth
if gtruth is not None:
name += '_psnr{:.1f}db_ssim{:0.4f}'.format(
psnr(x, gtruth), ssim(x, gtruth))
save_result(x, name)
if self.error and gtruth is not None:
save_error(x - gtruth, name + '_error')
self.iter_count += 1
odl.solvers.douglas_rachford_pd(x,
f,
g,
L,
tau,
sigmas,
niter=200,
callback=callback)
# %% Show results
x_true.show('True image', force_show=True)
y.show('Noisy image', force_show=True)
x.show('Denoised image', force_show=True)
(x_true - x).show('Difference true - denoised', force_show=True)
# %% Compute some image quality metrics
print('Noisy')
print('-----')
print('Mean squared error:', fom.mean_squared_error(y, x_true))
print('PSNR:', fom.psnr(y, x_true))
print('SSIM:', fom.ssim(y, x_true))
print('')
print('Denoised')
print('--------')
print('Mean squared error:', fom.mean_squared_error(x, x_true))
print('PSNR:', fom.psnr(x, x_true))
print('SSIM:', fom.ssim(x, x_true))
fom.blurring(phantom_noisy,
phantom,
mask,
normalized=True,
smoothness_factor=30))
false_struct.append(
fom.false_structures(phantom_noisy,
phantom,
mask,
normalized=True,
smoothness_factor=30))
ssim.append(fom.ssim(phantom_noisy, phantom))
psnr.append(fom.psnr(phantom_noisy, phantom, normalized=True))
haarpsi.append(fom.haarpsi(phantom_noisy, phantom))
fig, ax = plt.subplots()
ax.plot(mse, label='MSE')
ax.plot(mae, label='MAE')
ax.plot(mvd, label='MVD')
ax.plot(std_diff, label='SDD')
ax.plot(range_diff, label='RD')
ax.plot(blur, label='BLUR')
ax.plot(false_struct, label='FS')
ax.plot(ssim, label='SSIM')
ax.plot(haarpsi, label='HaarPSI')
plt.legend(loc='center right', fancybox=True, shadow=True, ncol=1)
ax.set_xlabel('Noise level')
# Create ODL data structures
size = 128
space = odl.uniform_discr([-64, -64], [64, 64], [size, size], dtype='float32')
# Creat parallel beam geometry
geometry = odl.tomo.parallel_beam_geometry(space, num_angles=30)
# Create ray transform operator
operator = odl.tomo.RayTransform(space, geometry)
# Create pseudoinverse
pseudoinverse = odl.tomo.fbp_op(operator, filter_type='Hann')
# --- Generate artificial data --- #
# Create phantom
phantom = odl.phantom.shepp_logan(space, modified=True)
# Create sinogram of forward projected phantom with noise
data = operator(phantom)
data += odl.phantom.white_noise(operator.range) * np.mean(np.abs(data)) * 0.05
recon = pseudoinverse(data)
print('psnr = {}'.format(fom.psnr(phantom, recon)))
# Display images
data.show('Data')
recon.show('Shepp-Logan FBP', clim=[0.1, 0.4])
# Combine functionals, order must correspond to the operator K
f = odl.solvers.SeparableSum(l2_norm, l1_norm)
# --- Select solver parameters and solve using Chambolle-Pock --- #
# Estimated operator norm, add 10 percent to ensure ||K||_2^2 * sigma * tau < 1
op_norm = 1.1 * odl.power_method_opnorm(op)
niter = 1000 # Number of iterations
tau = 0.1 # Step size for the primal variable
sigma = 1.0 / (op_norm**2 * tau) # Step size for the dual variable
gamma = 0.1
# Optionally pass callback to the solver to display intermediate results
callback = (odl.solvers.CallbackPrint(lambda x: psnr(phantom, x))
& odl.solvers.CallbackShow(clim=[0.1, 0.4]))
# Choose a starting point
x = pseudoinverse(data)
# Run the algorithm
odl.solvers.pdhg(x,
f,
g,
op,
tau=tau,
sigma=sigma,
niter=niter,
gamma=gamma,
callback=callback)
# --- Select solver parameters and solve using Chambolle-Pock --- #
# Choose a starting point
x = pseudoinverse(-np.log(epsilon + noisy_data) / mu_water)
# Estimated operator norm to ensure ||K||_2^2 * sigma * tau < 1
op_norm = odl.power_method_opnorm(op.derivative(x))
niter = 1000 # Number of iterations
tau = 1.0 / op_norm # Step size for the primal variable
sigma = 1.0 / op_norm # Step size for the dual variable
gamma = 0.01
# Pass callback to the solver to display intermediate results
callback = (odl.solvers.CallbackPrint(lambda x: fom.psnr(x, phantom))
& odl.solvers.CallbackShow(clim=[0.8, 1.2]))
odl.solvers.pdhg(x,
f,
g,
op,
tau=tau,
sigma=sigma,
niter=niter,
gamma=gamma,
callback=callback)
print('psnr = {}'.format(fom.psnr(phantom, x)))
# Display images
