def test_tv(self): geom = Geometry(2) proj_vec = Rn(geom.proj_size).element(1) cp = ODLChambollePock(geom, proj_vec) cp.least_squares(3, L=131.0, non_negativiy_constraint=False, tv_norm=1, verbose=False)
def test_adjoint_scaling_factor(self): """Test if back-projector A^* is adjoint of forward projector A: <A x, y>_D = <x,A^* y>_I . Define scaling factor as A^* = s B where is the implemented back-projector. Thus, s = <A x, y>_D / <x,B y>_I , or using y = A x s = <A x, A x>_D / <x,B A x>_I . """ geom = Geometry(2) # x = ones() and y = A x vol_rn = Rn(geom.vol_size) vol_rn_ones = vol_rn.element(1) proj_rn = Rn(geom.proj_size) projector = ODLProjector(geom, vol_rn, proj_rn) proj = projector.forward(vol_rn_ones) vol = projector.backward(proj) s0 = proj.norm() ** 2 / vol_rn._inner(vol, vol_rn_ones) # x = ones(), y = ones() vol_rn = Rn(geom.vol_size) vol_rn_ones = vol_rn.element(1) proj_rn = Rn(geom.proj_size) proj_rn_ones = proj_rn.element(1) projector = ODLProjector(geom, vol_rn, proj_rn) proj = projector.forward(vol_rn_ones) vol = projector.backward(proj_rn_ones) s1 = proj.inner(proj_rn_ones) / vol_rn_ones.inner(vol) # implemented function proj_vec = Rn(geom.proj_size).element(1) cp = ODLChambollePock(geom, proj_vec) cp.adjoint_scaling_factor() s2 = cp.adj_scal_fac self.assertEqual(s1, s2) print('Scaling factors:', s0, s1, s2) projector.clear_astra_memory()
def test_creation_of_vector_in_rn(self): geom = Geometry(2) rn = Rn(geom.proj_size) self.assertEqual(type(rn).__name__, 'Rn') rn_vec = rn.element(np.zeros(geom.proj_size)) self.assertEqual(type(rn_vec).__name__, 'Vector') self.assertEqual(rn.dtype, 'float') self.assertEqual(rn.field, odl.RealNumbers()) ODLChambollePock(geom)
def test_least_squares_method(self): geom = Geometry(2) proj_vec = Rn(geom.proj_size).element(1) cp = ODLChambollePock(geom, proj_vec) num_iter = 3 cp.least_squares(num_iter, verbose=False)
def test_matrix_norm(self): """Compute matrix norm of forward/backward projector using power norm. """ geom = Geometry(2) proj_vec = Rn(geom.proj_size).element(1) # Compute norm for simple least squares cp = ODLChambollePock(geom, proj_vec) self.assertEqual(cp.adj_scal_fac, 1) mat_norm0 = cp.matrix_norm(iterations=4, vol_init=1, intermediate_results=True) self.assertTrue(mat_norm0[-1] > 0) # Resume computation mat_norm1, vol = cp.matrix_norm(iterations=3, vol_init=1, intermediate_results=True, return_volume=True) mat_norm2 = cp.matrix_norm(iterations=4, vol_init=vol, intermediate_results=True) self.assertNotEqual(mat_norm0[0], mat_norm2[0]) self.assertEqual(mat_norm0[3], mat_norm2[0]) # Compute norm for TV mat_norm3 = cp.matrix_norm(iterations=4, vol_init=1, tv_norm=True, intermediate_results=True) self.assertFalse(np.array_equal(mat_norm2, mat_norm3)) print('LS unit init volume:', mat_norm2) print('TV unit init volume:', mat_norm3) # Use non-homogeneous initial volume v0 = np.random.rand(geom.vol_size) mat_norm4 = cp.matrix_norm(iterations=4, vol_init=v0, tv_norm=False, intermediate_results=True) mat_norm5 = cp.matrix_norm(iterations=4, vol_init=v0, tv_norm=True, intermediate_results=True) print('LS random init volume:', mat_norm4) print('TV random init volume:', mat_norm5) # test with adjoint scaling factor for backprojector self.assertEqual(cp.adj_scal_fac, 1) cp.adjoint_scaling_factor() self.assertFalse(cp.adj_scal_fac == 1) print('adjoint scaling factor:', cp.adj_scal_fac) mat_norm6 = cp.matrix_norm(iterations=4, vol_init=1, tv_norm=False, intermediate_results=True) mat_norm7 = cp.matrix_norm(iterations=4, vol_init=1, tv_norm=True, intermediate_results=True) print('LS init volume, adjoint rescaled:', mat_norm6) print('TV init volume, adjoint rescaled:', mat_norm7)