def test_axpby2(self): # test axpby with BlockDataContainer and DataContainer ig0 = ImageGeometry(2, 3, 4) # ig1 = ImageGeometry(2,3,5) data0 = ig0.allocate(-1) data2 = ig0.allocate(1) data1 = ig0.allocate(2) # data3 = ig1.allocate(3) cp0 = BlockDataContainer(data0, data2) # cp1 = BlockDataContainer(data1,data3) out = cp0 * 0. - 10 cp0.axpby(3, -2, data1, out) # operation should be [ 3 * -1 + (-2) * 2 , 3 * 1 + (-2) * 2 ] # output should be [ -7 , -1 ] res0 = ig0.allocate(-7) res2 = ig0.allocate(-1) res = BlockDataContainer(res0, res2) self.assertBlockDataContainerEqual(out, res)
def test_sapyb_datacontainer_c(self): #a vec, b vec ig = ImageGeometry(10,10) d1 = ig.allocate(dtype=numpy.complex64) d2 = ig.allocate(dtype=numpy.complex64) a = ig.allocate(dtype=numpy.complex64) b = ig.allocate(dtype=numpy.complex64) arr = numpy.empty(ig.shape, dtype=numpy.complex64) arr.real = numpy.asarray(numpy.arange(1,101).reshape(10,10), dtype=numpy.float32) arr.imag = numpy.asarray(numpy.arange(1,101).reshape(10,10), dtype=numpy.float32) d1.fill(arr) arr.imag = -1* arr.imag d2.fill(arr) a.fill(d2.as_array()) b.fill(d1.as_array()) out = ig.allocate(-1,dtype=numpy.complex64) # equals to d1^ * d1 + d2^*d2 = d1**2 + d2**2 = 2* arr.norm = 2 * (arr.real **2 + arr.imag **2) out = d1.sapyb(a,d2,b) res = 2* (arr.real * arr.real + arr.imag * arr.imag) numpy.testing.assert_array_equal(res, out.as_array()) out.fill(0) d1.sapyb(a,d2,b, out) numpy.testing.assert_array_equal(res, out.as_array())
def test_axpby(self): # test axpby between BlockDataContainers ig0 = ImageGeometry(2,3,4) ig1 = ImageGeometry(2,3,5) data0 = ig0.allocate(-1) data2 = ig0.allocate(1) data1 = ig0.allocate(2) data3 = ig0.allocate(3) cp0 = BlockDataContainer(data0,data2) cp1 = BlockDataContainer(data1,data3) out = cp0 * 0. - 10 cp0.axpby(3,-2,cp1,out, num_threads=4) # operation should be [ 3 * -1 + (-2) * 2 , 3 * 1 + (-2) * 3 ] # output should be [ -7 , -3 ] res0 = ig0.allocate(-7) res2 = ig0.allocate(-3) res = BlockDataContainer(res0, res2) print ("res0", res0.as_array()) print ("res2", res2.as_array()) print ("###############################") print ("out_0", out.get_item(0).as_array()) print ("out_1", out.get_item(1).as_array()) self.assertBlockDataContainerEqual(out, res)
def test_FISTA_catch_Lipschitz(self): if debug_print: print("Test FISTA catch Lipschitz") ig = ImageGeometry(127, 139, 149) initial = ImageData(geometry=ig) initial = ig.allocate() b = initial.copy() # fill with random numbers b.fill(numpy.random.random(initial.shape)) initial = ig.allocate(ImageGeometry.RANDOM) identity = IdentityOperator(ig) #### it seems FISTA does not work with Nowm2Sq norm2sq = LeastSquares(identity, b) if debug_print: print('Lipschitz', norm2sq.L) # norm2sq.L = None #norm2sq.L = 2 * norm2sq.c * identity.norm()**2 #norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity) opt = {'tol': 1e-4, 'memopt': False} if debug_print: print("initial objective", norm2sq(initial)) try: alg = FISTA(initial=initial, f=L1Norm(), g=ZeroFunction()) self.assertTrue(False) except ValueError as ve: print(ve) self.assertTrue(True)
def test_ConstantFunction(self): M, N, K = 3,4,5 ig = ImageGeometry(M, N, K) tmp = ig.allocate('random_int') constant = 10 f = ConstantFunction(constant) # check call res1 = f(tmp) self.assertAlmostEqual(res1, constant) # check gradient with and without out res1 = f.gradient(tmp) out = ig.allocate() self.assertNumpyArrayAlmostEqual(res1.as_array(), out) out1 = ig.allocate() f.gradient(tmp, out=out1) self.assertNumpyArrayAlmostEqual(res1.as_array(), out1) # check convex conjugate res1 = f.convex_conjugate(tmp) res2 = tmp.maximum(0).sum() self.assertNumpyArrayAlmostEqual(res1.as_array(), res2.as_array()) # check proximal tau = 0.4 res1 = f.proximal(tmp, tau) self.assertNumpyArrayAlmostEqual(res1.as_array(), tmp.as_array())
def test_axpby_b_blockdc(self): # test axpby between BlockDataContainers, with b as a blockdatacontainer ig0 = ImageGeometry(2, 3, 4) ig1 = ImageGeometry(2, 3, 5) data0 = ig0.allocate(-1) data2 = ig0.allocate(1) data1 = ig0.allocate(2) data3 = ig0.allocate(3) b1 = ig0.allocate(-2) b2 = ig0.allocate(-3) cp0 = BlockDataContainer(data0, data2) cp1 = BlockDataContainer(data1, data3) b = BlockDataContainer(b1, b2) out = cp0 * 0. - 10 cp0.axpby(3, b, cp1, out, num_threads=4) # operation should be [ 3 * -1 + (-2) * 2 , 3 * 1 + (-3) * 3 ] # output should be [ -7 , -3 ] res0 = ig0.allocate(-7) res2 = ig0.allocate(-6) res = BlockDataContainer(res0, res2) self.assertBlockDataContainerEqual(out, res)
def test_ImageDataSubset(self): new_order = ['horizontal_x', 'channel', 'horizontal_y'] vgeometry = ImageGeometry(voxel_num_x=4, voxel_num_y=3, channels=2, dimension_labels=new_order) # expected dimension_labels self.assertListEqual(new_order, list(vgeometry.dimension_labels)) vol = vgeometry.allocate() # test reshape new_order = ['channel', 'horizontal_y','horizontal_x'] vol.reorder(new_order) self.assertListEqual(new_order, list(vol.geometry.dimension_labels)) ss1 = vol.get_slice(horizontal_x = 0) self.assertListEqual(['channel', 'horizontal_y'], list(ss1.geometry.dimension_labels)) vg = ImageGeometry(3,4,5,channels=2) self.assertListEqual([ImageGeometry.CHANNEL, ImageGeometry.VERTICAL, ImageGeometry.HORIZONTAL_Y, ImageGeometry.HORIZONTAL_X], list(vg.dimension_labels)) ss2 = vg.allocate() ss3 = vol.get_slice(channel=0) self.assertListEqual([ImageGeometry.HORIZONTAL_Y, ImageGeometry.HORIZONTAL_X], list(ss3.geometry.dimension_labels))
def test_ImageData(self): # create ImageData from geometry vgeometry = ImageGeometry(voxel_num_x=4, voxel_num_y=3, channels=2) #vol = ImageData(geometry=vgeometry) vol = vgeometry.allocate() self.assertEqual(vol.shape, (2, 3, 4)) vol1 = vol + 1 self.assertNumpyArrayEqual(vol1.as_array(), numpy.ones(vol.shape)) vol1 = vol - 1 self.assertNumpyArrayEqual(vol1.as_array(), -numpy.ones(vol.shape)) vol1 = 2 * (vol + 1) self.assertNumpyArrayEqual(vol1.as_array(), 2 * numpy.ones(vol.shape)) vol1 = (vol + 1) / 2 self.assertNumpyArrayEqual(vol1.as_array(), numpy.ones(vol.shape) / 2) vol1 = vol + 1 self.assertEqual(vol1.sum(), 2*3*4) vol1 = (vol + 2) ** 2 self.assertNumpyArrayEqual(vol1.as_array(), numpy.ones(vol.shape) * 4) self.assertEqual(vol.number_of_dimensions, 3) ig2 = ImageGeometry (voxel_num_x=2,voxel_num_y=3,voxel_num_z=4, dimension_labels=[ImageGeometry.HORIZONTAL_X, ImageGeometry.HORIZONTAL_Y, ImageGeometry.VERTICAL]) data = ig2.allocate() self.assertNumpyArrayEqual(numpy.asarray(data.shape), numpy.asarray(ig2.shape)) self.assertNumpyArrayEqual(numpy.asarray(data.shape), data.as_array().shape)
def test_GD(self): print("Test GD") ig = ImageGeometry(12, 13, 14) initial = ig.allocate() # b = initial.copy() # fill with random numbers # b.fill(numpy.random.random(initial.shape)) b = ig.allocate('random') identity = IdentityOperator(ig) norm2sq = LeastSquares(identity, b) rate = norm2sq.L / 3. alg = GD(initial=initial, objective_function=norm2sq, rate=rate, atol=1e-9, rtol=1e-6) alg.max_iteration = 1000 alg.run(verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) alg = GD(initial=initial, objective_function=norm2sq, rate=rate, max_iteration=20, update_objective_interval=2, atol=1e-9, rtol=1e-6) alg.max_iteration = 20 self.assertTrue(alg.max_iteration == 20) self.assertTrue(alg.update_objective_interval == 2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
def test_mixedL12Norm(self): numpy.random.seed(1) M, N, K = 2, 3, 5 ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N) u1 = ig.allocate('random') u2 = ig.allocate('random') U = BlockDataContainer(u1, u2, shape=(2, 1)) # Define no scale and scaled f_no_scaled = MixedL21Norm() f_scaled = 1 * MixedL21Norm() # call a1 = f_no_scaled(U) a2 = f_scaled(U) self.assertNumpyArrayAlmostEqual(a1, a2) tmp = [el**2 for el in U.containers] self.assertBlockDataContainerEqual(BlockDataContainer(*tmp), U.power(2)) z1 = f_no_scaled.proximal_conjugate(U, 1) u3 = ig.allocate('random') u4 = ig.allocate('random') z3 = BlockDataContainer(u3, u4, shape=(2, 1)) f_no_scaled.proximal_conjugate(U, 1, out=z3) self.assertBlockDataContainerAlmostEqual(z3, z1, decimal=5)
def test_CGLS(self): print("Test CGLS") #ig = ImageGeometry(124,153,154) ig = ImageGeometry(10, 2) numpy.random.seed(2) initial = ig.allocate(0.) b = ig.allocate('random') # b = initial.copy() # fill with random numbers # b.fill(numpy.random.random(initial.shape)) # b = ig.allocate() # bdata = numpy.reshape(numpy.asarray([i for i in range(20)]), (2,10)) # b.fill(bdata) identity = IdentityOperator(ig) alg = CGLS(initial=initial, operator=identity, data=b) alg.max_iteration = 200 alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) alg = CGLS(initial=initial, operator=identity, data=b, max_iteration=200, update_objective_interval=2) self.assertTrue(alg.max_iteration == 200) self.assertTrue(alg.update_objective_interval == 2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
def test_ChannelwiseOperator(self): print("test_ChannelwiseOperator") M = 3 channels = 4 ig = ImageGeometry(M, M, channels=channels) igs = ImageGeometry(M, M) x = ig.allocate('random', seed=100) diag = igs.allocate('random', seed=101) D = DiagonalOperator(diag) C = ChannelwiseOperator(D, channels) y = C.direct(x) y2 = ig.allocate() C.direct(x, y2) for c in range(channels): numpy.testing.assert_array_equal(y.subset(channel=2).as_array(), \ (diag*x.subset(channel=2)).as_array()) numpy.testing.assert_array_equal(y2.subset(channel=2).as_array(), \ (diag*x.subset(channel=2)).as_array()) z = C.adjoint(y) z2 = ig.allocate() C.adjoint(y, z2) for c in range(channels): numpy.testing.assert_array_equal(z.subset(channel=2).as_array(), \ (diag*(diag*x.subset(channel=2))).as_array()) numpy.testing.assert_array_equal(z2.subset(channel=2).as_array(), \ (diag*(diag*x.subset(channel=2))).as_array())
def test_FISTA_Norm2Sq(self): print("Test FISTA Norm2Sq") ig = ImageGeometry(127, 139, 149) b = ig.allocate(ImageGeometry.RANDOM) # fill with random numbers initial = ig.allocate(ImageGeometry.RANDOM) identity = IdentityOperator(ig) #### it seems FISTA does not work with Nowm2Sq norm2sq = LeastSquares(identity, b) #norm2sq.L = 2 * norm2sq.c * identity.norm()**2 #norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity) opt = {'tol': 1e-4, 'memopt': False} if debug_print: print("initial objective", norm2sq(initial)) alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction()) alg.max_iteration = 2 alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), max_iteration=2, update_objective_interval=3) self.assertTrue(alg.max_iteration == 2) self.assertTrue(alg.update_objective_interval == 3) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
def test_axpby(self): print ("test axpby") ig = ImageGeometry(10,10) d1 = ig.allocate(1) d2 = ig.allocate(2) out = ig.allocate(None) a = 2 b = 1 # equals to 2 * [1] + 1 * [2] = [4] d1.axpby(a,b,d2,out) res = numpy.ones_like(d1.as_array()) * 4. numpy.testing.assert_array_equal(res, out.as_array())
def test_Norm2sq_as_OperatorCompositionFunction(self): print('Test for OperatorCompositionFunction') M, N = 50, 50 ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N) #numpy.random.seed(1) b = ig.allocate('random', seed=1) print('Check call with IdentityOperator operator... OK\n') operator = 3 * IdentityOperator(ig) u = ig.allocate('random', seed=50) f = 0.5 * L2NormSquared(b=b) func1 = OperatorCompositionFunction(f, operator) func2 = LeastSquares(operator, b, 0.5) print("f.L {}".format(f.L)) print("0.5*f.L {}".format((0.5 * f).L)) print("type func1 {}".format(type(func1))) print("func1.L {}".format(func1.L)) print("func2.L {}".format(func2.L)) print("operator.norm() {}".format(operator.norm())) numpy.testing.assert_almost_equal(func1(u), func2(u)) print('Check gradient with IdentityOperator operator... OK\n') tmp1 = ig.allocate() tmp2 = ig.allocate() res_gradient1 = func1.gradient(u) res_gradient2 = func2.gradient(u) func1.gradient(u, out=tmp1) func2.gradient(u, out=tmp2) self.assertNumpyArrayAlmostEqual(res_gradient1.as_array(), res_gradient2.as_array()) self.assertNumpyArrayAlmostEqual(tmp1.as_array(), tmp2.as_array()) print('Check call with MatrixOperator... OK\n') mat = np.random.randn(M, N) operator = MatrixOperator(mat) vg = VectorGeometry(N) b = vg.allocate('random') u = vg.allocate('random') func1 = OperatorCompositionFunction(0.5 * L2NormSquared(b=b), operator) func2 = LeastSquares(operator, b, 0.5) self.assertNumpyArrayAlmostEqual(func1(u), func2(u)) numpy.testing.assert_almost_equal(func1.L, func2.L)
def test_exception_initial_CGLS(self): if debug_print: print ("Test CGLS") ig = ImageGeometry(10,2) numpy.random.seed(2) initial = ig.allocate(0.) b = ig.allocate('random') identity = IdentityOperator(ig) try: alg = CGLS(initial=initial, operator=identity, data=b, x_init=initial) assert False except ValueError as ve: assert True
def setUp(self): ig0 = ImageGeometry(2, 3, 4) ig1 = ImageGeometry(2, 3, 5) data0 = ig0.allocate(-1) data2 = ig1.allocate(1) # data1 = ig0.allocate(2) # data3 = ig1.allocate(3) cp0 = BlockDataContainer(data0, data2) self.ig0 = ig0 self.ig1 = ig1 self.cp0 = cp0
def test_axpby2(self): print ("test axpby2") N = 100 ig = ImageGeometry(N,2*N,N*10) d1 = ig.allocate(1) d2 = ig.allocate(2) out = ig.allocate(None) a = 2 b = 1 print ("allocated") # equals to 2 * [1] + 1 * [2] = [4] d1.axpby(a,b,d2,out, num_threads=4) print ("calculated") res = numpy.ones_like(d1.as_array()) * 4. numpy.testing.assert_array_equal(res, out.as_array())
def test_ConstantFunction(self): k = ConstantFunction(constant=1) ig = ImageGeometry(1,2,3) x = ig.allocate(2) grad = k.gradient(x) out = ig.allocate(-1) k.gradient(x, out=out) #out.fill(-3) self.assertNumpyArrayEqual(numpy.zeros(x.shape), grad.as_array()) self.assertNumpyArrayEqual(out.as_array(), grad.as_array())
def test_fill_dimension_ImageData(self): ig = ImageGeometry(2, 3, 4) u = ig.allocate(0) a = numpy.ones((4, 2)) # default_labels = [ImageGeometry.VERTICAL, ImageGeometry.HORIZONTAL_Y, ImageGeometry.HORIZONTAL_X] data = u.as_array() axis_number = u.get_dimension_axis('horizontal_y') u.fill(a, horizontal_y=0) numpy.testing.assert_array_equal( u.subset(horizontal_y=0).as_array(), a) u.fill(2, horizontal_y=1) numpy.testing.assert_array_equal( u.subset(horizontal_y=1).as_array(), 2 * a) u.fill(2, horizontal_y=1) numpy.testing.assert_array_equal( u.subset(horizontal_y=1).as_array(), 2 * a) b = u.subset(horizontal_y=2) b.fill(3) u.fill(b, horizontal_y=2) numpy.testing.assert_array_equal( u.subset(horizontal_y=2).as_array(), 3 * a)
def setUp(self): ig = ImageGeometry(2, 3, 2) data = ig.allocate(1, dtype=np.float32) noisy_data = data + 1 # TV regularisation parameter self.alpha = 1 self.fidelities = [ 0.5 * L2NormSquared(b=noisy_data), L1Norm(b=noisy_data), KullbackLeibler(b=noisy_data, use_numba=False) ] F = self.alpha * MixedL21Norm() K = GradientOperator(ig) # Compute operator Norm normK = K.norm() # Primal & dual stepsizes self.sigma = 1. / normK self.tau = 1. / normK self.F = F self.K = K
def test_L1Norm_2D(self): model = 12 # select a model number from the library N = 400 # set dimension of the phantom path = os.path.dirname(tomophantom.__file__) path_library2D = os.path.join(path, "Phantom2DLibrary.dat") phantom_2D = TomoP2D.Model(model, N, path_library2D) # data = ImageData(phantom_2D) ig = ImageGeometry(voxel_num_x=N, voxel_num_y=N) data = ig.allocate(None) data.fill(phantom_2D) # Create acquisition data and geometry detectors = N angles = np.linspace(0, 180, 120, dtype=np.float32) ag = AcquisitionGeometry.create_Parallel2D()\ .set_angles(angles, angle_unit=AcquisitionGeometry.DEGREE)\ .set_panel(detectors) sin = ag.allocate(None) sino = TomoP2D.ModelSino(model, detectors, detectors, angles, path_library2D) sin.fill(sino) sin_stripe = sin.copy() # sin_stripe = sin tmp = sin_stripe.as_array() tmp[:,::27]=tmp[:,::28] sin_stripe.fill(tmp) ring_recon = RingRemover(20, "db15", 21, info = True)(sin_stripe) error = (ring_recon - sin).abs().as_array().mean() print ("L1Norm ", error) np.testing.assert_almost_equal(error, 83.20592, 4)
def test_Norm(self): print("test_BlockOperator") ## numpy.random.seed(1) N, M = 200, 300 ig = ImageGeometry(N, M) G = GradientOperator(ig) t0 = timer() norm = G.norm() t1 = timer() norm2 = G.norm() t2 = timer() norm3 = G.norm(force=True) t3 = timer() print("Norm dT1 {} dT2 {} dT3 {}".format(t1 - t0, t2 - t1, t3 - t2)) self.assertLess(t2 - t1, t1 - t0) self.assertLess(t2 - t1, t3 - t2) numpy.random.seed(1) t4 = timer() norm4 = G.norm(iterations=50, force=True) t5 = timer() self.assertLess(t2 - t1, t5 - t4) numpy.random.seed(1) t4 = timer() norm5 = G.norm(x_init=ig.allocate('random'), iterations=50, force=True) t5 = timer() self.assertLess(t2 - t1, t5 - t4) for n in [norm, norm2, norm3, norm4, norm5]: print("norm {}", format(n))
def test_Lipschitz(self): print('Test for OperatorCompositionFunction') M, N = 50, 50 ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N) b = ig.allocate('random', seed=1) print('Check call with IdentityOperator operator... OK\n') operator = 3 * IdentityOperator(ig) u = ig.allocate('random_int', seed=50) func2 = LeastSquares(operator, b, 0.5) assert func2.L != 2 print(func2.L) func2.L = 2 assert func2.L == 2
def test_PDHG_strongly_convex_gamma_g(self): ig = ImageGeometry(3,3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = IdentityOperator(ig) # sigma, tau sigma = 1.0 tau = 1.0 pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, max_iteration=5, gamma_g=0.5) pdhg.run(1, verbose=0) self.assertAlmostEquals(pdhg.theta, 1.0/ np.sqrt(1 + 2 * pdhg.gamma_g * tau)) self.assertAlmostEquals(pdhg.tau, tau * pdhg.theta) self.assertAlmostEquals(pdhg.sigma, sigma / pdhg.theta) pdhg.run(4, verbose=0) self.assertNotEqual(pdhg.sigma, sigma) self.assertNotEqual(pdhg.tau, tau) # check negative strongly convex constant with self.assertRaises(ValueError): pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, max_iteration=5, gamma_g=-0.5) # check strongly convex constant not a number with self.assertRaises(ValueError): pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, max_iteration=5, gamma_g="-0.5")
def test_NestedBlockDataContainer2(self): M, N = 2, 3 ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N) ag = ig u = ig.allocate(1) op1 = GradientOperator(ig) op2 = IdentityOperator(ig, ag) operator = BlockOperator(op1, op2, shape=(2, 1)) d1 = op1.direct(u) d2 = op2.direct(u) d = operator.direct(u) dd = operator.domain_geometry() ww = operator.range_geometry() c1 = d + d c2 = 2 * d c3 = d / (d + 0.0001) c5 = d.get_item(0).power(2).sum()
def test_ScaledOperator(self): print("test_ScaledOperator") ig = ImageGeometry(10, 20, 30) img = ig.allocate() scalar = 0.5 sid = scalar * IdentityOperator(ig) numpy.testing.assert_array_equal(scalar * img.as_array(), sid.direct(img).as_array())
def test_reorder_with_list(self): vgeometry = ImageGeometry(voxel_num_x=4, voxel_num_y=3, channels=2) data = vgeometry.allocate(0) new_order = ['horizontal_y', 'horizontal_x', 'channel'] data.reorder(new_order) self.assertListEqual(list(new_order), list(data.geometry.dimension_labels)) self.assertListEqual(list(new_order), list(data.dimension_labels))
def test_BlockOperatorLinearValidity(self): print("test_BlockOperatorLinearValidity") M, N = 3, 4 ig = ImageGeometry(M, N) arr = ig.allocate('random', seed=1) G = GradientOperator(ig) Id = IdentityOperator(ig) B = BlockOperator(G, Id) # Nx1 case u = ig.allocate('random', seed=2) w = B.range_geometry().allocate(ImageGeometry.RANDOM, seed=3) w1 = B.direct(u) u1 = B.adjoint(w) self.assertAlmostEqual((w * w1).sum(), (u1 * u).sum(), places=5)
def test_max(self): print ("test max") ig = ImageGeometry(10,10) a = numpy.asarray(numpy.linspace(-10,10, num=100, endpoint=True), dtype=numpy.float32) a = a.reshape((10,10)) d1 = ig.allocate(1) d1.fill(a) self.assertAlmostEqual(d1.max(), 10.)