def test_mutate_simple(self): def point_gen(): for n in range_(10): p = Point() p.indexes = [n] p.positions = {"x": n / 10.} p.lower = {"x": (n - 0.5) / 10.} p.upper = {"x": (n + 0.5) / 10.} yield p m = RandomOffsetMutator(1, ["x"], [0.01]) original = [p for p in point_gen()] mutated = [m.mutate(p, i) for i, p in enumerate(point_gen())] for o, m in zip(original, mutated): op, mp = o.positions["x"], m.positions["x"] ou, mu = o.upper["x"], m.upper["x"] ol, ml = o.lower["x"], m.lower["x"] self.assertNotEqual(op, mp) self.assertTrue(abs(mp - op) < 0.01) self.assertTrue(abs(mu - ou) < 0.01) self.assertTrue(abs(ml - ol) < 0.01) offsets = [ m.positions["x"] - o.positions["x"] for m, o in zip(mutated, original) ] for o1, o2 in zip(offsets[:-1], offsets[1:]): self.assertNotEqual(o1, o2)
def test_random_access_consistency(self): def point_gen(): for n in range_(10): p = Point() p.indexes = [n] p.positions = {"x": n / 10.} p.lower = {"x": (n - 0.5) / 10.} p.upper = {"x": (n + 0.5) / 10.} yield p m = RandomOffsetMutator(5025, ["x"], [0.01]) original = [p.positions['x'] for p in point_gen()] mutated1 = [ m.mutate(p, i).positions['x'] for i, p in enumerate(point_gen()) ] mutated2 = [ m.mutate(p, i).positions['x'] for i, p in enumerate(point_gen()) ] mutated3 = [ m.mutate(p, i).positions['x'] for i, p in list(enumerate(point_gen()))[::-1] ][::-1] self.assertNotEqual(original, mutated1) self.assertEqual(mutated1, mutated2) self.assertEqual(mutated1, mutated3)
def test_from_dict(self): g1 = LineGenerator("x1", "mm", -1.0, 1.0, 5, False) g1_dict = g1.to_dict() g2 = LineGenerator("y1", "mm", -1.0, 1.0, 5, False) g2_dict = g2.to_dict() r = CircularROI([0, 0], 1) excl_1 = ROIExcluder([r], ["x1", "y1"]) excl1_1_dict = excl_1.to_dict() mutator_1 = RandomOffsetMutator(0, ["x"], {"x": 1}) mutator_1_dict = mutator_1.to_dict() _dict = dict() _dict['generators'] = [g1_dict, g2_dict] _dict['excluders'] = [excl1_1_dict] _dict['mutators'] = [mutator_1_dict] _dict['duration'] = 12 _dict['continuous'] = False units_dict = dict() units_dict['x'] = 'mm' units_dict['y'] = 'mm' gen = CompoundGenerator.from_dict(_dict) self.assertEqual(gen.generators[0].to_dict(), g1.to_dict()) self.assertEqual(gen.generators[1].to_dict(), g2.to_dict()) self.assertEqual(gen.mutators[0].to_dict(), mutator_1.to_dict()) self.assertEqual(gen.excluders[0].to_dict(), excl_1.to_dict()) self.assertEqual(gen.duration, 12) self.assertEqual(gen.continuous, False)
def test_consistent_python_jython(self): p = Point() p.indexes = [0] p.positions = {"x": 1, "y": 2} p.lower = {"x": 0.5, "y": 1.75} p.upper = {"x": 1.5, "y": 2.25} m = RandomOffsetMutator(1, ["y"], [0.01]) q = m.mutate(p, 0) # Generated with Python 3.7.3, but should be consistent with all Python/Jython self.assertAlmostEqual(2.00454337, q.positions["y"]) self.assertAlmostEqual(2.25045721, q.upper["y"]) self.assertAlmostEqual(1.74735178, q.lower["y"])
def test_bounds_consistency(self): def point_gen(): for n in range_(10): p = Point() p.indexes = [n] p.positions = {"x": n / 10.} p.lower = {"x": (n - 0.5) / 10.} p.upper = {"x": (n + 0.5) / 10.} yield p m = RandomOffsetMutator(1, ["x"], [0.01]) original = [p.positions["x"] for p in point_gen()] mutated = [m.mutate(p, i) for i, p in enumerate(point_gen())] for m1, m2 in zip(mutated[:-1], mutated[1:]): self.assertEqual(m1.upper["x"], m2.lower["x"])
def test_mutators(self): mutator_1 = MagicMock() mutator_1.mutate = MagicMock(side_effect=lambda x, n: x) mutator_2 = RandomOffsetMutator(0, ["x"], {"x": 1}) mutator_2.calc_offset = MagicMock(return_value=0.1) x = LineGenerator('x', 'mm', 1, 5, 5) g = CompoundGenerator([x], [], [mutator_1, mutator_2], 0.2) g.prepare() x_pos = 1 n = 0 for p in g.iterator(): self.assertEqual(0.2, p.duration) self.assertEqual({"x": x_pos + 0.1}, p.positions) mutator_1.mutate.assert_called_once_with(p, n) mutator_1.mutate.reset_mock() n += 1 x_pos += 1 self.assertEqual(6, x_pos)
def test_double_line_consistency(self): xg = LineGenerator("x", "mm", 0, 4, 5, True) yg = LineGenerator("y", "mm", 0, 4, 3) m = RandomOffsetMutator(1, ["x", "y"], [0.1, 0.25]) g = CompoundGenerator([yg, xg], [], []) g.prepare() points = list(g.iterator()) ly = [l.upper["y"] for l in points[0:4] + points[5:9] + points[10:14]] ry = [r.lower["y"] for r in points[1:5] + points[6:10] + points[11:15]] self.assertEqual(ly, ry)
def test_from_dict_max_offset_dict(self): _dict = dict() _dict['seed'] = 1 _dict['axes'] = ["x"] _dict['max_offset'] = dict(x=0.25) units_dict = dict() units_dict['x'] = 'mm' m = RandomOffsetMutator.from_dict(_dict) self.assertEqual(1, m.seed) self.assertEqual(self.max_offset, m.max_offset)
def test_from_dict_multiple_axes_dict_corrects_order(self): _dict = dict() _dict['seed'] = 1 _dict['axes'] = ["x", "y"] _dict['max_offset'] = dict(y=0.5, x=0.25) units_dict = dict() units_dict['x'] = 'mm' units_dict['y'] = 'cm' m = RandomOffsetMutator.from_dict(_dict) self.assertEqual(1, m.seed) self.assertEqual(["x", "y"], m.axes) self.assertEqual([0.25, 0.5], m.max_offset)
def test_bounds_consistency_in_compound(self): liss = LissajousGenerator(["x", "y"], ["mm", "mm"], [0., 0.], [2., 2.], 4, 100, True) line = LineGenerator("z", "mm", 0, 1, 3) m = RandomOffsetMutator(1, ["x", "y"], [0.1, 0.1]) g = CompoundGenerator([line, liss], [], []) gm = CompoundGenerator([line, liss], [], [m]) g.prepare() gm.prepare() points = list(gm.iterator()) lx = [l.upper["x"] for l in points[:-1]] rx = [r.lower["x"] for r in points[1:]] self.assertListAlmostEqual(lx, rx) ly = [l.upper["y"] for l in points[:-1]] ry = [r.lower["y"] for r in points[1:]] self.assertListAlmostEqual(ly, ry)
def test_200_million_time_constraint(self): start_time = time.time() s = SpiralGenerator( ["x", "y"], "mm", [0, 0], 6, 0.02, True) # ~2e5 points z = LineGenerator("z", "mm", 0, 1, ZSIZE, True) #1e2 points or 1e1 for Jython w = LineGenerator("w", "mm", 0, 1, 10, True) #1e1 points r1 = CircularROI([-0.7, 4], 0.5) r2 = CircularROI([0.5, 0.5], 0.3) r3 = CircularROI([0.2, 4], 0.5) e1 = ROIExcluder([r1], ["x", "y"]) e2 = ROIExcluder([r2], ["w", "z"]) e3 = ROIExcluder([r3], ["z", "y"]) om = RandomOffsetMutator(0, ["x", "y"], {"x":0.2, "y":0.2}) g = CompoundGenerator([w, z, s], [e1, e3, e2], [om]) g.prepare() # g.size ~3e5 end_time = time.time() # if this test becomes problematic then we'll just have to remove it self.assertLess(end_time - start_time, TIMELIMIT)
class TestSerialisation(unittest.TestCase): def setUp(self): self.l = MagicMock() self.l_dict = MagicMock() self.max_offset = dict(x=0.25) self.m = RandomOffsetMutator(1, ["x"], self.max_offset) def test_to_dict(self): self.l.to_dict.return_value = self.l_dict expected_dict = dict() expected_dict[ 'typeid'] = "scanpointgenerator:mutator/RandomOffsetMutator:1.0" expected_dict['seed'] = 1 expected_dict['axes'] = ["x"] expected_dict['max_offset'] = self.max_offset d = self.m.to_dict() self.assertEqual(expected_dict, d) def test_from_dict(self): _dict = dict() _dict['seed'] = 1 _dict['axes'] = ["x"] _dict['max_offset'] = self.max_offset units_dict = dict() units_dict['x'] = 'mm' m = RandomOffsetMutator.from_dict(_dict) self.assertEqual(1, m.seed) self.assertEqual(self.max_offset, m.max_offset)
def test_init(self): m = RandomOffsetMutator(1, ["x"], [0.25]) self.assertEqual(1, m.seed) self.assertEqual([0.25], m.max_offset)
def setUp(self): self.l = MagicMock() self.l_dict = MagicMock() self.max_offset = [0.25] self.m = RandomOffsetMutator(1, ["x"], self.max_offset)
class TestSerialisation(unittest.TestCase): def setUp(self): self.l = MagicMock() self.l_dict = MagicMock() self.max_offset = [0.25] self.m = RandomOffsetMutator(1, ["x"], self.max_offset) def test_to_dict(self): self.l.to_dict.return_value = self.l_dict expected_dict = dict() expected_dict[ 'typeid'] = "scanpointgenerator:mutator/RandomOffsetMutator:1.0" expected_dict['seed'] = 1 expected_dict['axes'] = ["x"] expected_dict['max_offset'] = self.max_offset d = self.m.to_dict() self.assertEqual(expected_dict, d) def test_from_dict(self): _dict = dict() _dict['seed'] = 1 _dict['axes'] = ["x"] _dict['max_offset'] = self.max_offset units_dict = dict() units_dict['x'] = 'mm' m = RandomOffsetMutator.from_dict(_dict) self.assertEqual(1, m.seed) self.assertEqual(self.max_offset, m.max_offset) def test_from_dict_max_offset_dict(self): _dict = dict() _dict['seed'] = 1 _dict['axes'] = ["x"] _dict['max_offset'] = dict(x=0.25) units_dict = dict() units_dict['x'] = 'mm' m = RandomOffsetMutator.from_dict(_dict) self.assertEqual(1, m.seed) self.assertEqual(self.max_offset, m.max_offset) def test_from_dict_multiple_axes(self): _dict = dict() _dict['seed'] = 1 _dict['axes'] = ["x", "y"] _dict['max_offset'] = [0.25, 0.5] units_dict = dict() units_dict['x'] = 'mm' units_dict['y'] = 'cm' m = RandomOffsetMutator.from_dict(_dict) self.assertEqual(1, m.seed) self.assertEqual(["x", "y"], m.axes) self.assertEqual([0.25, 0.5], m.max_offset) def test_from_dict_multiple_axes_dict_corrects_order(self): _dict = dict() _dict['seed'] = 1 _dict['axes'] = ["x", "y"] _dict['max_offset'] = dict(y=0.5, x=0.25) units_dict = dict() units_dict['x'] = 'mm' units_dict['y'] = 'cm' m = RandomOffsetMutator.from_dict(_dict) self.assertEqual(1, m.seed) self.assertEqual(["x", "y"], m.axes) self.assertEqual([0.25, 0.5], m.max_offset)
def test_init(self): m = RandomOffsetMutator(1, ["x"], dict(x=0.25)) self.assertEqual(1, m.seed) self.assertEqual(dict(x=0.25), m.max_offset)