def test_cm1d_weak_solution_default(self):
# Define temporal and spatial sample points.
m, n = 10, 20
# Define mesh and function space.
mesh = UnitSquareMesh(m - 1, n - 1)
V = dh.create_function_space(mesh, 'default')
# Create zero function.
f = Function(V)
# Compute velocity.
v, res, fun = cm1d_weak_solution(V, f, f.dx(0), f.dx(1), 1.0, 1.0)
v = v.vector().get_local()
np.testing.assert_allclose(v.shape, m * n)
np.testing.assert_allclose(v, np.zeros_like(v))
np.testing.assert_allclose(res, 0)
np.testing.assert_allclose(fun, 0)
V = dh.create_function_space(mesh, 'periodic')
# Create zero function.
f = Function(V)
# Compute velocity.
v, res, fun = cm1d_weak_solution(V, f, f.dx(0), f.dx(1), 1.0, 1.0)
v = v.vector().get_local()
np.testing.assert_allclose(v.shape, m * (n - 1))
np.testing.assert_allclose(v, np.zeros_like(v))
np.testing.assert_allclose(res, 0)
np.testing.assert_allclose(fun, 0)
def test_cms1d_weak_solution_given_velocity_default(self):
# Define temporal and spatial sample points.
m, n = 10, 20
# Define mesh and function space.
mesh = UnitSquareMesh(m - 1, n - 1)
V = dh.create_function_space(mesh, 'default')
# Create zero function.
f = Function(V)
# Create velocity.
v = Function(V)
vx = Function(V)
# Compute source.
k, res, fun = cms1d_weak_solution_given_velocity(
V, f, f.dx(0), f.dx(1), v, vx, 1.0, 1.0)
k = k.vector().get_local()
np.testing.assert_allclose(k.shape, m * n)
np.testing.assert_allclose(k, np.zeros_like(k))
V = dh.create_function_space(mesh, 'periodic')
# Create zero function.
f = Function(V)
# Compute source.
k, res, fun = cms1d_weak_solution_given_velocity(
V, f, f.dx(0), f.dx(1), v, vx, 1.0, 1.0)
k = k.vector().get_local()
np.testing.assert_allclose(k.shape, m * (n - 1))
np.testing.assert_allclose(k, np.zeros_like(k))
def cm1d_exp(m: int, n: int, f: Expression, ft: Expression, fx: Expression,
alpha0: float, alpha1: float) -> np.array:
"""Computes the L2-H1 mass conserving flow for a 1D image sequence.
Args:
m (int): Number of temporal sampling points.
n (int): Number of spatial sampling points.
f (Expression): 1D image sequence.
ft (Expression): Partial derivative of f wrt. time.
fx (Expression): Partial derivative of f wrt. space.
alpha0 (float): Spatial regularisation parameter.
alpha1 (float): Temporal regularisation parameter.
Returns:
v (np.array): A velocity array of shape (m, n).
res (float): The residual.
func (float): The value of the functional.
"""
# Define mesh and function space.
mesh = UnitSquareMesh(m - 1, n - 1)
V = dh.create_function_space(mesh, 'default')
# Compute velocity.
v, res, fun = cm1d_weak_solution(V, f, ft, fx, alpha0, alpha1)
# Convert to array and return.
return dh.funvec2img(v.vector().get_local(), m, n), res, fun
def of1d_exp(m: int, n: int,
f: Expression, ft: Expression, fx: Expression,
alpha0: float, alpha1) -> (np.array, float, float):
"""Computes the L2-H1 optical flow for a 1D image sequence.
Takes a one-dimensional image sequence and partial derivatives, and returns
a minimiser of the Horn-Schunck functional with spatio-temporal
regularisation.
Args:
m (int): Number of temporal sampling points.
n (int): Number of spatial sampling points.
f (Expression): 1D image sequence.
ft (Expression): Partial derivative of f wrt. time.
fx (Expression): Partial derivative of f wrt. space.
alpha0 (float): Spatial regularisation parameter.
alpha1 (float): Temporal regularisation parameter.
Returns:
v (np.array): A velocity array of shape (m, n).
res (float): The residual.
fun (float): The function value.
"""
# Define mesh and function space.
mesh = UnitSquareMesh(m - 1, n - 1)
V = dh.create_function_space(mesh, 'default')
# Compute velocity.
v, res, fun = of1d_weak_solution(V, f, ft, fx, alpha0, alpha1)
# Convert to array and return.
return dh.funvec2img(v.vector().get_local(), m, n), res, fun
def test_cmscr1d_weak_solution_zero_Dirichlet(self):
print("Running test 'test_cmscr1d_weak_solution_zero_Dirichlet'")
# Define temporal and spatial sample points.
m, n = 10, 20
# Define mesh and function space.
mesh = UnitSquareMesh(m - 1, n - 1)
V = dh.create_function_space(mesh, 'default')
W = dh.create_vector_function_space(mesh, 'default')
# Define boundary conditions for velocity.
bc = DirichletBC(W.sub(0), Constant(0), dh.DirichletBoundary())
# Create zero function.
f = Function(V)
# Compute velocity.
v, k, res, fun, converged = cmscr1d_weak_solution(W, f,
f.dx(0), f.dx(1),
1.0, 1.0,
1.0, 1.0, 1.0,
bcs=bc)
v = v.vector().get_local()
k = k.vector().get_local()
np.testing.assert_allclose(v.shape, m * n)
np.testing.assert_allclose(v, np.zeros_like(v))
np.testing.assert_allclose(k.shape, m * n)
np.testing.assert_allclose(k, np.zeros_like(k))
def cmscr1d_img_pb(img: np.array,
alpha0: float, alpha1: float,
alpha2: float, alpha3: float,
beta: float, deriv='mesh') \
-> (np.array, np.array, float, float, bool):
"""Computes the L2-H1 mass conserving flow with source for a 1D image
sequence with spatio-temporal and convective regularisation with periodic
spatial boundary.
Args:
img (np.array): 1D image sequence of shape (m, n), where m is the
number of time steps and n is the number of pixels.
alpha0 (float): The spatial regularisation parameter for v.
alpha1 (float): The temporal regularisation parameter for v.
alpha2 (float): The spatial regularisation parameter for k.
alpha3 (float): The temporal regularisation parameter for k.
beta (float): The convective regularisation parameter.
deriv (str): Specifies how to approximate pertial derivatives.
When set to 'mesh' it uses FEniCS built in function.
Returns:
v (np.array): A velocity array of shape (m, n).
k (np.array): A source array of shape (m, n).
res (float): The residual.
fun (float): The function value.
converged (bool): True if Newton's method converged.
"""
# Check for valid arguments.
valid = {'mesh'}
if deriv not in valid:
raise ValueError("Argument 'deriv' must be one of %r." % valid)
# Create mesh.
m, n = img.shape
mesh = UnitSquareMesh(m - 1, n - 1)
# Define function space.
V = dh.create_function_space(mesh, 'periodic')
W = dh.create_vector_function_space(mesh, 'periodic')
# Convert array to function.
f = Function(V)
f.vector()[:] = dh.img2funvec_pb(img)
# Compute partial derivatives.
ft, fx = f.dx(0), f.dx(1)
# Compute velocity.
v, k, res, fun, converged = cmscr1d_weak_solution(W, f, ft, fx, alpha0,
alpha1, alpha2, alpha3,
beta)
# Convert back to array and return.
v = dh.funvec2img(v.vector().get_local(), m, n)
k = dh.funvec2img(k.vector().get_local(), m, n)
return v, k, res, fun, converged
def test_cmscr1d_weak_solution_default(self):
print("Running test 'test_cmscr1d_weak_solution_default'")
# Define temporal and spatial sample points.
m, n = 10, 20
# Define mesh and function space.
mesh = UnitSquareMesh(m - 1, n - 1)
V = dh.create_function_space(mesh, 'default')
W = dh.create_vector_function_space(mesh, 'default')
# Create zero function.
f = Function(V)
# Compute velocity.
v, k, res, fun, converged = cmscr1d_weak_solution(W, f,
f.dx(0), f.dx(1),
1.0, 1.0,
1.0, 1.0, 1.0)
v = v.vector().get_local()
k = k.vector().get_local()
np.testing.assert_allclose(v.shape, m * n)
np.testing.assert_allclose(v, np.zeros_like(v))
np.testing.assert_allclose(k.shape, m * n)
np.testing.assert_allclose(k, np.zeros_like(k))
V = dh.create_function_space(mesh, 'periodic')
# Create zero function.
f = Function(V)
# Compute velocity.
v, k, res, fun, converged = cmscr1d_weak_solution(W, f,
f.dx(0), f.dx(1),
1.0, 1.0, 1.0,
1.0, 1.0)
v = v.vector().get_local()
k = k.vector().get_local()
np.testing.assert_allclose(v.shape, m * n)
np.testing.assert_allclose(v, np.zeros_like(v))
np.testing.assert_allclose(k.shape, m * n)
np.testing.assert_allclose(k, np.zeros_like(k))
def of1d_img(img: np.array, alpha0: float, alpha1: float, deriv) \
-> (np.array, float, float):
"""Computes the L2-H1 optical flow for a 1D image sequence.
Takes a one-dimensional image sequence and returns a minimiser of the
Horn-Schunck functional with spatio-temporal regularisation.
Allows to specify how to approximate partial derivatives of f numerically.
Args:
img (np.array): 1D image sequence of shape (m, n), where m is the
number of time steps and n is the number of pixels.
alpha0 (float): Spatial regularisation parameter.
alpha1 (float): Temporal regularisation parameter.
deriv (str): Specifies how to approximate pertial derivatives.
When set to 'mesh' it uses FEniCS built in function.
When set to 'fd' it uses finite differences.
Returns:
v (np.array): A velocity array of shape (m, n).
res (float): The residual.
fun (float): The function value.
"""
# Check for valid arguments.
valid = {'mesh', 'fd'}
if deriv not in valid:
raise ValueError("Argument 'deriv' must be one of %r." % valid)
# Create mesh.
m, n = img.shape
mesh = UnitSquareMesh(m - 1, n - 1)
# Define function space.
V = dh.create_function_space(mesh, 'default')
# Convert array to function.
f = Function(V)
f.vector()[:] = dh.img2funvec(img)
# Compute partial derivatives.
if deriv is 'mesh':
ft, fx = f.dx(0), f.dx(1)
if deriv is 'fd':
imgt, imgx = nh.partial_derivatives(img)
ft, fx = Function(V), Function(V)
ft.vector()[:] = dh.img2funvec(imgt)
fx.vector()[:] = dh.img2funvec(imgx)
# Compute velocity.
v, res, fun = of1d_weak_solution(V, f, ft, fx, alpha0, alpha1)
# Convert to array and return.
return dh.funvec2img(v.vector().get_local(), m, n), res, fun
def mpi1d_exp_pb(m: int, n: int, f: Expression, ft: Expression,
fx: Expression) -> (np.array, np.array):
# Define mesh and function space.
mesh = UnitSquareMesh(m - 1, n - 1)
V = dh.create_function_space(mesh, 'periodic')
# Compute velocity.
v, k = mpi1d_weak_solution(V, f, ft, fx)
# Convert back to array and return.
v = dh.funvec2img_pb(v.vector().get_local(), m, n)
k = dh.funvec2img_pb(k.vector().get_local(), m, n)
return v, k
def cm1d_img_pb(img: np.array,
alpha0: float,
alpha1: float,
deriv='mesh') -> np.array:
"""Computes the L2-H1 mass conserving flow for a 1D image sequence with
periodic spatial boundary.
Allows to specify how to approximate partial derivatives of f numerically.
Note that the last column of img is ignored.
Args:
img (np.array): 1D image sequence of shape (m, n), where m is the
number of time steps and n is the number of pixels.
alpha0 (float): Spatial regularisation parameter.
alpha1 (float): Temporal regularisation parameter.
deriv (str): Specifies how to approximate pertial derivatives.
When set to 'mesh' it uses FEniCS built in function.
Returns:
v (np.array): A velocity array of shape (m, n).
res (float): The residual.
func (float): The value of the functional.
"""
# Check for valid arguments.
valid = {'mesh'}
if deriv not in valid:
raise ValueError("Argument 'deriv' must be one of %r." % valid)
# Create mesh.
m, n = img.shape
mesh = UnitSquareMesh(m - 1, n - 1)
# Define function space.
V = dh.create_function_space(mesh, 'periodic')
# Convert array to function.
f = Function(V)
f.vector()[:] = dh.img2funvec_pb(img)
# Compute partial derivatives.
ft, fx = f.dx(0), f.dx(1)
# Compute velocity.
v, res, fun = cm1d_weak_solution(V, f, ft, fx, alpha0, alpha1)
# Convert to array and return.
return dh.funvec2img_pb(v.vector().get_local(), m, n), res, fun
alpha1 = 1e-3 # v_t alpha2 = 1e-4 # k_x alpha3 = 1e-4 # k_t beta = 1e-3 # D_v k gamma = 1e-4 # k # Set parameters of data. w = 0.1 lambdap = 1 / (4 * np.pi) tau = 1.0 c0 = 0.0 # Create mesh and function spaces. m, n = 40, 100 mesh = UnitSquareMesh(m - 1, n - 1) V = dh.create_function_space(mesh, 'default') W = dh.create_function_space(mesh, 'periodic') # Run experiments with decaying data. f = f_decay(degree=2) ft = f_decay_t(degree=1) fx = f_decay_x(degree=1) datastr = DecayingData().string() # Interpolate function. fa = interpolate(f, V) fa = dh.funvec2img(fa.vector().get_local(), m, n) fa_pb = interpolate(f, W) fa_pb = dh.funvec2img_pb(fa_pb.vector().get_local(), m, n)
def cmscr1d_img(img: np.array,
alpha0: float, alpha1: float,
alpha2: float, alpha3: float,
beta: float, deriv, mesh=None, bc='natural') \
-> (np.array, np.array, float, float, bool):
"""Computes the L2-H1 mass conserving flow with source for a 1D image
sequence with spatio-temporal and convective regularisation.
Allows to specify how to approximate partial derivatives of f numerically.
Args:
img (np.array): 1D image sequence of shape (m, n), where m is the
number of time steps and n is the number of pixels.
alpha0 (float): The spatial regularisation parameter for v.
alpha1 (float): The temporal regularisation parameter for v.
alpha2 (float): The spatial regularisation parameter for k.
alpha3 (float): The temporal regularisation parameter for k.
beta (float): The convective regularisation parameter.
deriv (str): Specifies how to approximate pertial derivatives.
When set to 'mesh' it uses FEniCS built in function.
When set to 'fd' it uses finite differences.
mesh: A custom mesh (optional). Must have (m - 1, n - 1) cells.
bc (str): One of {'natural', 'zero', 'zerospace'} for boundary
conditions for the velocity v (optional).
Returns:
v (np.array): A velocity array of shape (m, n).
k (np.array): A source array of shape (m, n).
res (float): The residual.
fun (float): The function value.
converged (bool): True if Newton's method converged.
"""
# Check for valid arguments.
valid = {'mesh', 'fd'}
if deriv not in valid:
raise ValueError("Argument 'deriv' must be one of %r." % valid)
# Create mesh.
m, n = img.shape
if mesh is None:
mesh = UnitSquareMesh(m - 1, n - 1)
# Define function spaces.
V = dh.create_function_space(mesh, 'default')
W = dh.create_vector_function_space(mesh, 'default')
# Convert array to function.
f = Function(V)
f.vector()[:] = dh.img2funvec(img)
# Compute partial derivatives.
if deriv is 'mesh':
ft, fx = f.dx(0), f.dx(1)
if deriv is 'fd':
imgt, imgx = nh.partial_derivatives(img)
ft, fx = Function(V), Function(V)
ft.vector()[:] = dh.img2funvec(imgt)
fx.vector()[:] = dh.img2funvec(imgx)
# Check for valid arguments.
valid = {'natural', 'zero', 'zerospace'}
if bc not in valid:
raise ValueError("Argument 'bc' must be one of %r." % valid)
# Define boundary conditions for velocity.
if bc is 'natural':
bc = []
if bc is 'zero':
bc = DirichletBC(W.sub(0), Constant(0), dh.DirichletBoundary())
if bc is 'zerospace':
bc = DirichletBC(W.sub(0), Constant(0), dh.DirichletBoundarySpace())
# Compute velocity.
v, k, res, fun, converged = cmscr1d_weak_solution(W,
f,
ft,
fx,
alpha0,
alpha1,
alpha2,
alpha3,
beta,
bcs=bc)
# Convert back to array and return.
v = dh.funvec2img(v.vector().get_local(), m, n)
k = dh.funvec2img(k.vector().get_local(), m, n)
return v, k, res, fun, converged