def test_get_source_positions(self): pg1 = ts.cone(source_distance=1).to_vector() pg2 = ts.cone(source_distance=2).to_vector() source_diff = pg1.get_source_positions( ) * 2 - pg2.get_source_positions() self.assertTrue(np.all(abs(source_diff) < ts.epsilon))
def test_init(self): """Test data creation.""" pg = ts.cone(angles=10, shape=20) vg = ts.VolumeGeometry().reshape(10) pd = ts.Data(pg, 0) proj_shape = pd.get().shape # Should warn when data is silently converted to float32. with self.assertWarns(UserWarning): ts.Data(pg, np.ones(proj_shape, dtype=np.float64)) with self.assertWarns(UserWarning): ts.Data(vg, np.ones(vg.shape, dtype=np.float64)) # Should warn when data is made contiguous. with self.assertWarns(UserWarning): p_data = np.ones( (pg.shape[0] * 2, pg.get_num_angles(), pg.shape[1]), dtype=np.float32) ts.Data(pg, p_data[::2, ...]) with self.assertWarns(UserWarning): v_data = np.ones((vg.shape[0] * 2, *vg.shape[1:]), dtype=np.float32) ts.Data(vg, v_data[::2, ...]) ts.Data(pg, np.ones(proj_shape, dtype=np.float32)) ts.Data(vg, np.ones(vg.shape, dtype=np.float32))
def test_volume_from_projection(self): """Test volume_from_projection_geometry This method checks that astra projections of a volume obtained by volume_from_projection_geometry satisfy some conditions. Notably, 1) when inside=True, the backprojection of a detector should hit all volume voxels. This should actually hold for each angle individually, but this is too expensive to test. 2) when inside=False, the forward projection of the volume should hit each detector pixel. Again, this should hold for each angle individually. NOTE: When the source intersects the volume, astra does not always do a correct forward projection. Hence, a correctly sized volume might fail the test. """ num_angles = 119 interactive = False proj_angles = np.linspace(0, 2 * np.pi, num_angles, False) pg = ts.cone() vg = ts.volume_from_projection_geometry(pg)
def test_get_item(self): pg = ts.cone(angles=10, shape=20) self.assertEqual(pg[1].get_num_angles(), 1) self.assertEqual(pg[:1].get_num_angles(), 1) self.assertEqual(pg[:2].get_num_angles(), 2) self.assertEqual(pg[:].get_num_angles(), 10) self.assertEqual(pg[10].get_num_angles(), 0)
def test_display_geometry(self): """Test something.""" interactive = False pg = ts.cone(angles=100, source_distance=10, detector_distance=5) vg = ts.volume_from_projection_geometry(pg, inside=False) if interactive: ts.display_geometry(pg, vg)
def test_get_set(self): """Test data.set() and data.get() """ pg = ts.cone().reshape(10) data = ts.Data(pg, 0) self.assertTrue(np.all(abs(data.get()) < ts.epsilon)) data.set(1) self.assertTrue(np.all(abs(data.get() - 1) < ts.epsilon))
def test_get_size(self): size = (1, 1) pg = ts.cone(angles=5, size=size).to_vector() self.assertTrue(abs(size - pg.get_size()).sum() < ts.epsilon) for _ in range(10): new_shape = np.random.uniform(1, 100, size=2).astype(np.int) # Change the number of detector pixels and test if the # change in size is proportional pg2 = pg.reshape(new_shape) self.assertTrue( abs(size * new_shape - pg2.get_size()).sum() < ts.epsilon)
def test_init(self): """Test ReconstructionGeometry init.""" pd = ts.Data(ts.cone()) vd = ts.Data(ts.VolumeGeometry()) r = ts.ReconstructionGeometry(pd, vd) r = ts.ReconstructionGeometry(pd, vd, detector_supersampling=2, voxel_supersampling=2)
def test_project_point_detector_spacing(self): """Test project_point with detector spacing Test whether projection_point works with non-uniform detector spacing. """ angles = np.zeros(1) shape = (10, 40) size = (30, 80) pg = ts.cone(1, size, shape, source_distance=10).to_vector() self.assertAlmostEqual(np.abs(pg.project_point((0, 0, 0))).sum(), 0) self.assertAlmostEqual( np.abs(pg.project_point((3.0, 0, 0)) - [1.0, 0.0]).sum(), 0) self.assertAlmostEqual( np.abs(pg.project_point((0, 0, 2.0)) - [0.0, 1.0]).sum(), 0) shape = (100, 400) pg = ts.cone(1, size, shape, source_distance=10).to_vector() self.assertAlmostEqual(np.abs(pg.project_point((0, 0, 0))).sum(), 0) self.assertAlmostEqual( np.abs(pg.project_point((0.3, 0, 0)) - [1.0, 0.0]).sum(), 0) self.assertAlmostEqual( np.abs(pg.project_point((0, 0, 0.2)) - [0.0, 1.0]).sum(), 0)
def test_with(self): """Test that data in a with statement gets cleaned up Also, that using the with statement works. """ seg_fault = False pg = ts.cone() vg = ts.VolumeGeometry() with ts.Data(pg, 0) as pd, ts.Data(vg, 0) as vd: proj = pd.get() vol = vd.get() # No test to check that the code below segfaults, but it does :) # You can run the code.. if seg_fault: proj[:] = 0 vol[:] = 0
def test_display_data(self): interactive = False p = ts.Data(ts.cone(angles=100).reshape(100)) v = ts.Data( ts.volume_from_projection_geometry(p.geometry).reshape(100)) # Fill the projection data with random noise: proj = p.get() proj[:] = np.random.normal(size=proj.shape) proj[:] = abs(proj) r = ts.ReconstructionGeometry(p, v) if interactive: ts.display_data(p) r.backward() if interactive: ts.display_data(v)
def test_forward_backward(self): pd = ts.Data(ts.cone().reshape(10)) vd = ts.Data(ts.VolumeGeometry().reshape(10)) rs = [ ts.ReconstructionGeometry(pd, vd), ts.ReconstructionGeometry(pd, vd, detector_supersampling=2, voxel_supersampling=2), ts.ReconstructionGeometry(pd, vd, detector_supersampling=1, voxel_supersampling=2), ts.ReconstructionGeometry(pd, vd, detector_supersampling=2, voxel_supersampling=1), ] for r in rs: r.forward() r.backward()
def test_is_volume_geometry(self): self.assertTrue(ts.is_volume_geometry(ts.VolumeGeometry())) self.assertFalse(ts.is_volume_geometry(ts.cone())) self.assertFalse(ts.is_volume_geometry(None))
def test_get_corners(self): # TODO: This test deserves better.. size = (1, 1) pg1 = ts.cone(angles=5, size=size).to_vector() self.assertEqual(pg1.get_corners().shape, (4, 5, 3))
def test_cone(self): self.assertEqual(ts.ConeGeometry(), ts.cone())
def test_is_volume_projection(self): self.assertTrue(ts.Data(ts.cone()).is_projection()) self.assertFalse(ts.Data(ts.cone()).is_volume()) self.assertTrue(ts.Data(ts.VolumeGeometry()).is_volume()) self.assertFalse(ts.Data(ts.VolumeGeometry()).is_projection())
def test_get_size(self): size = (1, 2) pg = ts.cone(size=size) self.assertTrue(abs(size - pg.get_size()).sum() < ts.epsilon)