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_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_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())
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))
z1 = operator.domain_geometry()
