def test_GradientOperator_4D_allocate(self):
nc, nz, ny, nx = 3, 4, 5, 6
size = nc * nz * ny * nx
dim = [nc, nz, ny, nx]
ig = ImageGeometry(voxel_num_x=nx, voxel_num_y=ny, voxel_num_z=nz, channels=nc)
arr = numpy.arange(size).reshape(dim).astype(numpy.float32)**2
data = ig.allocate()
data.fill(arr)
#numpy
grad1 = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='numpy')
gold_direct = grad1.direct(data)
gold_adjoint = grad1.adjoint(gold_direct)
grad2 = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='numpy')
out_direct = grad2.range_geometry().allocate()
out_adjoint = grad2.domain_geometry().allocate()
grad2.direct(data, out=out_direct)
grad2.adjoint(out_direct, out=out_adjoint)
#print("GradientOperatorOperator, 4D, bnd_cond='Neumann', direct")
numpy.testing.assert_array_equal(out_direct.get_item(0).as_array(), gold_direct.get_item(0).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(1).as_array(), gold_direct.get_item(1).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(2).as_array(), gold_direct.get_item(2).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(3).as_array(), gold_direct.get_item(3).as_array())
#print("GradientOperator, 4D, bnd_cond='Neumann', adjoint")
numpy.testing.assert_array_equal(out_adjoint.as_array(), gold_adjoint.as_array())
#c
grad1 = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='c')
gold_direct = grad1.direct(data)
gold_adjoint = grad1.adjoint(gold_direct)
grad2 = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='c')
out_direct = grad2.range_geometry().allocate()
out_adjoint = grad2.domain_geometry().allocate()
grad2.direct(data, out=out_direct)
grad2.adjoint(out_direct, out=out_adjoint)
#print("GradientOperator, 4D, bnd_cond='Neumann', direct")
numpy.testing.assert_array_equal(out_direct.get_item(0).as_array(), gold_direct.get_item(0).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(1).as_array(), gold_direct.get_item(1).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(2).as_array(), gold_direct.get_item(2).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(3).as_array(), gold_direct.get_item(3).as_array())
#print("GradientOperator, 4D, bnd_cond='Neumann', adjoint")
numpy.testing.assert_array_equal(out_adjoint.as_array(), gold_adjoint.as_array())
def test_SymmetrisedGradientOperator3b(self):
###########################################################################
# 3D geometry no channels
#ig3 = ImageGeometry(N, M, K)
Grad3 = GradientOperator(self.ig3, correlation='Space')
E3 = SymmetrisedGradientOperator(Grad3.range_geometry())
numpy.random.seed(1)
u3 = E3.domain_geometry().allocate('random')
w3 = E3.range_geometry().allocate('random', symmetry=True)
#
lhs3 = E3.direct(u3).dot(w3)
rhs3 = u3.dot(E3.adjoint(w3))
# with numpy 1.11 and py 3.5 decimal = 3
decimal = 4
npv = version.parse(numpy.version.version)
if npv.major == 1 and npv.minor == 11:
print("########## SETTING decimal to 3 ###########")
decimal = 3
numpy.testing.assert_almost_equal(lhs3, rhs3, decimal=decimal)
# self.assertAlmostEqual(lhs3, rhs3, )
print("*******", lhs3, rhs3, abs((rhs3 - lhs3) / rhs3), 1.5 * 10**(-4),
abs((rhs3 - lhs3) / rhs3) < 1.5 * 10**(-4))
self.assertTrue(
LinearOperator.dot_test(E3,
range_init=w3,
domain_init=u3,
decimal=decimal))
def test_SymmetrisedGradientOperator2a(self):
###########################################################################
# 2D geometry with channels
# ig2 = ImageGeometry(N, M, channels = C)
Grad2 = GradientOperator(self.ig2, correlation='Space')
E2 = SymmetrisedGradientOperator(Grad2.range_geometry())
numpy.testing.assert_almost_equal(E2.norm(iterations=self.iterations),
numpy.sqrt(8),
decimal=self.decimal)
def test_SymmetrisedGradientOperator3a(self):
###########################################################################
# 3D geometry no channels
#ig3 = ImageGeometry(N, M, K)
Grad3 = GradientOperator(self.ig3, correlation='Space')
E3 = SymmetrisedGradientOperator(Grad3.range_geometry())
norm = LinearOperator.PowerMethod(E3, max_iteration=100, tolerance=0)
numpy.testing.assert_almost_equal(norm,
numpy.sqrt(12),
decimal=self.decimal)
def test_SymmetrisedGradientOperator1a(self):
###########################################################################
## Symmetrized Gradient Tests
print("Test SymmetrisedGradientOperator")
###########################################################################
# 2D geometry no channels
# ig = ImageGeometry(N, M)
Grad = GradientOperator(self.ig)
E1 = SymmetrisedGradientOperator(Grad.range_geometry())
numpy.testing.assert_almost_equal(E1.norm(iterations=self.iterations),
numpy.sqrt(8),
decimal=self.decimal)
def test_SymmetrisedGradientOperator3a(self):
###########################################################################
# 3D geometry no channels
#ig3 = ImageGeometry(N, M, K)
Grad3 = GradientOperator(self.ig3, correlation='Space')
E3 = SymmetrisedGradientOperator(Grad3.range_geometry())
norm1 = E3.norm()
norm2 = E3.calculate_norm(iterations=100)
print(norm1, norm2)
numpy.testing.assert_almost_equal(norm2,
numpy.sqrt(12),
decimal=self.decimal)
def test_SymmetrisedGradientOperator2(self):
###########################################################################
# 2D geometry with channels
# ig2 = ImageGeometry(N, M, channels = C)
Grad2 = GradientOperator(self.ig2, correlation='Space')
E2 = SymmetrisedGradientOperator(Grad2.range_geometry())
numpy.random.seed(1)
u2 = E2.domain_geometry().allocate('random')
w2 = E2.range_geometry().allocate('random', symmetry=True)
#
lhs2 = E2.direct(u2).dot(w2)
rhs2 = u2.dot(E2.adjoint(w2))
numpy.testing.assert_allclose(lhs2, rhs2, rtol=1e-3)
def test_TranslateFunction_MixedL21Norm(self):
print("Test for TranslateFunction for MixedL21Norm")
ig = ImageGeometry(4, 4)
Grad = GradientOperator(ig)
b = Grad.range_geometry().allocate('random', seed=10)
alpha = 0.4
f1 = alpha * MixedL21Norm()
fun = TranslateFunction(f1, b)
tmp_x = Grad.range_geometry().allocate('random', seed=10)
res1 = fun(tmp_x)
res2 = f1(tmp_x - b)
self.assertAlmostEqual(res1, res2)
print("Check call...OK")
res1 = f1.convex_conjugate(tmp_x) - b.dot(tmp_x)
res2 = fun.convex_conjugate(tmp_x)
self.assertAlmostEqual(res1, res2)
print("Check convex conjugate...OK (maybe inf=inf)")
tau = 0.4
res1 = fun.proximal(tmp_x, tau)
res2 = f1.proximal(tmp_x - b, tau) + b
self.assertNumpyArrayAlmostEqual(
res1.get_item(0).as_array(),
res2.get_item(0).as_array())
self.assertNumpyArrayAlmostEqual(
res1.get_item(1).as_array(),
res2.get_item(1).as_array())
print("Check prox...OK ")
def test_SymmetrisedGradientOperator1b(self):
###########################################################################
## Symmetrized GradientOperator Tests
print("Test SymmetrisedGradientOperator")
###########################################################################
# 2D geometry no channels
# ig = ImageGeometry(N, M)
Grad = GradientOperator(self.ig)
E1 = SymmetrisedGradientOperator(Grad.range_geometry())
numpy.random.seed(1)
u1 = E1.domain_geometry().allocate('random')
w1 = E1.range_geometry().allocate('random', symmetry=True)
lhs = E1.direct(u1).dot(w1)
rhs = u1.dot(E1.adjoint(w1))
print("lhs {} rhs {}".format(lhs, rhs))
# self.assertAlmostEqual(lhs, rhs)
numpy.testing.assert_allclose(lhs, rhs, rtol=1e-3)
def test_SymmetrisedGradientOperator3b(self):
###########################################################################
# 3D geometry no channels
#ig3 = ImageGeometry(N, M, K)
Grad3 = GradientOperator(self.ig3, correlation='Space')
E3 = SymmetrisedGradientOperator(Grad3.range_geometry())
numpy.random.seed(1)
u3 = E3.domain_geometry().allocate('random')
w3 = E3.range_geometry().allocate('random', symmetry=True)
#
lhs3 = E3.direct(u3).dot(w3)
rhs3 = u3.dot(E3.adjoint(w3))
numpy.testing.assert_almost_equal(lhs3, rhs3, decimal=3)
print("*******", lhs3, rhs3, abs((rhs3 - lhs3) / rhs3), 1.5 * 10**(-4),
abs((rhs3 - lhs3) / rhs3) < 1.5 * 10**(-4))
self.assertTrue(
LinearOperator.dot_test(E3,
range_init=w3,
domain_init=u3,
decimal=3))
###########################################################################
## Symmetrized GradientOperator Tests
from cil.framework import ImageGeometry
from cil.optimisation.operators import GradientOperator
import numpy as np
N, M = 2, 3
K = 2
C = 2
###########################################################################
# 2D geometry no channels
ig = ImageGeometry(N, M)
Grad = GradientOperator(ig)
E1 = SymmetrizedGradientOperator(Grad.range_geometry())
np.testing.assert_almost_equal(E1.norm(), np.sqrt(8), 1e-5)
print(E1.domain_geometry().shape, E1.range_geometry().shape)
u1 = E1.domain_geometry().allocate('random_int')
w1 = E1.range_geometry().allocate('random_int', symmetry=True)
lhs = E1.direct(u1).dot(w1)
rhs = u1.dot(E1.adjoint(w1))
np.testing.assert_almost_equal(lhs, rhs)
###########################################################################
# 2D geometry with channels
ig2 = ImageGeometry(N, M, channels=C)
Grad2 = GradientOperator(ig2, correlation='Space')
def test_FiniteDifference(self):
print("test FiniteDifference")
##
N, M = 2, 3
numpy.random.seed(1)
ig = ImageGeometry(N, M)
Id = IdentityOperator(ig)
FD = FiniteDifferenceOperator(ig, direction=0, bnd_cond='Neumann')
u = FD.domain_geometry().allocate('random')
res = FD.domain_geometry().allocate(ImageGeometry.RANDOM)
FD.adjoint(u, out=res)
w = FD.adjoint(u)
self.assertNumpyArrayEqual(res.as_array(), w.as_array())
res = Id.domain_geometry().allocate(ImageGeometry.RANDOM)
Id.adjoint(u, out=res)
w = Id.adjoint(u)
self.assertNumpyArrayEqual(res.as_array(), w.as_array())
self.assertNumpyArrayEqual(u.as_array(), w.as_array())
G = GradientOperator(ig)
u = G.range_geometry().allocate(ImageGeometry.RANDOM)
res = G.domain_geometry().allocate()
G.adjoint(u, out=res)
w = G.adjoint(u)
self.assertNumpyArrayEqual(res.as_array(), w.as_array())
u = G.domain_geometry().allocate(ImageGeometry.RANDOM)
res = G.range_geometry().allocate()
G.direct(u, out=res)
w = G.direct(u)
self.assertBlockDataContainerEqual(res, w)
# 2D
M, N = 2, 3
ig = ImageGeometry(voxel_num_x=M,
voxel_num_y=N,
voxel_size_x=0.1,
voxel_size_y=0.4)
x = ig.allocate('random')
labels = ["horizontal_y", "horizontal_x"]
for i, dir in enumerate(labels):
FD1 = FiniteDifferenceOperator(ig, direction=i)
res1 = FD1.direct(x)
res1b = FD1.adjoint(x)
FD2 = FiniteDifferenceOperator(ig, direction=labels[i])
res2 = FD2.direct(x)
res2b = FD2.adjoint(x)
numpy.testing.assert_almost_equal(res1.as_array(), res2.as_array())
numpy.testing.assert_almost_equal(res1b.as_array(),
res2b.as_array())
print("Check 2D FiniteDiff for label {}".format(labels[i]))
# 2D + chan
M, N, K = 2, 3, 4
ig1 = ImageGeometry(voxel_num_x=M,
voxel_num_y=N,
channels=K,
voxel_size_x=0.1,
voxel_size_y=0.4)
print(ig1.dimension_labels)
x = ig1.allocate('random')
labels = ["channel", "horizontal_y", "horizontal_x"]
for i, dir in enumerate(labels):
FD1 = FiniteDifferenceOperator(ig1, direction=i)
res1 = FD1.direct(x)
res1b = FD1.adjoint(x)
FD2 = FiniteDifferenceOperator(ig1, direction=labels[i])
res2 = FD2.direct(x)
res2b = FD2.adjoint(x)
numpy.testing.assert_almost_equal(res1.as_array(), res2.as_array())
numpy.testing.assert_almost_equal(res1b.as_array(),
res2b.as_array())
print("Check for 2D chan for FiniteDiff label {}".format(
labels[i]))
def test_GradientOperator(self):
N, M, K = 20, 30, 40
channels = 10
numpy.random.seed(1)
# check range geometry, examples
ig1 = ImageGeometry(voxel_num_x = M, voxel_num_y = N)
ig3 = ImageGeometry(voxel_num_x = M, voxel_num_y = N, channels = channels)
ig4 = ImageGeometry(voxel_num_x = M, voxel_num_y = N, channels = channels, voxel_num_z= K)
G1 = GradientOperator(ig1, correlation = 'Space', backend='numpy')
print(G1.range_geometry().shape, '2D no channels')
G4 = GradientOperator(ig3, correlation = 'SpaceChannels', backend='numpy')
print(G4.range_geometry().shape, '2D with channels corr')
G5 = GradientOperator(ig3, correlation = 'Space', backend='numpy')
print(G5.range_geometry().shape, '2D with channels no corr')
G6 = GradientOperator(ig4, correlation = 'Space', backend='numpy')
print(G6.range_geometry().shape, '3D with channels no corr')
G7 = GradientOperator(ig4, correlation = 'SpaceChannels', backend='numpy')
print(G7.range_geometry().shape, '3D with channels with corr')
u = ig1.allocate(ImageGeometry.RANDOM)
w = G1.range_geometry().allocate(ImageGeometry.RANDOM)
LHS = (G1.direct(u)*w).sum()
RHS = (u * G1.adjoint(w)).sum()
numpy.testing.assert_approx_equal(LHS, RHS, significant = 1)
numpy.testing.assert_approx_equal(G1.norm(), numpy.sqrt(2*4), significant = 1)
u1 = ig3.allocate('random')
w1 = G4.range_geometry().allocate('random')
LHS1 = (G4.direct(u1) * w1).sum()
RHS1 = (u1 * G4.adjoint(w1)).sum()
numpy.testing.assert_approx_equal(LHS1, RHS1, significant=1)
numpy.testing.assert_almost_equal(G4.norm(), numpy.sqrt(3*4), decimal = 0)
u2 = ig4.allocate('random')
w2 = G7.range_geometry().allocate('random')
LHS2 = (G7.direct(u2) * w2).sum()
RHS2 = (u2 * G7.adjoint(w2)).sum()
numpy.testing.assert_approx_equal(LHS2, RHS2, significant = 3)
numpy.testing.assert_approx_equal(G7.norm(), numpy.sqrt(3*4), significant = 1)
#check direct/adjoint for space/channels correlation
ig_channel = ImageGeometry(voxel_num_x = 2, voxel_num_y = 3, channels = 2)
G_no_channel = GradientOperator(ig_channel, correlation = 'Space', backend='numpy')
G_channel = GradientOperator(ig_channel, correlation = 'SpaceChannels', backend='numpy')
u3 = ig_channel.allocate('random_int')
res_no_channel = G_no_channel.direct(u3)
res_channel = G_channel.direct(u3)
print(" Derivative for 3 directions, first is wrt Channel direction\n")
print(res_channel[0].as_array())
print(res_channel[1].as_array())
print(res_channel[2].as_array())
print(" Derivative for 2 directions, no Channel direction\n")
print(res_no_channel[0].as_array())
print(res_no_channel[1].as_array())
ig2D = ImageGeometry(voxel_num_x = 2, voxel_num_y = 3)
u4 = ig2D.allocate('random_int')
G2D = GradientOperator(ig2D, backend='numpy')
res = G2D.direct(u4)
print(res[0].as_array())
print(res[1].as_array())
M, N = 20, 30
ig = ImageGeometry(M, N)
# check direct of GradientOperator and sparse matrix
G = GradientOperator(ig, backend='numpy')
norm1 = G.norm(iterations=300)
print ("should be sqrt(8) {} {}".format(numpy.sqrt(8), norm1))
numpy.testing.assert_almost_equal(norm1, numpy.sqrt(8), decimal=1)
ig4 = ImageGeometry(M,N, channels=3)
G4 = GradientOperator(ig4, correlation="SpaceChannels", backend='numpy')
norm4 = G4.norm(iterations=300)
print("should be sqrt(12) {} {}".format(numpy.sqrt(12), norm4))
self.assertTrue((norm4 - numpy.sqrt(12))/norm4 < 0.2)
def test_GradientOperator_for_pseudo_2D_geometries(self):
numpy.random.seed(1)
# ImageGeometry shape (5,5,1)
ig1 = ImageGeometry(voxel_num_x=1,
voxel_num_y=5,
voxel_num_z=5,
voxel_size_x=0.4,
voxel_size_y=0.2,
voxel_size_z=0.6)
# ImageGeometry shape (1,5,5)
ig2 = ImageGeometry(voxel_num_x=5,
voxel_num_y=5,
voxel_num_z=1,
voxel_size_x=0.1,
voxel_size_y=0.2,
voxel_size_z=0.4)
# ImageGeometry shape (5,1,5)
ig3 = ImageGeometry(voxel_num_x=5,
voxel_num_y=1,
voxel_num_z=5,
voxel_size_x=0.6,
voxel_size_y=0.4,
voxel_size_z=0.3)
data1 = ig1.allocate('random')
data2 = ig2.allocate('random')
data3 = ig3.allocate('random')
data = [data1, data2, data3]
ig = [ig1, ig2, ig3]
for i in range(3):
########################################
##### Test Gradient numpy backend #####
########################################
Grad_numpy = GradientOperator(ig[i], backend='numpy')
res1 = Grad_numpy.direct(data[i])
res2 = Grad_numpy.range_geometry().allocate()
Grad_numpy.direct(data[i], out=res2)
# test direct with and without out
numpy.testing.assert_array_almost_equal(res1[0].as_array(),
res2[0].as_array())
numpy.testing.assert_array_almost_equal(res1[1].as_array(),
res2[1].as_array())
# test adjoint with and without out
res3 = Grad_numpy.adjoint(res1)
res4 = Grad_numpy.domain_geometry().allocate()
Grad_numpy.adjoint(res2, out=res4)
numpy.testing.assert_array_almost_equal(res3.as_array(),
res4.as_array())
# test dot_test
for sd in [5, 10, 15]:
self.assertTrue(LinearOperator.dot_test(Grad_numpy, seed=sd))
# test shape of output of direct
self.assertEqual(res1[0].shape, ig[i].shape)
self.assertEqual(res1.shape, (2, 1))
########################################
##### Test Gradient c backend #####
########################################
Grad_c = GradientOperator(ig[i], backend='c')
# test direct with and without out
res5 = Grad_c.direct(data[i])
res6 = Grad_c.range_geometry().allocate() * 0.
Grad_c.direct(data[i], out=res6)
numpy.testing.assert_array_almost_equal(res5[0].as_array(),
res6[0].as_array())
numpy.testing.assert_array_almost_equal(res5[1].as_array(),
res6[1].as_array())
# test adjoint
res7 = Grad_c.adjoint(res5)
res8 = Grad_c.domain_geometry().allocate() * 0.
Grad_c.adjoint(res5, out=res8)
numpy.testing.assert_array_almost_equal(res7.as_array(),
res8.as_array())
# test dot_test
for sd in [5, 10, 15]:
self.assertTrue(LinearOperator.dot_test(Grad_c, seed=sd))
# test direct numpy vs direct c backends (with and without out)
numpy.testing.assert_array_almost_equal(res5[0].as_array(),
res1[0].as_array())
numpy.testing.assert_array_almost_equal(res6[1].as_array(),
res2[1].as_array())
u = ig.allocate('random_int')
z1 = B.direct(u)
res = B.range_geometry().allocate()
B.direct(u, out=res)
###########################################################################
# Block Operator for TGV reconstruction
M, N = 2, 3
ig = ImageGeometry(M, N)
ag = ig
op11 = GradientOperator(ig)
op12 = IdentityOperator(op11.range_geometry())
op22 = SymmetrisedGradientOperator(op11.domain_geometry())
op21 = ZeroOperator(ig, op22.range_geometry())
op31 = IdentityOperator(ig, ag)
op32 = ZeroOperator(op22.domain_geometry(), ag)
operator = BlockOperator(op11,
-1 * op12,
op21,
op22,
op31,
op32,
shape=(3, 2))
