def test_RectGrid_points():
vec1 = np.array([2, 3, 4, 5])
vec2 = np.array([-4, -2, 0, 2, 4])
scalar = 0.5
# C ordering
points = []
for x1 in vec1:
for x2 in vec2:
points.append(np.array((x1, x2), dtype=float))
grid = RectGrid(vec1, vec2)
assert all_equal(points, grid.points())
assert all_equal(points, grid.points(order='C'))
assert all_equal(grid.min_pt, grid.points()[0])
assert all_equal(grid.max_pt, grid.points()[-1])
# F ordering
points = []
for x2 in vec2:
for x1 in vec1:
points.append(np.array((x1, x2), dtype=float))
grid = RectGrid(vec1, vec2)
assert all_equal(points, grid.points(order='F'))
# Degenerate axis 1
points = []
for x1 in vec1:
for x2 in vec2:
points.append(np.array((scalar, x1, x2), dtype=float))
grid = RectGrid(scalar, vec1, vec2)
assert all_equal(points, grid.points())
# Degenerate axis 2
points = []
for x1 in vec1:
for x2 in vec2:
points.append(np.array((x1, scalar, x2), dtype=float))
grid = RectGrid(vec1, scalar, vec2)
assert all_equal(points, grid.points())
# Degenerate axis 3
points = []
for x1 in vec1:
for x2 in vec2:
points.append(np.array((x1, x2, scalar), dtype=float))
grid = RectGrid(vec1, vec2, scalar)
assert all_equal(points, grid.points())
# Bad input
with pytest.raises(ValueError):
grid.points(order='A')
def corners(self, order='C'):
"""Return the corner points as a single array.
Parameters
----------
order : {'C', 'F'}, optional
Ordering of the axes in which the corners appear in
the output. ``'C'`` means that the first axis varies slowest
and the last one fastest, vice versa in ``'F'`` ordering.
Returns
-------
corners : `numpy.ndarray`
Array containing the corner coordinates. The size of the
array is ``2^m x ndim``, where ``m`` is the number of
non-degenerate axes, i.e. the corners are stored as rows.
Examples
--------
>>> intv = IntervalProd([-1, 2, 0], [-0.5, 3, 0.5])
>>> intv.corners()
array([[-1. , 2. , 0. ],
[-1. , 2. , 0.5],
[-1. , 3. , 0. ],
[-1. , 3. , 0.5],
[-0.5, 2. , 0. ],
[-0.5, 2. , 0.5],
[-0.5, 3. , 0. ],
[-0.5, 3. , 0.5]])
>>> intv.corners(order='F')
array([[-1. , 2. , 0. ],
[-0.5, 2. , 0. ],
[-1. , 3. , 0. ],
[-0.5, 3. , 0. ],
[-1. , 2. , 0.5],
[-0.5, 2. , 0.5],
[-1. , 3. , 0.5],
[-0.5, 3. , 0.5]])
"""
from odl.discr.grid import RectGrid
minmax_vecs = [0] * self.ndim
for axis in np.where(~self.nondegen_byaxis)[0]:
minmax_vecs[axis] = self.min_pt[axis]
for axis in np.where(self.nondegen_byaxis)[0]:
minmax_vecs[axis] = (self.min_pt[axis], self.max_pt[axis])
minmax_grid = RectGrid(*minmax_vecs)
return minmax_grid.points(order=order)
def corners(self, order='C'):
"""Return the corner points as a single array.
Parameters
----------
order : {'C', 'F'}, optional
Ordering of the axes in which the corners appear in
the output. ``'C'`` means that the first axis varies slowest
and the last one fastest, vice versa in ``'F'`` ordering.
Returns
-------
corners : `numpy.ndarray`
Array containing the corner coordinates. The size of the
array is ``2^m x ndim``, where ``m`` is the number of
non-degenerate axes, i.e. the corners are stored as rows.
Examples
--------
>>> rbox = IntervalProd([-1, 2, 0], [-0.5, 3, 0.5])
>>> rbox.corners()
array([[-1. , 2. , 0. ],
[-1. , 2. , 0.5],
[-1. , 3. , 0. ],
...,
[-0.5, 2. , 0.5],
[-0.5, 3. , 0. ],
[-0.5, 3. , 0.5]])
>>> rbox.corners(order='F')
array([[-1. , 2. , 0. ],
[-0.5, 2. , 0. ],
[-1. , 3. , 0. ],
...,
[-0.5, 2. , 0.5],
[-1. , 3. , 0.5],
[-0.5, 3. , 0.5]])
"""
from odl.discr.grid import RectGrid
minmax_vecs = [0] * self.ndim
for axis in np.where(~self.nondegen_byaxis)[0]:
minmax_vecs[axis] = self.min_pt[axis]
for axis in np.where(self.nondegen_byaxis)[0]:
minmax_vecs[axis] = (self.min_pt[axis], self.max_pt[axis])
minmax_grid = RectGrid(*minmax_vecs)
return minmax_grid.points(order=order)
def test_empty_grid():
"""Check if empty grids behave as expected and all methods work."""
grid = RectGrid()
assert grid.ndim == grid.size == len(grid) == 0
assert grid.shape == ()
assert grid.coord_vectors == ()
assert grid.nondegen_byaxis == ()
assert np.array_equal(grid.min_pt, [])
assert np.array_equal(grid.max_pt, [])
assert np.array_equal(grid.mid_pt, [])
assert np.array_equal(grid.stride, [])
assert np.array_equal(grid.extent, [])
out = np.array([])
grid.min(out=out)
grid.max(out=out)
assert grid.is_uniform
assert grid.convex_hull() == odl.IntervalProd([], [])
same = RectGrid()
assert grid == same
assert hash(grid) == hash(same)
other = RectGrid([0, 2, 3])
assert grid != other
assert grid.is_subgrid(other)
assert [] in grid
assert 1.0 not in grid
assert grid.insert(0, other) == other
assert other.insert(0, grid) == other
assert other.insert(1, grid) == other
assert grid.squeeze() == grid
assert np.array_equal(grid.points(), np.array([]).reshape((0, 0)))
assert grid.corner_grid() == grid
assert np.array_equal(grid.corners(), np.array([]).reshape((0, 0)))
assert grid.meshgrid == ()
assert grid[[]] == grid
assert np.array_equal(np.asarray(grid), np.array([]).reshape((0, 0)))
assert grid == uniform_grid([], [], ())
repr(grid)