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)
class TestSerialisation(unittest.TestCase):
    def setUp(self):
        self.r1 = MagicMock()
        self.r1_dict = MagicMock()
        self.r2 = MagicMock()
        self.r2_dict = MagicMock()
        self.r1.to_dict.return_value = self.r1_dict
        self.r2.to_dict.return_value = self.r2_dict

        self.e = ROIExcluder([self.r1, self.r2], ["x", "y"])

    def test_to_dict(self):
        expected_dict = dict()
        expected_dict['typeid'] = "scanpointgenerator:excluder/ROIExcluder:1.0"
        expected_dict['rois'] = [self.r1_dict, self.r2_dict]
        expected_dict['axes'] = ["x", "y"]

        d = self.e.to_dict()

        self.assertEqual(expected_dict, d)

    @patch(roi_patch_path + '.from_dict')
    def test_from_dict(self, from_dict_mock):
        from_dict_mock.side_effect = [self.r1, self.r2]
        _dict = dict()
        _dict['rois'] = [self.r1_dict, self.r2_dict]
        _dict['axes'] = ["x", "y"]

        e = ROIExcluder.from_dict(_dict)

        from_dict_mock.assert_has_calls(
            [call(self.r1_dict), call(self.r2_dict)])
        self.assertEqual(e.rois, [self.r1, self.r2])
        self.assertEqual(e.axes, ["x", "y"])
class TestSerialisation(unittest.TestCase):
    def setUp(self):
        self.r1 = CircularROI([1, 2], 3)
        self.r2 = CircularROI([4, 5], 6)

        self.r1_dict = self.r1.to_dict()
        self.r2_dict = self.r2.to_dict()

        self.e = ROIExcluder([self.r1, self.r2], ["x", "y"])

    def test_to_dict(self):
        expected_dict = dict()
        expected_dict['typeid'] = "scanpointgenerator:excluder/ROIExcluder:1.0"
        expected_dict['rois'] = [self.r1_dict, self.r2_dict]
        expected_dict['axes'] = ["x", "y"]

        d = self.e.to_dict()

        self.assertEqual(expected_dict, d)

    def test_from_dict(self):
        _dict = dict()

        _dict['rois'] = [self.r1_dict, self.r2_dict]
        _dict['axes'] = ["x", "y"]

        e = ROIExcluder.from_dict(_dict)

        self.assertEqual(["x", "y"], e.axes)
        self.assertEqual(2, len(e.rois))
        self.assertEqual("scanpointgenerator:roi/CircularROI:1.0",
                         e.rois[0].typeid)
        self.assertEqual([1, 2], e.rois[0].centre)
        self.assertEqual(3, e.rois[0].radius)
        self.assertEqual("scanpointgenerator:roi/CircularROI:1.0",
                         e.rois[1].typeid)
        self.assertEqual([4, 5], e.rois[1].centre)
        self.assertEqual(6, e.rois[1].radius)
Example #4
0
class JExcluder(object):

    def __init__(self, rois, scannables):
        py_rois = [roi.py_roi for roi in rois]
        self.py_excluder = ROIExcluder(py_rois, scannables)
        logging.debug(self.py_excluder.to_dict())