def test_spread_excluder_multi_axes_per_gen(self):
gx1_pos = np.array([1, 2, 3, 4, 5])
gx2_pos = np.array([11, 10, 9, 8, 7])
gy_pos = np.array([-1, 0, 1])
gz_pos = np.array([1, 0, -1, -2, -3])
mask_x1z_func = lambda px, pz: (px-4)**2 + (pz+1)**2 <= 1
exz = Mock(axes=["gx1", "gz"], create_mask=Mock(side_effect=mask_x1z_func))
gx = Mock(axes=["gx1", "gx2"], positions={"gx1":gx1_pos, "gx2":gx2_pos}, size=5, alternate=False)
gy = Mock(axes=["gy"], positions={"gy":gy_pos}, size=3, alternate=False)
gz = Mock(axes=["gz"], positions={"gz":gz_pos}, size=5, alternate=False)
d = Dimension.merge_dimensions([Dimension(gz), Dimension(gy), Dimension(gx)])
d.apply_excluder(exz)
d.prepare()
x1_positions = np.tile(gx1_pos, 15)
x2_positions = np.tile(gx2_pos, 15)
y_positions = np.repeat(np.tile(gy_pos, 5), 5)
z_positions = np.repeat(gz_pos, 15)
mask = mask_x1z_func(x1_positions, z_positions)
expected_x1 = x1_positions[mask].tolist()
expected_x2 = x2_positions[mask].tolist()
expected_y = y_positions[mask].tolist()
expected_z = z_positions[mask].tolist()
self.assertEqual(expected_x1, d.get_positions("gx1").tolist())
self.assertEqual(expected_x2, d.get_positions("gx2").tolist())
self.assertEqual(expected_y, d.get_positions("gy").tolist())
self.assertEqual(expected_z, d.get_positions("gz").tolist())
def test_merge_dimensions(self):
g, h = Mock(), Mock()
g.axes, h.axes = ["gx", "gy"], ["hx", "hy"]
g.size, h.size = 16, 64
g.positions = {"gx":np.array([0, 1, 2]), "gy":np.array([10, 11, 12])}
h.positions = {"hx":np.array([0, -1, -2]), "hy":np.array([-10, -11, -12])}
outer, inner = Dimension(g), Dimension(h)
om1, om2 = Mock(), Mock()
im1, im2 = Mock(), Mock()
outer._masks = [{"repeat":2, "tile":3, "mask":om1},
{"repeat":5, "tile":7, "mask":om2}]
inner._masks = [{"repeat":11, "tile":13, "mask":im1},
{"repeat":17, "tile":19, "mask":im2}]
combined = Dimension.merge_dimensions([outer, inner])
self.assertEqual(g.size * h.size, combined._max_length)
self.assertEqual(outer.alternate or inner.alternate, combined.alternate)
self.assertEqual(["gx", "gy", "hx", "hy"], combined.axes)
self.assertEqual([2, 12, 0, -10], combined.upper)
self.assertEqual([0, 10, -2, -12], combined.lower)
expected_masks = [
{"repeat":128, "tile":3, "mask":om1},
{"repeat":320, "tile":7, "mask":om2},
{"repeat":11, "tile":13*16, "mask":im1},
{"repeat":17, "tile":19*16, "mask":im2}]
self.assertEqual(expected_masks, combined._masks)
def test_merge_three(self):
g1, g2, g3 = Mock(), Mock(), Mock()
g1.axes, g2.axes, g3.axes = ["g1"], ["g2"], ["g3"]
g1.size, g2.size, g3.size = 3, 4, 5
g1.positions = {"g1":np.array([0, 1, 2])}
g2.positions = {"g2":np.array([-1, 0, 1, 2])}
g3.positions = {"g3":np.array([-2, 0, 2, 4, 6])}
d1, d2, d3 = Dimension(g1), Dimension(g2), Dimension(g3)
d1_m, d2_m, d3_m = Mock(), Mock(), Mock()
d1._masks = [{"repeat":1, "tile":1, "mask":d1_m}]
d2._masks = [{"repeat":2, "tile":3, "mask":d2_m}]
d3._masks = [{"repeat":5, "tile":7, "mask":d3_m}]
combined = Dimension.merge_dimensions([d1, d2, d3])
self.assertEqual(60, combined._max_length)
self.assertEqual(g1.alternate or g2.alternate or g3.alternate, combined.alternate)
self.assertEqual(["g1", "g2", "g3"], combined.axes)
self.assertEqual([0, -1, -2], combined.lower)
self.assertEqual([2, 2, 6], combined.upper)
expected_masks = [
{"repeat":20, "tile":1, "mask":d1_m},
{"repeat":10, "tile":9, "mask":d2_m},
{"repeat":5, "tile":84, "mask":d3_m}]
self.assertEqual(expected_masks, combined._masks)
def test_high_dimensional_excluder(self):
w_pos = np.array([0, 1, 2, 3, 4, 5])
x_pos = np.array([0, 1, 2, 3, 4, 5])
y_pos = np.array([0, 1, 2, 3, 4, 5])
z_pos = np.array([0, 1, 2, 3, 4, 5])
mask_function = lambda pw, px, py, pz: (pw-2)**2 + (px-2)**2 + (py-1)**2 + (pz-3)**2 <= 1.1
excluder = Mock(axes=["w", "x", "y", "z"], create_mask=Mock(side_effect=mask_function))
gw = Mock(axes=["w"], positions={"w":w_pos}, size=len(w_pos), alternate=False)
gx = Mock(axes=["x"], positions={"x":x_pos}, size=len(x_pos), alternate=False)
gy = Mock(axes=["y"], positions={"y":y_pos}, size=len(y_pos), alternate=False)
gz = Mock(axes=["z"], positions={"z":z_pos}, size=len(z_pos), alternate=False)
d = Dimension.merge_dimensions([Dimension(gz), Dimension(gy), Dimension(gx), Dimension(gw)])
d.apply_excluder(excluder)
d.prepare()
w_positions = np.tile(w_pos, len(x_pos) * len(y_pos) * len(z_pos))
x_positions = np.repeat(np.tile(x_pos, len(y_pos) * len(z_pos)), len(w_pos))
y_positions = np.repeat(np.tile(y_pos, len(z_pos)), len(w_pos) * len(x_pos))
z_positions = np.repeat(z_pos, len(w_pos) * len(x_pos) * len(y_pos))
mask = mask_function(w_positions, x_positions, y_positions, z_positions)
w_expected = w_positions[mask].tolist()
x_expected = x_positions[mask].tolist()
y_expected = y_positions[mask].tolist()
z_expected = z_positions[mask].tolist()
self.assertEqual(w_expected, d.get_positions("w").tolist())
self.assertEqual(x_expected, d.get_positions("x").tolist())
self.assertEqual(y_expected, d.get_positions("y").tolist())
self.assertEqual(z_expected, d.get_positions("z").tolist())
def test_excluder_spread_axes(self):
sp = SpiralGenerator(["s1", "s2"], ["mm", "mm"], centre=[0, 0], radius=1, scale=0.5, alternate=True)
y = LineGenerator("y", "mm", 0, 1, 3, True)
z = LineGenerator("z", "mm", -2, 3, 6, True)
e = ROIExcluder([CircularROI([0., 0.], 1.0)], ["s1", "z"])
g = CompoundGenerator([z, y, sp], [e], [])
g.prepare()
s1_pos, s2_pos = sp.positions["s1"], sp.positions["s2"]
s1_pos = np.tile(np.append(s1_pos, s1_pos[::-1]), 9)
s2_pos = np.tile(np.append(s2_pos, s2_pos[::-1]), 9)
y_pos = np.tile(np.repeat(np.array([0, 0.5, 1.0, 1.0, 0.5, 0]), sp.size), 3)
z_pos = np.repeat(np.array([-2, -1, 0, 1, 2, 3]), sp.size * 3)
mask_func = lambda ps1, pz: ps1**2 + pz**2 <= 1
mask = mask_func(s1_pos, z_pos)
expected_s1 = s1_pos[mask]
expected_s2 = s2_pos[mask]
expected_y = y_pos[mask]
expected_z = z_pos[mask]
expected_positions = [{'s1':ps1, 's2':ps2, 'y':py, 'z':pz}
for (ps1, ps2, py, pz) in zip(expected_s1, expected_s2, expected_y, expected_z)]
positions = [point.positions for point in list(g.iterator())]
self.assertEqual(positions, expected_positions)
def test_single_alternating_generator_with_excluder(self):
x_pos = np.array([0, 1, 2, 3, 4, 5])
x_bounds = np.array([-0.5, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5])
y_pos = np.array([10, 11, 12, 13, 14, 15])
y_bounds = np.array([9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5])
g = Mock(axes=["x", "y"],
positions={
"x": x_pos,
"y": y_pos
},
bounds={
"x": x_bounds,
"y": y_bounds
},
size=6)
g.alternate = True
mask = np.array([1, 1, 0, 1, 0, 0], dtype=np.int8)
e = Mock(axes=["x", "y"], create_mask=Mock(return_value=mask))
d = Dimension([g], [e])
self.assertTrue(d.alternate)
d.prepare()
expected_x = [0, 1, 3]
expected_y = [10, 11, 13]
self.assertEqual(expected_x, d.positions["x"].tolist())
self.assertEqual(expected_y, d.positions["y"].tolist())
def produce_points(self):
self.points = {}
self.points_lower = {}
self.points_upper = {}
for axis in range_(self.num_axes):
axis_name = self.name[axis]
start = self.start[axis]
stop = self.stop[axis]
d = stop - start
if self.num == 1:
self.points[axis_name] = np.array([start])
self.points_upper[axis_name] = np.array([start + 0.5 * d])
self.points_lower[axis_name] = np.array([start - 0.5 * d])
else:
n = self.num - 1.
s = d / n
upper_start = start + 0.5 * d / n
upper_stop = stop + 0.5 * d / n
lower_start = start - 0.5 * d / n
lower_stop = stop - 0.5 * d / n
self.points[axis_name] = np.linspace(
float(start), float(stop), self.num)
self.points_upper[axis_name] = np.linspace(
float(upper_start), float(upper_stop), self.num)
self.points_lower[axis_name] = np.linspace(
float(lower_start), float(lower_stop), self.num)
def test_apply_excluders_over_multiple_gens(self):
gx_pos = np.array([1, 2, 3, 4, 5])
gy_pos = np.zeros(5)
hx_pos = np.zeros(5)
hy_pos = np.array([-1, -2, -3])
mask = np.full(15, 1, dtype=np.int8)
e = Mock(axes=["gx", "hy"], create_mask=Mock(return_value=mask))
g = Mock(axes=["gx", "gy"],
positions={
"gx": gx_pos,
"gy": gy_pos
},
size=len(gx_pos),
alternate=False)
h = Mock(axes=["hx", "hy"],
positions={
"hx": hx_pos,
"hy": hy_pos
},
size=len(hy_pos),
alternate=False)
d = Dimension(g)
d.generators = [g, h]
d.size = g.size * h.size
d.apply_excluder(e)
d._masks[0]["mask"] = d._masks[0]["mask"].tolist()
self.assertEqual([{
"repeat": 1,
"tile": 1,
"mask": mask.tolist()
}], d._masks)
self.assertTrue((np.repeat(np.array([1, 2, 3, 4, 5]),
3) == e.create_mask.call_args[0][0]).all())
self.assertTrue((np.tile(np.array([-1, -2, -3]),
5) == e.create_mask.call_args[0][1]).all())
def test_get_mesh_map(self):
# Set up a generator, with 3x4 grid with alternating x and a circular
# excluder such that the four 'corners' of the grid are excluded
gx_pos = np.array([0.1, 0.2, 0.3])
gx_bounds = np.array([0.05, 0.15, 0.25, 0.35])
gy_pos = np.array([1.1, 1.2, 1.3, 1.4])
mask_func = lambda px, py: (px - 0.2)**2 + (py - 1.25)**2 <= 0.0225
gx = Mock(axes=["gx"],
positions={"gx": gx_pos},
bounds={"gx": gx_bounds},
size=3,
alternate=True)
gy = Mock(axes=["gy"],
positions={"gy": gy_pos},
size=4,
alternate=False)
e = Mock(axes=["gx", "gy"], create_mask=Mock(side_effect=mask_func))
d = Dimension([gy, gx], [e])
d.prepare()
self.assertEqual([1, 2, 1, 0, 0, 1, 2, 1],
d.get_mesh_map("gx").tolist())
self.assertEqual([0, 1, 1, 1, 2, 2, 2, 3],
d.get_mesh_map("gy").tolist())
def test_mask_points(self):
points = [np.array([7., 9.]), np.array([11., 11.])]
points_cp = [axis.copy().tolist() for axis in points]
expected = [True, False]
mask = self.roi.mask_points(points)
self.assertEqual(expected, mask.tolist())
self.assertEqual(points_cp, [axis.tolist() for axis in points])
def test_get_positions_with_alternating(self):
gx_pos = np.array([0, 1, 2, 3])
gy_pos = np.array([0, 1, 2, 3])
gz_pos = np.array([0, 1, 2, 3])
mask_xy_func = lambda px, py: (px-1)**2 + (py-2)**2 <= 2
mask_yz_func = lambda py, pz: (py-2)**2 + (pz-1)**2 <= 1
exy = Mock(axes=["gx", "gy"], create_mask=Mock(side_effect=mask_xy_func))
eyz = Mock(axes=["gy", "gz"], create_mask=Mock(side_effect=mask_yz_func))
gx = Mock(axes=["gx"], positions={"gx":gx_pos}, size=4, alternate=True)
gy = Mock(axes=["gy"], positions={"gy":gy_pos}, size=4, alternate=True)
gz = Mock(axes=["gz"], positions={"gz":gz_pos}, size=4, alternate=True)
dx = Dimension(gx)
dy = Dimension(gy)
dz = Dimension(gz)
d = Dimension.merge_dimensions([dz, dy, dx])
d.apply_excluder(exy)
d.apply_excluder(eyz)
d.prepare()
self.assertEqual(15, d.size)
self.assertEqual(
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2],
d.get_positions("gz").tolist())
self.assertEqual(
[2, 2, 2, 3, 3, 3, 2, 2, 2, 1, 1, 1, 2, 2, 2],
d.get_positions("gy").tolist())
self.assertEqual(
[0, 1, 2, 0, 1, 2, 2, 1, 0, 0, 1, 2, 0, 1, 2],
d.get_positions("gx").tolist())
def test_create_mask_returns_all_points(self):
x_points = np.array([1, 2, 3, 4])
y_points = np.array([10, 10, 20, 20])
expected_mask = np.array([True, True, True, True])
mask = self.e.create_mask(x_points, y_points)
self.assertEqual(expected_mask.tolist(), mask.tolist())
def test_simple_point_contains(self):
vertices_x = [0, 1, 2, 2, -1, -1]
vertices_y = [0, 0, -1, 1, 1, -1]
roi = PolygonalROI(vertices_x, vertices_y)
px = [-0.9, 1.9, 0.5, 0.5, 2.2, -1.1]
py = [-0.85, 0.85, -0.5, 0.5, 0.5, 0.5]
p = [np.array(px), np.array(py)]
expected = [True, True, False, True, False, False]
mask = roi.mask_points(p)
self.assertEquals(expected, mask.tolist())
def test_mask_points(self):
roi = EllipticalROI([1, 2], [2, 1], pi / 6)
points = [
np.array([3, 1, 2.73, 3.00, -0.73]),
np.array([1, 0, 3.00, 4.27, 1.000])
]
points_cp = [axis.copy().tolist() for axis in points]
expected = [False, False, True, False, True]
self.assertEquals(expected, roi.mask_points(points).tolist())
self.assertEqual(points_cp, [axis.tolist() for axis in points])
def test_mask(self):
roi = RectangularROI([1, 2], 1, 1, pi / 4)
points = [
np.array([2, 2, 1, 1, 1.7, 0.3, 1.01, 0.99]),
np.array([3, 2, 2, 3.4, 2.7, 2.705, 1.99, 1.99])
]
points_cp = [axis.copy().tolist() for axis in points]
expected = [False, False, True, True, True, True, False, False]
mask = roi.mask_points(points)
self.assertEqual(expected, mask.tolist())
self.assertEqual(points_cp, [axis.tolist() for axis in points])
def test_get_positions_single_gen(self):
gx_pos = np.tile(np.array([0, 1, 2, 3]), 4)
gy_pos = np.repeat(np.array([0, 1, 2, 3]), 4)
mask_func = lambda px, py: (px-1)**2 + (py-2)**2 <= 1
g = Mock(axes=["gx", "gy"], positions={"gx":gx_pos, "gy":gy_pos}, size=16, alternate=False)
e = Mock(axes=["gx", "gy"], create_mask=Mock(side_effect=mask_func))
d = Dimension(g)
d.apply_excluder(e)
d.prepare()
self.assertEqual([1, 0, 1, 2, 1], d.get_positions("gx").tolist())
self.assertEqual([1, 2, 2, 2, 3], d.get_positions("gy").tolist())
def __init__(self, points_x, points_y):
# type: (UPointsX, UPointsY) -> None
super(PolygonalROI, self).__init__()
if len(points_x) != len(points_y):
raise ValueError("Point arrays must be the same size")
if len(points_x) < 3:
raise ValueError("Polygon requires at least 3 vertices")
# TODO: check points are not all collinear
# (i.e. describe at least a triangle)
self.points_x = APointsX(np.array(points_x, dtype=np.float64))
self.points_y = APointsY(np.array(points_y, dtype=np.float64))
def test_mask_points(self):
l = LinearROI([1, 1], 2 * sqrt(2), -pi / 4 - 2 * pi)
px = [
1, 2, 3, 1 + 1e-10, 3 - 1e-10, 2 + 1e-10, 2 - 1e-14, 3 + 1e-14, 1
]
py = [1, 0, -1, 1, -1, 0 + 1e-10, 0 + 1e-14, -1 - 1e-14, 1 + 1e-14]
p = [np.array(px), np.array(py)]
points_cp = [axis.copy().tolist() for axis in p]
expected = [True, True, True, False, False, False, True, True, True]
mask = l.mask_points(p, 1e-12)
self.assertEquals(expected, mask.tolist())
self.assertEqual(points_cp, [axis.tolist() for axis in p])
def test_single_axis_excluder(self):
x_pos = np.array([0, 1, 2, 3, 4, 5])
y_pos = np.array([10, 11, 12, 13, 14, 15])
g = Mock(axes=["x", "y"], positions={"x":x_pos, "y":y_pos}, size=len(x_pos))
g.alternate = False
e = Mock(axes=["x"], create_mask=lambda x: (2 <= x) & (x < 4) | (x == 5))
d = Dimension(g)
d.apply_excluder(e)
d.prepare()
self.assertEqual([2, 3, 5], d.get_positions('x').tolist())
self.assertEqual([12, 13, 15], d.get_positions('y').tolist())
def test_complex_mask_points(self):
vertices_x = [0, 0, 2, 2, 1, 1, 3, 3]
vertices_y = [0, 2, 2, 1, 1, 3, 3, 0]
roi = PolygonalROI(vertices_x, vertices_y)
px = [0.5, 0.5, 1.5, 1.5, 2.5, 2.5, 3.5, -0.5, 3.5, 2, 3, 0]
py = [0.5, 2.5, 1.5, 2.5, 2.5, -0.5, 1.5, 0.5, 0.5, 0, 2, 1.5]
p = [np.array(px), np.array(py)]
points_cp = [axis.copy().tolist() for axis in p]
expected = [True, False, False, True, True, False, False, False, False,
True, False, True]
mask = roi.mask_points(p)
self.assertEquals(expected, mask.tolist())
self.assertEqual(points_cp, [axis.tolist() for axis in p])
def test_apply_excluders_over_single_alternating(self):
x_pos = np.array([1, 2, 3, 4, 5])
y_pos = np.array([10, 11, 12, 13, 14, 15])
g = Mock(axes=["x", "y"], positions={"x":x_pos, "y":y_pos})
g.alternate = True
mask = np.array([1, 1, 0, 1, 0, 0], dtype=np.int8)
e = Mock(axes=["x", "y"], create_mask=Mock(return_value=mask))
d = Dimension(g)
d.apply_excluder(e)
d._masks[0]["mask"] = d._masks[0]["mask"].tolist()
self.assertEqual([{"repeat":1, "tile":0.5, "mask":mask.tolist()}], d._masks)
self.assertTrue((np.append(x_pos, x_pos[::-1]) == e.create_mask.call_args[0][0]).all())
self.assertTrue((np.append(y_pos, y_pos[::-1]) == e.create_mask.call_args[0][1]).all())
def test_positions_non_alternate(self):
g1, g2, g3 = Mock(), Mock(), Mock()
g1.axes, g2.axes, g3.axes = ["g1"], ["g2"], ["g3"]
g1.size, g2.size, g3.size = 3, 4, 5
g1.positions = {"g1": np.array([0, 1, 2])}
g1.bounds = {"g1": np.array([-0.5, 0.5, 1.5, 2.5])}
g2.positions = {"g2": np.array([-1, 0, 1, 2])}
g2.bounds = {"g2": np.array([-1.5, -0.5, 0.5, 1.5, 2.5])}
g3.positions = {"g3": np.array([-2, 0, 2, 4, 6])}
g3.bounds = {"g3": np.array([-3, -1, 1, 3, 5, 7])}
g1.alternate = False
g2.alternate = False
g3.alternate = False
e1, e2 = Mock(), Mock()
e1.axes = ["g1", "g2"]
e2.axes = ["g2", "g3"]
m1 = np.repeat(np.array([0, 1, 0, 1, 1, 0]), 10)
m2 = np.tile(np.array([1, 0, 0, 1, 1, 1]), 10)
e1.create_mask.return_value = m1
e2.create_mask.return_value = m2
d = Dimension([g1, g2, g3], [e1, e2])
d.prepare()
expected_mask = m1 & m2
expected_indices = expected_mask.nonzero()[0]
expected_g1 = np.repeat(g1.positions["g1"], 5 * 4)[expected_indices]
expected_g2 = np.tile(np.repeat(g2.positions["g2"], 5),
3)[expected_indices]
expected_g3 = np.tile(g3.positions["g3"], 3 * 4)[expected_indices]
self.assertEqual(expected_mask.tolist(), d.mask.tolist())
self.assertEqual(expected_indices.tolist(), d.indices.tolist())
self.assertEqual(expected_g1.tolist(), d.positions["g1"].tolist())
self.assertEqual(expected_g2.tolist(), d.positions["g2"].tolist())
self.assertEqual(expected_g3.tolist(), d.positions["g3"].tolist())
def test_dim_invalid_alternating(self):
g1 = Mock(axes=["x"],
positions={"x": np.array([1, 2, 3])},
bounds={"x": np.array([0.5, 1.5, 2.5, 3.5])},
size=3,
alternate=True)
g2 = Mock(axes=["y"],
positions={"y": np.array([1, 2, 3])},
bounds={"y": np.array([0.5, 1.5, 2.5, 3.5])},
size=3,
alternate=False)
with self.assertRaises(ValueError):
d = Dimension([g1, g2])
def test_two_generators_init(self):
g, h = Mock(), Mock()
g.axes, h.axes = ["gx", "gy"], ["hx", "hy"]
g.size, h.size = 16, 64
g.alternate = False
h.alternate = False
g.positions = {"gx": np.array([0, 1, 2]), "gy": np.array([10, 11, 12])}
g.bounds = {
"gx": np.array([-0.5, 0.5, 1.5, 2.5]),
"gy": np.array([9.5, 10.5, 11.5, 12.5])
}
h.positions = {
"hx": np.array([0, -1, -2]),
"hy": np.array([-10, -11, -12])
}
h.bounds = {
"hx": np.array([0.5, -0.5, -1.5, -2.5]),
"hy": np.array([-9.5, -10.5, -11.5, -12.5])
}
d = Dimension([g, h])
self.assertEqual(False, d.alternate)
self.assertEqual(["gx", "gy", "hx", "hy"], d.axes)
self.assertEqual([2, 12, 0, -10], d.upper)
self.assertEqual([0, 10, -2, -12], d.lower)
def test_mask_points(self):
roi = PointROI([1, 2])
px = [1, 0, 1 + 1e-15, 1, 1]
py = [2, 0, 2, 2 + 1e-15, 2 + 1e-14]
expected = [True, False, True, True, False]
p = [np.array(px), np.array(py)]
points_cp = [axis.copy().tolist() for axis in p]
mask = roi.mask_points(p, 2e-15)
self.assertEqual(expected, mask.tolist())
mask = roi.mask_points([np.array(px), np.array(py)], 0)
expected = [True, False, False, False, False]
self.assertEqual(expected, mask.tolist())
self.assertEqual(points_cp, [axis.tolist() for axis in p])
def test_init(self):
g = Mock()
g.axes = ["x", "y"]
g.positions = {"x":np.array([0, 1, 2]), "y":np.array([10, 11, 12])}
g.size = 3
d = Dimension(g)
d.prepare()
self.assertEqual([g], d.generators)
self.assertEqual(["x", "y"], d.axes)
self.assertEqual([], d._masks)
self.assertEqual(g.alternate, d.alternate)
self.assertEqual(g.size, d.size)
self.assertEqual([2, 12], d.upper)
self.assertEqual([0, 10], d.lower)
def test_get_positions_after_merge(self):
gx_pos = np.array([0, 1, 2, 3])
gy_pos = np.array([0, 1, 2, 3])
mask_func = lambda px, py: (px-1)**2 + (py-2)**2 <= 1
gx = Mock(axes=["gx"], positions={"gx":gx_pos}, size=4, alternate=False)
gy = Mock(axes=["gy"], positions={"gy":gy_pos}, size=4, alternate=False)
e = Mock(axes=["gx", "gy"], create_mask=Mock(side_effect=mask_func))
dx = Dimension(gx)
dy = Dimension(gy)
d = Dimension.merge_dimensions([dy, dx])
d.apply_excluder(e)
d.prepare()
self.assertEqual([1, 0, 1, 2, 1], d.get_positions("gx").tolist())
self.assertEqual([1, 2, 2, 2, 3], d.get_positions("gy").tolist())
def test_mask_points(self):
s = SectorROI((0, 1), (1, 2), (-pi / 2, pi / 2))
p = [
np.array([0, 1, 0, 2.05, 1, 0.7, -1.5, 0.00]),
np.array([0, 0, 1, 0.00, 1, 0.7, 0.00, 2.05])
]
points_cp = [axis.copy().tolist() for axis in p]
expected = [True, True, False, False, True, False, False, True]
mask = s.mask_points(p)
self.assertEquals(expected, mask.tolist())
s2 = SectorROI((0, 0), (1, 2),
(-5 * pi / 2, -3 * pi / 2)) #the same sector
mask = s.mask_points(p)
self.assertEquals(expected, mask.tolist())
self.assertEqual(points_cp, [axis.tolist() for axis in p])
def test_apply_excluders_with_scaling(self):
g1_pos = np.array([1, 2, 3])
g2_pos = np.array([-1, -2])
mask_func = lambda px, py: np.full(len(px), 1, dtype=np.int8)
g1 = Mock(axes=["g1"], positions={"g1":g1_pos}, size=len(g1_pos))
g2 = Mock(axes=["g2"], positions={"g2":g2_pos}, size=len(g2_pos))
e = Mock(axes=["g1", "g2"], create_mask=Mock(side_effect=mask_func))
d = Dimension(g1)
d.alternate = True
d.generators = [Mock(size=5, axes=[]), g1, g2, Mock(size=7, axes=[])]
d.size = 5 * len(g1_pos) * len(g2_pos) * 7
d.apply_excluder(e)
d._masks[0]["mask"] = d._masks[0]["mask"].tolist()
expected_mask = [1] * 12
self.assertEqual([{"repeat":7, "tile":2.5, "mask":expected_mask}], d._masks)
self.assertTrue((np.repeat(np.append(g1_pos, g1_pos[::-1]), 2) == e.create_mask.call_args[0][0]).all())
self.assertTrue((np.tile(np.append(g2_pos, g2_pos[::-1]), 3) == e.create_mask.call_args[0][1]).all())
def test_excluder_over_spread_axes(self):
gw_pos = np.array([0.1, 0.2])
gw_bounds = np.array([0.05, 0.15, 0.25])
gx_pos = np.array([0, 1, 2, 3])
gy_pos = np.array([10, 11, 12, 13])
gz_pos = np.array([100, 101, 102, 103])
go_pos = np.array([1000, 1001, 1002])
mask_xz_func = lambda px, pz: (px - 1)**2 + (pz - 102)**2 <= 1
exz = Mock(axes=["gx", "gz"],
create_mask=Mock(side_effect=mask_xz_func))
gw = Mock(axes=["gw"],
positions={"gw": gw_pos},
bounds={"gw": gw_bounds},
size=2,
alternate=False)
gx = Mock(axes=["gx"],
positions={"gx": gx_pos},
size=4,
alternate=False)
gy = Mock(axes=["gy"],
positions={"gy": gy_pos},
size=4,
alternate=False)
gz = Mock(axes=["gz"],
positions={"gz": gz_pos},
size=4,
alternate=False)
go = Mock(axes=["go"],
positions={"go": go_pos},
size=3,
alternate=False)
d = Dimension([go, gz, gy, gx, gw], [exz])
d.prepare()
x_positions = np.tile(np.array([0, 1, 2, 3]), 16)
y_positions = np.repeat(np.tile(np.array([10, 11, 12, 13]), 4), 4)
z_positions = np.repeat(np.array([100, 101, 102, 103]), 16)
x_positions = np.tile(np.repeat(x_positions, gw.size), go.size)
y_positions = np.tile(np.repeat(y_positions, gw.size), go.size)
z_positions = np.tile(np.repeat(z_positions, gw.size), go.size)
mask = mask_xz_func(x_positions, z_positions)
expected_x = x_positions[mask].tolist()
expected_y = y_positions[mask].tolist()
expected_z = z_positions[mask].tolist()
self.assertEqual(expected_x, d.get_positions("gx").tolist())
self.assertEqual(expected_y, d.get_positions("gy").tolist())
self.assertEqual(expected_z, d.get_positions("gz").tolist())