Esempio n. 1
0
    def exec_general(self, data_1, data_2, fill_value=None):
        tabor_segments = [
            TaborSegment(d1, d2, None, None) for d1, d2 in zip(data_1, data_2)
        ]
        expected_length = (sum(segment.num_points
                               for segment in tabor_segments) + 16 *
                           (len(tabor_segments) - 1)) * 2

        offset = 0
        pyte_result = 15000 * np.ones(expected_length, dtype=np.uint16)
        for i, segment in enumerate(tabor_segments):
            offset = pytabor.make_combined_wave(segment.ch_a,
                                                segment.ch_b,
                                                dest_array=pyte_result,
                                                dest_array_offset=offset,
                                                add_idle_pts=i > 0)
        self.assertEqual(expected_length, offset)

        result = make_combined_wave(tabor_segments, fill_value=15000)
        np.testing.assert_equal(pyte_result, result)

        dest_array = 15000 * np.ones(expected_length, dtype=np.uint16)
        result = make_combined_wave(tabor_segments,
                                    destination_array=dest_array)
        np.testing.assert_equal(pyte_result, result)
        # test that the destination array data is not copied
        self.assertEqual(dest_array.__array_interface__['data'],
                         result.__array_interface__['data'])

        with self.assertRaises(ValueError):
            make_combined_wave(tabor_segments, destination_array=np.ones(16))
Esempio n. 2
0
    def exec_general(self, data_1, data_2, fill_value=None):
        tabor_segments = [
            TaborSegment(d1, d2, None, None) for d1, d2 in zip(data_1, data_2)
        ]
        expected_length = (sum(segment.num_points
                               for segment in tabor_segments) + 16 *
                           (len(tabor_segments) - 1)) * 2

        result = make_combined_wave(tabor_segments, fill_value=fill_value)
        self.assertEqual(len(result), expected_length)

        validate_result(tabor_segments, result, fill_value=fill_value)

        destination_array = np.empty(expected_length, dtype=np.uint16)
        result = make_combined_wave(tabor_segments,
                                    fill_value=fill_value,
                                    destination_array=destination_array)
        validate_result(tabor_segments, result, fill_value=fill_value)
        self.assertEqual(destination_array.__array_interface__['data'],
                         result.__array_interface__['data'], 'Data was copied')
Esempio n. 3
0
    def test_invalid_segment_length(self):
        gen = itertools.count()
        data_1 = [
            np.fromiter(gen, count=32, dtype=np.uint16),
            np.fromiter(gen, count=15, dtype=np.uint16),
            np.fromiter(gen, count=192, dtype=np.uint16)
        ]

        data_2 = [
            np.fromiter(gen, count=32, dtype=np.uint16),
            np.fromiter(gen, count=16, dtype=np.uint16),
            np.fromiter(gen, count=193, dtype=np.uint16)
        ]

        tabor_segments = [TaborSegment(d, d, None, None) for d in data_1]
        with self.assertRaises(ValueError):
            make_combined_wave(tabor_segments)

        tabor_segments = [TaborSegment(d, d, None, None) for d in data_2]
        with self.assertRaises(ValueError):
            make_combined_wave(tabor_segments)
Esempio n. 4
0
    def test_empty_segment_list(self):
        combined = make_combined_wave([])

        self.assertIsInstance(combined, np.ndarray)
        self.assertIs(combined.dtype, np.dtype('uint16'))
        self.assertEqual(len(combined), 0)