def test_reciprocal_grid_nd_axes():
grid = odl.uniform_sampling([0] * 3, [1] * 3, shape=(3, 4, 5))
s = grid.stride
n = np.array(grid.shape)
axes_list = [[1, -1], [0], 0, [0, 2, 1], [2, 0]]
for axes in axes_list:
active = np.zeros(grid.ndim, dtype=bool)
active[axes] = True
inactive = np.logical_not(active)
true_recip_stride = np.empty(grid.ndim)
true_recip_stride[active] = 2 * np.pi / (s[active] * n[active])
true_recip_stride[inactive] = s[inactive]
# Without shift altogether
rgrid = reciprocal_grid(grid, shift=False, axes=axes,
halfcomplex=False)
assert all_equal(rgrid.shape, n)
assert all_almost_equal(rgrid.stride, true_recip_stride)
assert all_almost_equal(rgrid.min_pt[active], -rgrid.max_pt[active])
assert all_equal(rgrid.min_pt[inactive], grid.min_pt[inactive])
assert all_equal(rgrid.max_pt[inactive], grid.max_pt[inactive])
# Inverting should give back the original
irgrid = realspace_grid(rgrid, grid.min_pt, axes=axes,
halfcomplex=False)
assert irgrid.approx_equals(grid, atol=1e-6)
def test_reciprocal_grid_nd_halfcomplex():
grid = odl.uniform_sampling([0] * 3, [1] * 3, shape=(3, 4, 5))
s = grid.stride
n = np.array(grid.shape)
stride_last = 2 * np.pi / (s[-1] * n[-1])
n[-1] = n[-1] // 2 + 1
# Without shift
rgrid = reciprocal_grid(grid, shift=False, halfcomplex=True)
assert all_equal(rgrid.shape, n)
assert rgrid.max_pt[-1] == 0 # last dim is odd
# With shift
rgrid = reciprocal_grid(grid, shift=True, halfcomplex=True)
assert all_equal(rgrid.shape, n)
assert rgrid.max_pt[-1] == -stride_last / 2
# Inverting should give back the original
irgrid = realspace_grid(rgrid, grid.min_pt, halfcomplex=True,
halfcx_parity='odd')
assert irgrid.approx_equals(grid, atol=1e-6)
with pytest.raises(ValueError):
realspace_grid(rgrid, grid.min_pt, halfcomplex=True,
halfcx_parity='+')
def test_reciprocal_grid_nd_halfcomplex():
grid = odl.uniform_grid([0] * 3, [1] * 3, shape=(3, 4, 5))
s = grid.stride
n = np.array(grid.shape)
stride_last = 2 * np.pi / (s[-1] * n[-1])
n[-1] = n[-1] // 2 + 1
# Without shift
rgrid = reciprocal_grid(grid, shift=False, halfcomplex=True)
assert all_equal(rgrid.shape, n)
assert rgrid.max_pt[-1] == 0 # last dim is odd
# With shift
rgrid = reciprocal_grid(grid, shift=True, halfcomplex=True)
assert all_equal(rgrid.shape, n)
assert rgrid.max_pt[-1] == -stride_last / 2
# Inverting should give back the original
irgrid = realspace_grid(rgrid, grid.min_pt, halfcomplex=True,
halfcx_parity='odd')
assert irgrid.approx_equals(grid, atol=1e-6)
with pytest.raises(ValueError):
realspace_grid(rgrid, grid.min_pt, halfcomplex=True,
halfcx_parity='+')
def test_reciprocal_grid_nd_axes():
grid = odl.uniform_grid([0] * 3, [1] * 3, shape=(3, 4, 5))
s = grid.stride
n = np.array(grid.shape)
axes_list = [[1, -1], [0], 0, [0, 2, 1], [2, 0]]
for axes in axes_list:
active = np.zeros(grid.ndim, dtype=bool)
active[axes] = True
inactive = np.logical_not(active)
true_recip_stride = np.empty(grid.ndim)
true_recip_stride[active] = 2 * np.pi / (s[active] * n[active])
true_recip_stride[inactive] = s[inactive]
# Without shift altogether
rgrid = reciprocal_grid(grid, shift=False, axes=axes,
halfcomplex=False)
assert all_equal(rgrid.shape, n)
assert all_almost_equal(rgrid.stride, true_recip_stride)
assert all_almost_equal(rgrid.min_pt[active], -rgrid.max_pt[active])
assert all_equal(rgrid.min_pt[inactive], grid.min_pt[inactive])
assert all_equal(rgrid.max_pt[inactive], grid.max_pt[inactive])
# Inverting should give back the original
irgrid = realspace_grid(rgrid, grid.min_pt, axes=axes,
halfcomplex=False)
assert irgrid.approx_equals(grid, atol=1e-6)
def test_reciprocal_grid_1d(halfcomplex, shift, parity):
shape = 10 if parity == 'even' else 11
grid = odl.uniform_grid(0, 1, shape=shape)
s = grid.stride
n = np.array(grid.shape)
rgrid = reciprocal_grid(grid, shift=shift, halfcomplex=halfcomplex)
# Independent of halfcomplex, shift and parity
true_recip_stride = 2 * np.pi / (s * n)
assert all_almost_equal(rgrid.stride, true_recip_stride)
if halfcomplex:
assert all_equal(rgrid.shape, n // 2 + 1)
if parity == 'odd' and shift:
# Max point should be half a negative recip stride
assert all_almost_equal(rgrid.max_pt, -true_recip_stride / 2)
elif parity == 'even' and not shift:
# Max point should be half a positive recip stride
assert all_almost_equal(rgrid.max_pt, true_recip_stride / 2)
elif (parity == 'odd' and not shift) or (parity == 'even' and shift):
# Max should be zero
assert all_almost_equal(rgrid.max_pt, 0)
else:
raise RuntimeError('parameter combination not covered')
else: # halfcomplex = False
assert all_equal(rgrid.shape, n)
if (parity == 'even' and shift) or (parity == 'odd' and not shift):
# Zero should be at index n // 2
assert all_almost_equal(rgrid[n // 2], 0)
elif (parity == 'odd' and shift) or (parity == 'even' and not shift):
# No point should be closer to 0 than half a recip stride
atol = 0.999 * true_recip_stride / 2
assert not rgrid.approx_contains(0, atol=atol)
else:
raise RuntimeError('parameter combination not covered')
if not shift:
# Grid Should be symmetric
assert all_almost_equal(rgrid.min_pt, -rgrid.max_pt)
if parity == 'odd':
# Midpoint should be 0
assert all_almost_equal(rgrid.mid_pt, 0)
# Inverting should give back the original
irgrid = realspace_grid(rgrid,
grid.min_pt,
halfcomplex=halfcomplex,
halfcx_parity=parity)
assert irgrid.approx_equals(grid, atol=1e-6)
def test_reciprocal_grid_1d(halfcomplex, shift, parity):
shape = 10 if parity == 'even' else 11
grid = odl.uniform_sampling(0, 1, shape=shape)
s = grid.stride
n = np.array(grid.shape)
rgrid = reciprocal_grid(grid, shift=shift, halfcomplex=halfcomplex)
# Independent of halfcomplex, shift and parity
true_recip_stride = 2 * np.pi / (s * n)
assert all_almost_equal(rgrid.stride, true_recip_stride)
if halfcomplex:
assert all_equal(rgrid.shape, n // 2 + 1)
if parity == 'odd' and shift:
# Max point should be half a negative recip stride
assert all_almost_equal(rgrid.max_pt, -true_recip_stride / 2)
elif parity == 'even' and not shift:
# Max point should be half a positive recip stride
assert all_almost_equal(rgrid.max_pt, true_recip_stride / 2)
elif (parity == 'odd' and not shift) or (parity == 'even' and shift):
# Max should be zero
assert all_almost_equal(rgrid.max_pt, 0)
else:
raise RuntimeError('parameter combination not covered')
else: # halfcomplex = False
assert all_equal(rgrid.shape, n)
if (parity == 'even' and shift) or (parity == 'odd' and not shift):
# Zero should be at index n // 2
assert all_almost_equal(rgrid[n // 2], 0)
elif (parity == 'odd' and shift) or (parity == 'even' and not shift):
# No point should be closer to 0 than half a recip stride
atol = 0.999 * true_recip_stride / 2
assert not rgrid.approx_contains(0, atol=atol)
else:
raise RuntimeError('parameter combination not covered')
if not shift:
# Grid Should be symmetric
assert all_almost_equal(rgrid.min_pt, -rgrid.max_pt)
if parity == 'odd':
# Midpoint should be 0
assert all_almost_equal(rgrid.mid_pt, 0)
# Inverting should give back the original
irgrid = realspace_grid(rgrid, grid.min_pt, halfcomplex=halfcomplex,
halfcx_parity=parity)
assert irgrid.approx_equals(grid, atol=1e-6)
def test_reciprocal_grid_nd():
grid = odl.uniform_sampling([0] * 3, [1] * 3, shape=(3, 4, 5))
s = grid.stride
n = np.array(grid.shape)
true_recip_stride = 2 * np.pi / (s * n)
# Without shift altogether
rgrid = reciprocal_grid(grid, shift=False, halfcomplex=False)
assert all_equal(rgrid.shape, n)
assert all_almost_equal(rgrid.stride, true_recip_stride)
assert all_almost_equal(rgrid.min_pt, -rgrid.max_pt)
# Inverting should give back the original
irgrid = realspace_grid(rgrid, grid.min_pt, halfcomplex=False)
assert irgrid.approx_equals(grid, atol=1e-6)
def test_reciprocal_grid_nd():
grid = odl.uniform_grid([0] * 3, [1] * 3, shape=(3, 4, 5))
s = grid.stride
n = np.array(grid.shape)
true_recip_stride = 2 * np.pi / (s * n)
# Without shift altogether
rgrid = reciprocal_grid(grid, shift=False, halfcomplex=False)
assert all_equal(rgrid.shape, n)
assert all_almost_equal(rgrid.stride, true_recip_stride)
assert all_almost_equal(rgrid.min_pt, -rgrid.max_pt)
# Inverting should give back the original
irgrid = realspace_grid(rgrid, grid.min_pt, halfcomplex=False)
assert irgrid.approx_equals(grid, atol=1e-6)
def test_reciprocal_grid_nd_shift_list():
grid = odl.uniform_sampling([0] * 3, [1] * 3, shape=(3, 4, 5))
s = grid.stride
n = np.array(grid.shape)
shift = [False, True, False]
true_recip_stride = 2 * np.pi / (s * n)
# Shift only the even dimension, then zero must be contained
rgrid = reciprocal_grid(grid, shift=shift, halfcomplex=False)
noshift = np.where(np.logical_not(shift))
assert all_equal(rgrid.shape, n)
assert all_almost_equal(rgrid.stride, true_recip_stride)
assert all_almost_equal(rgrid.min_pt[noshift], -rgrid.max_pt[noshift])
assert all_almost_equal(rgrid[n // 2], [0] * 3)
# Inverting should give back the original
irgrid = realspace_grid(rgrid, grid.min_pt, halfcomplex=False)
assert irgrid.approx_equals(grid, atol=1e-6)
def test_reciprocal_grid_nd_shift_list():
grid = odl.uniform_grid([0] * 3, [1] * 3, shape=(3, 4, 5))
s = grid.stride
n = np.array(grid.shape)
shift = [False, True, False]
true_recip_stride = 2 * np.pi / (s * n)
# Shift only the even dimension, then zero must be contained
rgrid = reciprocal_grid(grid, shift=shift, halfcomplex=False)
noshift = np.where(np.logical_not(shift))
assert all_equal(rgrid.shape, n)
assert all_almost_equal(rgrid.stride, true_recip_stride)
assert all_almost_equal(rgrid.min_pt[noshift], -rgrid.max_pt[noshift])
assert all_almost_equal(rgrid[n // 2], [0] * 3)
# Inverting should give back the original
irgrid = realspace_grid(rgrid, grid.min_pt, halfcomplex=False)
assert irgrid.approx_equals(grid, atol=1e-6)
