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