def __call__(self, w, **kwargs):
if self.iter > 0:
k = self.iter
self.ergx = 1 / k * ((k - 1) * self.ergx + w[0])
self.ergy = 1 / k * ((k - 1) * self.ergy + w[1])
if self.iter in self.iter_save:
obj = obj_fun(w[0])
breg_x = bregman_g(w[0])
breg_y = bregman_f(w[1])
breg = breg_x + breg_y
breg_ex = bregman_g(self.ergx)
breg_ey = bregman_f(self.ergy)
breg_erg = breg_ex + breg_ey
dx = dist_x(w[0])
dy = dist_y(w[1])
dist = dx + dy
dex = dist_x(self.ergx)
dey = dist_y(self.ergy)
dist_erg = dex + dey
self.out.append({'obj': obj, 'breg': breg, 'breg_x': breg_x,
'breg_y': breg_y, 'breg_erg': breg_erg,
'breg_ex': breg_ex, 'breg_ey': breg_ey,
'dist': dist, 'dist_x': dx, 'dist_y': dy,
'dist_erg': dist_erg, 'dist_ex': dex,
'dist_ey': dey, '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 __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 __call__(self, x, **kwargs):
if self.iter in self.iter_save:
obj = obj_fun(x[0])
dx = dist_x(x[0])
dy = dist_y(x[1])
d = dx + dy
self.out.append({
'obj': obj,
'iter': self.iter,
'dist': d,
'dist_x': dx,
'dist_y': dy
})
if self.iter in self.iter_plot:
fname = '{}_{}'.format(self.alg, self.iter)
spdhg.save_image(x[0], fname, folder_today, 1, clim=clim)
self.iter += 1
sino_supp = sino.ufuncs.greater(0)
smooth_supp = Y.element([
gaussian_filter(s, sigma=[1, 2 / X.cell_sides[0]]) for s in sino_supp
])
background = 10 * smooth_supp + 10
background *= counts_background / background.ufuncs.sum()
data = odl.phantom.poisson_noise(factors * sino + background, seed=1807)
arr = np.empty(3, dtype=object)
arr[0] = data
arr[1] = factors
arr[2] = background
np.save(file_data, arr)
spdhg.save_image(groundtruth, 'groundtruth', folder_main, 1, clim=clim)
fig2 = plt.figure(2)
fig2.clf()
i = 11
plt.plot((sino[i]).asarray()[0], label='G(x)')
plt.plot((factors[i] * sino[i]).asarray()[0], label='factors * G(x)')
plt.plot(data[i].asarray()[0], label='data')
plt.plot(background[i].asarray()[0], label='background')
plt.legend()
fig2.savefig('{}/components1D.png'.format(folder_main),
bbox_inches='tight')
else:
(data, factors, background) = np.load(file_data)
kernel = images.blurring_kernel(shape=[15, 15])
convolution = spdhg.Blur2D(X, kernel)
K = odl.uniform_discr([0, 0], kernel.shape, kernel.shape)
kernel = K.element(kernel)
scale = 1e+3
A = odl.BroadcastOperator(Dx, Dy, scale / clim[1] * convolution)
Y = A.range
# create data
background = 200 * Y[2].one()
data = odl.phantom.poisson_noise(A[2](groundtruth) + background, seed=1807)
# save images and data
if not os.path.exists('{}/groundtruth.png'.format(folder_main)):
spdhg.save_image(groundtruth, 'groundtruth', folder_main, 1, clim=clim)
spdhg.save_image(data - background,
'data',
folder_main,
2,
clim=[0, scale])
spdhg.save_image(kernel, 'kernel', folder_main, 3)
alpha = 0.1 # set regularisation parameter
gamma = 0.99 # auxiliary step size parameter < 1
# set up functional f
f = odl.solvers.SeparableSum(
odl.solvers.Huber(A[0].range, gamma=1),
odl.solvers.Huber(A[1].range, gamma=1),
1 / alpha * spdhg.KullbackLeiblerSmooth(A[2].range, data, background))
folder_npy = '{}/npy'.format(folder_today)
if not os.path.exists(folder_npy):
os.makedirs(folder_npy)
# create ground truth
image_gray = images.building(gray=True)
X = odl.uniform_discr([0, 0], image_gray.shape, image_gray.shape)
groundtruth = X.element(image_gray)
clim = [0, 1]
# create data
data = odl.phantom.white_noise(X, mean=groundtruth, stddev=0.1, seed=1807)
# save images and data
if not os.path.exists('{}/groundtruth.png'.format(folder_main)):
spdhg.save_image(groundtruth, 'groundtruth', folder_main, 1, clim=clim)
spdhg.save_image(data, 'data', folder_main, 2, clim=clim)
alpha = .12 # set regularisation parameter
gamma = 0.99 # gamma^2 is upper bound of step size constraint
# create forward operators
Dx = odl.PartialDerivative(X, 0, pad_mode='symmetric')
Dy = odl.PartialDerivative(X, 1, pad_mode='symmetric')
A = odl.BroadcastOperator(Dx, Dy)
Y = A.range
# set up functional f
f = odl.solvers.SeparableSum(*[odl.solvers.L1Norm(Yi) for Yi in Y])
# set up functional g
g = 1 / (2 * alpha) * odl.solvers.L2NormSquared(X).translated(data)
