def test_partition_init_raise():
# Check different error scenarios
vec1 = np.array([2, 4, 5, 7])
vec2 = np.array([-4, -3, 0, 1, 4])
grid = odl.TensorGrid(vec1, vec2)
begin = [2, -5]
end = [10, 4]
beg_toolarge = (2, -3.5)
end_toosmall = (7, 1)
beg_badshape = (-1, 2, 0)
end_badshape = (2, )
with pytest.raises(ValueError):
odl.RectPartition(odl.IntervalProd(beg_toolarge, end), grid)
with pytest.raises(ValueError):
odl.RectPartition(odl.IntervalProd(begin, end_toosmall), grid)
with pytest.raises(ValueError):
odl.RectPartition(odl.IntervalProd(beg_badshape, end_badshape), grid)
with pytest.raises(TypeError):
odl.RectPartition(None, grid)
with pytest.raises(TypeError):
odl.RectPartition(odl.IntervalProd(beg_toolarge, end), None)
def test_partition_insert():
vec11 = [2, 4, 5, 7]
vec12 = [-4, -3, 0, 1, 4]
min_pt1 = [1, -4]
max_pt1 = [7, 5]
grid1 = odl.RectGrid(vec11, vec12)
intv1 = odl.IntervalProd(min_pt1, max_pt1)
part1 = odl.RectPartition(intv1, grid1)
vec21 = [-2, 0, 3]
vec22 = [0]
min_pt2 = [-2, -2]
max_pt2 = [4, 0]
grid2 = odl.RectGrid(vec21, vec22)
intv2 = odl.IntervalProd(min_pt2, max_pt2)
part2 = odl.RectPartition(intv2, grid2)
part = part1.insert(0, part2)
assert all_equal(part.min_pt, [-2, -2, 1, -4])
assert all_equal(part.max_pt, [4, 0, 7, 5])
assert all_equal(part.grid.min_pt, [-2, 0, 2, -4])
assert all_equal(part.grid.max_pt, [3, 0, 7, 4])
part = part1.insert(1, part2)
assert all_equal(part.min_pt, [1, -2, -2, -4])
assert all_equal(part.max_pt, [7, 4, 0, 5])
assert all_equal(part.grid.min_pt, [2, -2, 0, -4])
assert all_equal(part.grid.max_pt, [7, 3, 0, 4])
def test_partition_insert():
vec11 = [2, 4, 5, 7]
vec12 = [-4, -3, 0, 1, 4]
begin1 = [1, -4]
end1 = [7, 5]
grid1 = odl.TensorGrid(vec11, vec12)
intv1 = odl.IntervalProd(begin1, end1)
part1 = odl.RectPartition(intv1, grid1)
vec21 = [-2, 0, 3]
vec22 = [0]
begin2 = [-2, -2]
end2 = [4, 0]
grid2 = odl.TensorGrid(vec21, vec22)
intv2 = odl.IntervalProd(begin2, end2)
part2 = odl.RectPartition(intv2, grid2)
part = part1.insert(0, part2)
assert all_equal(part.begin, [-2, -2, 1, -4])
assert all_equal(part.end, [4, 0, 7, 5])
assert all_equal(part.grid.min_pt, [-2, 0, 2, -4])
assert all_equal(part.grid.max_pt, [3, 0, 7, 4])
part = part1.insert(1, part2)
assert all_equal(part.begin, [1, -2, -2, -4])
assert all_equal(part.end, [7, 4, 0, 5])
assert all_equal(part.grid.min_pt, [2, -2, 0, -4])
assert all_equal(part.grid.max_pt, [7, 3, 0, 4])
def test_empty_partition():
"""Check if empty partitions behave as expected and all methods work."""
part = odl.RectPartition(odl.IntervalProd([], []),
odl.uniform_grid([], [], ()))
assert part.cell_boundary_vecs == ()
assert part.nodes_on_bdry is True
assert part.nodes_on_bdry_byaxis == ()
assert part.has_isotropic_cells
assert part.boundary_cell_fractions == ()
assert part.cell_sizes_vecs == ()
assert np.array_equal(part.cell_sides, [])
assert part.cell_volume == 0
same = odl.RectPartition(odl.IntervalProd([], []),
odl.uniform_grid([], [], ()))
assert part == same
assert hash(part) == hash(same)
other = odl.uniform_partition(0, 1, 4)
assert part != other
assert part[[]] == part
assert part.insert(0, other) == other
assert other.insert(0, part) == other
assert other.insert(1, part) == other
assert part.squeeze() == part
assert part.index([]) == ()
part.byaxis
assert part == odl.uniform_partition([], [], ())
repr(part)
def test_partition_init_raise():
# Check different error scenarios
vec1 = np.array([2, 4, 5, 7])
vec2 = np.array([-4, -3, 0, 1, 4])
grid = odl.RectGrid(vec1, vec2)
min_pt = [2, -5]
max_pt = [10, 4]
min_pt_toolarge = (2, -3.5)
max_pt_toosmall = (7, 1)
min_pt_badshape = (-1, 2, 0)
max_pt_badshape = (2, )
with pytest.raises(ValueError):
odl.RectPartition(odl.IntervalProd(min_pt_toolarge, max_pt), grid)
with pytest.raises(ValueError):
odl.RectPartition(odl.IntervalProd(min_pt, max_pt_toosmall), grid)
with pytest.raises(ValueError):
odl.RectPartition(odl.IntervalProd(min_pt_badshape, max_pt_badshape),
grid)
with pytest.raises(TypeError):
odl.RectPartition(None, grid)
with pytest.raises(TypeError):
odl.RectPartition(odl.IntervalProd(min_pt_toolarge, max_pt), None)
def test_partition_init():
vec1 = np.array([2, 4, 5, 7])
vec2 = np.array([-4, -3, 0, 1, 4])
begin = [2, -5]
end = [10, 4]
# Simply test if code runs
odl.RectPartition(odl.Rectangle(begin, end), odl.TensorGrid(vec1, vec2))
odl.RectPartition(odl.Interval(begin[0], end[0]), odl.TensorGrid(vec1))
# Degenerate dimensions should work, too
vec2 = np.array([1.0])
odl.RectPartition(odl.Rectangle(begin, end), odl.TensorGrid(vec1, vec2))
def test_partition_init():
vec1 = np.array([2, 4, 5, 7])
vec2 = np.array([-4, -3, 0, 1, 4])
min_pt = [2, -5]
max_pt = [10, 4]
# Simply test if code runs
odl.RectPartition(odl.IntervalProd(min_pt, max_pt),
odl.RectGrid(vec1, vec2))
odl.RectPartition(odl.IntervalProd(min_pt[0], max_pt[0]),
odl.RectGrid(vec1))
# Degenerate dimensions should work, too
vec2 = np.array([1.0])
odl.RectPartition(odl.IntervalProd(min_pt, max_pt),
odl.RectGrid(vec1, vec2))
def test_partition_getitem():
vec1 = [2, 4, 5, 7]
vec2 = [-4, -3, 0, 1, 4]
vec3 = [-2, 0, 3]
vec4 = [0]
vecs = [vec1, vec2, vec3, vec4]
min_pt = [1, -4, -2, -2]
max_pt = [7, 5, 4, 0]
grid = odl.RectGrid(*vecs)
intv = odl.IntervalProd(min_pt, max_pt)
part = odl.RectPartition(intv, grid)
# Test a couple of slices
slc = (1, -2, 2, 0)
slc_vecs = [v[i] for i, v in zip(slc, vecs)]
slc_part = part[slc]
assert slc_part.grid == odl.RectGrid(*slc_vecs)
slc_min_pt = [3, 0.5, 1.5, -2]
slc_max_pt = [4.5, 2.5, 4, 0]
assert slc_part.set == odl.IntervalProd(slc_min_pt, slc_max_pt)
slc = (slice(None), slice(None, None, 2), slice(None, 2), 0)
slc_vecs = [v[i] for i, v in zip(slc, vecs)]
slc_part = part[slc]
assert slc_part.grid == odl.RectGrid(*slc_vecs)
slc_min_pt = [1, -4, -2, -2]
slc_max_pt = [7, 5, 1.5, 0]
assert slc_part.set == odl.IntervalProd(slc_min_pt, slc_max_pt)
# Fewer indices
assert part[1] == part[1, :, :, :] == part[1, ...]
assert part[1, 2:] == part[1, 2:, :, :] == part[1, 2:, ...]
assert part[1, 2:, ::2] == part[1, 2:, ::2, :] == part[1, 2:, ::2, ...]
# Index list using indices 0 and 2
lst_min_pt = [1, -4, -2, -2]
lst_max_pt = [6, 5, 4, 0]
lst_intv = odl.IntervalProd(lst_min_pt, lst_max_pt)
lst_vec1 = [2, 5]
lst_grid = odl.RectGrid(lst_vec1, vec2, vec3, vec4)
lst_part = odl.RectPartition(lst_intv, lst_grid)
assert part[[0, 2]] == lst_part
def test_astra_projection_geometry():
"""Create ASTRA projection geometry from geometry objects."""
with pytest.raises(TypeError):
odl.tomo.astra_projection_geometry(None)
apart = odl.uniform_partition(0, 2 * np.pi, 5)
dpart = odl.uniform_partition(-40, 40, 10)
# motion sampling grid, detector sampling grid but not uniform
dpart_0 = odl.RectPartition(odl.IntervalProd(0, 3), odl.RectGrid([0, 1,
3]))
geom_p2d = odl.tomo.Parallel2dGeometry(apart, dpart=dpart_0)
with pytest.raises(ValueError):
odl.tomo.astra_projection_geometry(geom_p2d)
# detector sampling grid, motion sampling grid
geom_p2d = odl.tomo.Parallel2dGeometry(apart, dpart)
odl.tomo.astra_projection_geometry(geom_p2d)
# Parallel 2D geometry
geom_p2d = odl.tomo.Parallel2dGeometry(apart, dpart)
astra_geom = odl.tomo.astra_projection_geometry(geom_p2d)
assert astra_geom['type'] == 'parallel'
# Fan flat
src_rad = 10
det_rad = 5
geom_ff = odl.tomo.FanFlatGeometry(apart, dpart, src_rad, det_rad)
astra_geom = odl.tomo.astra_projection_geometry(geom_ff)
assert astra_geom['type'] == 'fanflat_vec'
dpart = odl.uniform_partition([-40, -3], [40, 3], (10, 5))
# Parallel 3D geometry
geom_p3d = odl.tomo.Parallel3dAxisGeometry(apart, dpart)
odl.tomo.astra_projection_geometry(geom_p3d)
astra_geom = odl.tomo.astra_projection_geometry(geom_p3d)
assert astra_geom['type'] == 'parallel3d_vec'
# Circular conebeam flat
geom_ccf = odl.tomo.ConeFlatGeometry(apart, dpart, src_rad, det_rad)
astra_geom = odl.tomo.astra_projection_geometry(geom_ccf)
assert astra_geom['type'] == 'cone_vec'
# Helical conebeam flat
pitch = 1
geom_hcf = odl.tomo.ConeFlatGeometry(apart,
dpart,
src_rad,
det_rad,
pitch=pitch)
astra_geom = odl.tomo.astra_projection_geometry(geom_hcf)
assert astra_geom['type'] == 'cone_vec'
def test_equals():
"""Test partition equality checks and hash."""
vec1 = np.array([2, 3, 4, 5])
vec2 = np.array([-4, -2, 0, 2, 4])
part1 = odl.RectPartition(odl.IntervalProd(1, 6), odl.RectGrid(vec1))
part2 = odl.RectPartition(odl.IntervalProd([1, -5], [6, 5]),
odl.RectGrid(vec1, vec2))
part2_again = odl.RectPartition(odl.IntervalProd([1, -5], [6, 5]),
odl.RectGrid(vec1, vec2))
part2_rev = odl.RectPartition(odl.IntervalProd([-5, 1], [5, 6]),
odl.RectGrid(vec2, vec1))
_test_eq(part1, part1)
_test_eq(part2, part2)
_test_eq(part2, part2_again)
_test_neq(part1, part2)
_test_neq(part2, part2_rev)
assert part2 != (vec1, vec2)
def test_partition_set():
vec1 = np.array([2, 4, 5, 7])
vec2 = np.array([-4, -3, 0, 1, 4])
grid = odl.RectGrid(vec1, vec2)
min_pt = [1, -4]
max_pt = [10, 5]
intv = odl.IntervalProd(min_pt, max_pt)
part = odl.RectPartition(intv, grid)
assert part.set == odl.IntervalProd(min_pt, max_pt)
assert all_equal(part.min_pt, min_pt)
assert all_equal(part.min(), min_pt)
assert all_equal(part.max_pt, max_pt)
assert all_equal(part.max(), max_pt)
def test_partition_set():
vec1 = np.array([2, 4, 5, 7])
vec2 = np.array([-4, -3, 0, 1, 4])
grid = odl.TensorGrid(vec1, vec2)
begin = [1, -4]
end = [10, 5]
intv = odl.IntervalProd(begin, end)
part = odl.RectPartition(intv, grid)
assert part.set == odl.IntervalProd(begin, end)
assert all_equal(part.begin, begin)
assert all_equal(part.min(), begin)
assert all_equal(part.end, end)
assert all_equal(part.max(), end)
def test_partition_cell_boundary_vecs():
vec1 = np.array([2, 4, 5, 7])
vec2 = np.array([-4, -3, 0, 1, 4])
grid = odl.RectGrid(vec1, vec2)
midpts1 = [3, 4.5, 6]
midpts2 = [-3.5, -1.5, 0.5, 2.5]
min_pt = [2, -6]
max_pt = [10, 4]
intv = odl.IntervalProd(min_pt, max_pt)
true_bvec1 = [2] + midpts1 + [10]
true_bvec2 = [-6] + midpts2 + [4]
part = odl.RectPartition(intv, grid)
assert all_equal(part.cell_boundary_vecs, (true_bvec1, true_bvec2))
def test_partition_cell_sizes_vecs():
vec1 = np.array([2, 4, 5, 7])
vec2 = np.array([-4, -3, 0, 1, 4])
grid = odl.TensorGrid(vec1, vec2)
midpts1 = [3, 4.5, 6]
midpts2 = [-3.5, -1.5, 0.5, 2.5]
begin = [2, -6]
end = [10, 4]
intv = odl.IntervalProd(begin, end)
bvec1 = np.array([2] + midpts1 + [10])
bvec2 = np.array([-6] + midpts2 + [4])
true_csizes1 = bvec1[1:] - bvec1[:-1]
true_csizes2 = bvec2[1:] - bvec2[:-1]
part = odl.RectPartition(intv, grid)
assert all_equal(part.cell_sizes_vecs, (true_csizes1, true_csizes2))
def test_resizing_op_raise():
# domain not a uniformely discretized Lp
with pytest.raises(TypeError):
odl.ResizingOperator(odl.rn(5), ran_shp=(10, ))
grid = odl.RectGrid([0, 2, 3])
part = odl.RectPartition(odl.IntervalProd(0, 3), grid)
fspace = odl.FunctionSpace(odl.IntervalProd(0, 3))
dspace = odl.rn(3)
space = odl.DiscreteLp(fspace, part, dspace)
with pytest.raises(ValueError):
odl.ResizingOperator(space, ran_shp=(10, ))
# different cell sides in domain and range
space = odl.uniform_discr(0, 1, 10)
res_space = odl.uniform_discr(0, 1, 15)
with pytest.raises(ValueError):
odl.ResizingOperator(space, res_space)
# non-integer multiple of cell sides used as shift (grid of the
# resized space shifted)
space = odl.uniform_discr(0, 1, 5)
res_space = odl.uniform_discr(-0.5, 1.5, 10)
with pytest.raises(ValueError):
odl.ResizingOperator(space, res_space)
# need either range or ran_shp
with pytest.raises(ValueError):
odl.ResizingOperator(space)
# offset cannot be combined with range
space = odl.uniform_discr([0, -1], [1, 1], (10, 5))
res_space = odl.uniform_discr([0, -3], [2, 3], (20, 15))
with pytest.raises(ValueError):
odl.ResizingOperator(space, res_space, offset=(0, 0))
# bad pad_mode
with pytest.raises(ValueError):
odl.ResizingOperator(space, res_space, pad_mode='something')
def test_norm_rectangle_boundary(impl, exponent):
# Check the constant function 1 in different situations regarding the
# placement of the outermost grid points.
if exponent == float('inf'):
pytest.xfail('inf-norm not implemented in CUDA')
rect = odl.Rectangle([-1, -2], [1, 2])
# Standard case
discr = odl.uniform_discr_fromspace(odl.FunctionSpace(rect), (4, 8),
impl=impl, exponent=exponent)
if exponent == float('inf'):
assert discr.one().norm() == 1
else:
assert almost_equal(discr.one().norm(),
(rect.volume) ** (1 / exponent))
# Nodes on the boundary (everywhere)
discr = odl.uniform_discr_fromspace(
odl.FunctionSpace(rect), (4, 8), exponent=exponent,
impl=impl, nodes_on_bdry=True)
if exponent == float('inf'):
assert discr.one().norm() == 1
else:
assert almost_equal(discr.one().norm(),
(rect.volume) ** (1 / exponent))
# Nodes on the boundary (selective)
discr = odl.uniform_discr_fromspace(
odl.FunctionSpace(rect), (4, 8), exponent=exponent,
impl=impl, nodes_on_bdry=((False, True), False))
if exponent == float('inf'):
assert discr.one().norm() == 1
else:
assert almost_equal(discr.one().norm(),
(rect.volume) ** (1 / exponent))
discr = odl.uniform_discr_fromspace(
odl.FunctionSpace(rect), (4, 8), exponent=exponent,
impl=impl, nodes_on_bdry=(False, (True, False)))
if exponent == float('inf'):
assert discr.one().norm() == 1
else:
assert almost_equal(discr.one().norm(),
(rect.volume) ** (1 / exponent))
# Completely arbitrary boundary
grid = odl.RegularGrid([0, 0], [1, 1], (4, 4))
part = odl.RectPartition(rect, grid)
weight = 1.0 if exponent == float('inf') else part.cell_volume
dspace = odl.Rn(part.size, exponent=exponent, weight=weight)
discr = DiscreteLp(odl.FunctionSpace(rect), part, dspace,
impl=impl, exponent=exponent)
if exponent == float('inf'):
assert discr.one().norm() == 1
else:
assert almost_equal(discr.one().norm(),
(rect.volume) ** (1 / exponent))
@author: Rob Tovey
'''
from os.path import join
RECORD = join('store', 'DogBones_small')
RECORD = None
if RECORD is not None:
import matplotlib
matplotlib.use('Agg')
import odl
from numpy import sqrt, loadtxt, asarray, pi, ascontiguousarray
from PIL import Image
# Import data:
angles = loadtxt(join('DogBones', 'Sample_A2_Tilt_Series_tiltcorr_cut.rawtlt'))
angles = odl.RectPartition(odl.IntervalProd(-pi / 2, pi / 2),
odl.RectGrid((pi / 180) * angles))
# angles = odl.uniform_partition(-(pi / 180) * 69, (pi / 180) * 73, 71)
data = Image.open(join('DogBones', 'Sample A2 Tilt Series_tiltcorr_cut.tif'))
data = [asarray(data).T for i in range(data.n_frames) if data.seek(i) is None]
# First dimension is angle, second is width, third is slice
data = asarray(data)
# import matplotlib
# matplotlib.use('Agg')
from matplotlib import pyplot as plt, animation as mv
# writer = mv.writers['ffmpeg'](fps=5, metadata={'title': 'DogBones'})
fig = plt.figure()
# writer.setup(fig, 'DogBones' + '.mp4', dpi=100)
for i in range(data.shape[0]):
plt.gca().clear()
plt.imshow(data[i, :, 500:564].T)
plt.pause(0.1)
def test_norm_rectangle_boundary(odl_tspace_impl, exponent):
# Check the constant function 1 in different situations regarding the
# placement of the outermost grid points.
impl = odl_tspace_impl
dtype = 'float32'
rect = odl.IntervalProd([-1, -2], [1, 2])
fspace = odl.FunctionSpace(rect, out_dtype=dtype)
# Standard case
discr = odl.uniform_discr_fromspace(fspace, (4, 8),
impl=impl,
exponent=exponent)
if exponent == float('inf'):
assert discr.one().norm() == 1
else:
assert (discr.one().norm() == pytest.approx(rect.volume**(1 /
exponent)))
# Nodes on the boundary (everywhere)
discr = odl.uniform_discr_fromspace(fspace, (4, 8),
exponent=exponent,
impl=impl,
nodes_on_bdry=True)
if exponent == float('inf'):
assert discr.one().norm() == 1
else:
assert (discr.one().norm() == pytest.approx(rect.volume**(1 /
exponent)))
# Nodes on the boundary (selective)
discr = odl.uniform_discr_fromspace(fspace, (4, 8),
exponent=exponent,
impl=impl,
nodes_on_bdry=((False, True), False))
if exponent == float('inf'):
assert discr.one().norm() == 1
else:
assert (discr.one().norm() == pytest.approx(rect.volume**(1 /
exponent)))
discr = odl.uniform_discr_fromspace(fspace, (4, 8),
exponent=exponent,
impl=impl,
nodes_on_bdry=(False, (True, False)))
if exponent == float('inf'):
assert discr.one().norm() == 1
else:
assert (discr.one().norm() == pytest.approx(rect.volume**(1 /
exponent)))
# Completely arbitrary boundary
grid = odl.uniform_grid([0, 0], [1, 1], (4, 4))
part = odl.RectPartition(rect, grid)
weight = 1.0 if exponent == float('inf') else part.cell_volume
tspace = odl.rn(part.shape,
dtype=dtype,
impl=impl,
exponent=exponent,
weighting=weight)
discr = DiscreteLp(fspace, part, tspace)
if exponent == float('inf'):
assert discr.one().norm() == 1
else:
assert (discr.one().norm() == pytest.approx(rect.volume**(1 /
exponent)))
def projector(request):
n_angles = 200
geom, impl, angle = request.param.split()
if angle == 'uniform':
apart = odl.uniform_partition(0, 2 * np.pi, n_angles)
elif angle == 'random':
# Linearly spaced with random noise
min_pt = 2 * (2.0 * np.pi) / n_angles
max_pt = (2.0 * np.pi) - 2 * (2.0 * np.pi) / n_angles
points = np.linspace(min_pt, max_pt, n_angles)
points += np.random.rand(n_angles) * (max_pt - min_pt) / (5 * n_angles)
agrid = odl.TensorGrid(points)
apart = odl.RectPartition(odl.Interval(0, 2 * np.pi), agrid)
elif angle == 'nonuniform':
# Angles spaced quadratically
min_pt = 2 * (2.0 * np.pi) / n_angles
max_pt = (2.0 * np.pi) - 2 * (2.0 * np.pi) / n_angles
points = np.linspace(min_pt**0.5, max_pt**0.5, n_angles)**2
agrid = odl.TensorGrid(points)
apart = odl.RectPartition(odl.Interval(0, 2 * np.pi), agrid)
else:
raise ValueError('angle not valid')
if geom == 'par2d':
# Discrete reconstruction space
discr_reco_space = odl.uniform_discr([-20, -20], [20, 20], [100, 100],
dtype='float32')
# Geometry
dpart = odl.uniform_partition(-30, 30, 200)
geom = tomo.Parallel2dGeometry(apart, dpart)
# Ray transform
return tomo.RayTransform(discr_reco_space, geom, impl=impl)
elif geom == 'par3d':
# Discrete reconstruction space
discr_reco_space = odl.uniform_discr([-20, -20, -20], [20, 20, 20],
[100, 100, 100],
dtype='float32')
# Geometry
dpart = odl.uniform_partition([-30, -30], [30, 30], [200, 200])
geom = tomo.Parallel3dAxisGeometry(apart, dpart, axis=[1, 0, 0])
# Ray transform
return tomo.RayTransform(discr_reco_space, geom, impl=impl)
elif geom == 'cone2d':
# Discrete reconstruction space
discr_reco_space = odl.uniform_discr([-20, -20], [20, 20], [100, 100],
dtype='float32')
# Geometry
dpart = odl.uniform_partition(-30, 30, 200)
geom = tomo.FanFlatGeometry(apart,
dpart,
src_radius=200,
det_radius=100)
# Ray transform
return tomo.RayTransform(discr_reco_space, geom, impl=impl)
elif geom == 'cone3d':
# Discrete reconstruction space
discr_reco_space = odl.uniform_discr([-20, -20, -20], [20, 20, 20],
[100, 100, 100],
dtype='float32')
# Geometry
dpart = odl.uniform_partition([-30, -30], [30, 30], [200, 200])
geom = tomo.CircularConeFlatGeometry(apart,
dpart,
src_radius=200,
det_radius=100,
axis=[1, 0, 0])
# Ray transform
return tomo.RayTransform(discr_reco_space, geom, impl=impl)
elif geom == 'helical':
# Discrete reconstruction space
discr_reco_space = odl.uniform_discr([-20, -20, 0], [20, 20, 40],
[100, 100, 100],
dtype='float32')
# Geometry
# TODO: angles
n_angle = 700
apart = odl.uniform_partition(0, 8 * 2 * np.pi, n_angle)
dpart = odl.uniform_partition([-30, -3], [30, 3], [200, 20])
geom = tomo.HelicalConeFlatGeometry(apart,
dpart,
pitch=5.0,
src_radius=200,
det_radius=100)
# Ray transform
return tomo.RayTransform(discr_reco_space, geom, impl=impl)
else:
raise ValueError('param not valid')
def test_partition_cell_volume():
grid = odl.uniform_grid([0, 1], [2, 4], (5, 3))
intv = odl.IntervalProd([0, 1], [2, 4])
part = odl.RectPartition(intv, grid)
true_volume = 0.5 * 1.5
assert part.cell_volume == true_volume
def test_partition_cell_sides():
grid = odl.uniform_grid([0, 1], [2, 4], (5, 3))
intv = odl.IntervalProd([0, 1], [2, 4])
part = odl.RectPartition(intv, grid)
true_sides = [0.5, 1.5]
assert all_equal(part.cell_sides, true_sides)
