def __init__(self, Vm, parameters=[]):
""" Vm = FunctionSpace for the parameters m1, and m2 """
self.parameters = {}
self.parameters['k'] = 1.0
self.parameters['eps'] = 1e-2
self.parameters['amg'] = 'default'
self.parameters['nb_param'] = 2
self.parameters['use_i'] = False
self.parameters['print'] = False
self.parameters.update(parameters)
n = self.parameters['nb_param']
use_i = self.parameters['use_i']
assert not ((not use_i) * (n > 2))
if not use_i:
VmVm = createMixedFS(Vm, Vm)
else:
if self.parameters['print']:
print '[V_TV] Using createMixedFSi'
Vms = []
for ii in range(n):
Vms.append(Vm)
VmVm = createMixedFSi(Vms)
self.parameters['Vm'] = VmVm
self.regTV = TV(self.parameters)
if not use_i:
self.m1, self.m2 = Function(Vm), Function(Vm)
self.m = Function(VmVm)
def __init__(self, mesh, k, regularization='tikhonov'):
"""
Inputs:
pbtype = 'denoising' or 'deblurring'
mesh = Fenics mesh
k = Fenics Expression of the blurring kernel; must have parameter t
f = target image
"""
self.mesh = mesh
self.V = dl.FunctionSpace(self.mesh, 'Lagrange', 1)
self.dimV = self.V.dim()
self.xx = self.V.dofmap().tabulate_all_coordinates(self.mesh)
self.test, self.trial = dl.TestFunction(self.V), dl.TrialFunction(
self.V)
# Target data:
self.f_true = 0.75 * (self.xx >= .1) * (self.xx <= .25)
self.f_true += (self.xx >= 0.28) * (self.xx <= 0.3) * (15 * self.xx -
15 * 0.28)
self.f_true += (self.xx > 0.3) * (self.xx < 0.33) * 0.3
self.f_true += (self.xx >= 0.33) * (self.xx <= 0.35) * (-15 * self.xx +
15 * 0.35)
self.f_true += (self.xx >= .4) * (self.xx <= .9) * (
self.xx - .4)**2 * (self.xx - 0.9)**2 / .25**4
self.g = None # current iterate
# kernel operator
self.k = k
self.Kweak = dl.inner(self.k, self.test) * dl.dx
self.assembleK()
# mass matrix
self.Mweak = dl.inner(self.test, self.trial) * dl.dx
self.M = dl.assemble(self.Mweak)
# regularization
self.parameters['regularization'] = regularization
if regularization == 'tikhonov':
self.RegTikh = LaplacianPrior({
'gamma': 1.0,
'beta': 0.0,
'Vm': self.V
})
self.R = self.RegTikh.Minvprior.array()
elif regularization == 'TV':
self.RegTV = TV({'eps': 1e-2, 'Vm': self.V})
# line search parameters
self.parameters['alpha0'] = 1.0
self.parameters['rho'] = 0.5
self.parameters['c'] = 5e-5
self.parameters['max_backtrack'] = 12
def __init__(self,
CGdeg,
regularizationtype,
h=1.0,
parameters=[],
image='image.dat'):
class Image(dl.Expression):
def __init__(self, Lx, Ly, data):
self.data = data
self.hx = Lx / float(self.data.shape[1] - 1)
self.hy = Ly / float(self.data.shape[0] - 1)
def eval(self, values, x):
j = math.floor(x[0] / self.hx)
i = math.floor(x[1] / self.hy)
values[0] = self.data[i, j]
data = np.loadtxt(image, delimiter=',')
#Lx, Ly = float(data.shape[1])/float(data.shape[0]), 1.
Lx, Ly = 2., 1.
scaling = 100. * h # =1.0 => h~0.01
Lx, Ly = scaling * Lx, scaling * Ly
np.random.seed(seed=1)
noise_std_dev = 0.3
noise = noise_std_dev * np.random.randn(data.shape[0], data.shape[1])
print '||noise||={}'.format(np.linalg.norm(noise))
mesh = dl.RectangleMesh(dl.Point(0, 0), dl.Point(Lx, Ly), 200, 100)
mcoord = mesh.coordinates()
print 'hx={}, hy={}'.format((mcoord[-1][0] - mcoord[0][0]) / 200.,
(mcoord[-1][1] - mcoord[0][1]) / 100.)
V = dl.FunctionSpace(mesh, 'Lagrange', CGdeg)
trueImage = Image(Lx, Ly, data)
noisyImage = Image(Lx, Ly, data + noise)
print 'min(data)={}, max(data)={}'.format(np.amin(data), np.amax(data))
print 'min(data+noise)={}, max(data+noise)={}'.format(
np.amin(data + noise), np.amax(data + noise))
self.u_true = dl.interpolate(trueImage, V)
self.u_0 = dl.interpolate(noisyImage, V)
self.u = dl.Function(V)
self.ucopy = dl.Function(V)
self.G = dl.Function(V)
self.du = dl.Function(V)
u_test = dl.TestFunction(V)
u_trial = dl.TrialFunction(V)
Mweak = dl.inner(u_test, u_trial) * dl.dx
self.M = dl.assemble(Mweak)
self.solverM = dl.LUSolver('petsc')
self.solverM.parameters['symmetric'] = True
self.solverM.parameters['reuse_factorization'] = True
self.solverM.set_operator(self.M)
self.regul = regularizationtype
if self.regul == 'tikhonov':
self.Regul = LaplacianPrior({'Vm': V, 'gamma': 1.0, 'beta': 0.0})
elif self.regul == 'TV':
paramTV = {'Vm': V, 'k': 1.0, 'eps': 1e-4, 'GNhessian': True}
paramTV.update(parameters)
self.Regul = TV(paramTV)
self.inexact = False
elif self.regul == 'TVPD':
paramTV = {'Vm': V, 'k': 1.0, 'eps': 1e-4, 'exact': False}
paramTV.update(parameters)
self.Regul = TVPD(paramTV)
self.inexact = False
self.alpha = 1.0
self.Hess = self.M
self.parametersLS = {'alpha0':1.0, 'rho':0.5, 'c':5e-5, \
'max_backtrack':12, 'cgtol':0.5, 'maxiter':50000}
filename, ext = os.path.splitext(sys.argv[0])
#if os.path.isdir(filename + '/'): shutil.rmtree(filename + '/')
self.myplot = PlotFenics(filename)
try:
solver = PETScKrylovSolver('cg', 'ml_amg')
self.precond = 'ml_amg'
except:
print '*** WARNING: ML not installed -- using petsc_amg instead'
self.precond = 'petsc_amg'
