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()