コード例 #1
0
    def test_reverse_window_shift(self):
        src_data = tuple([x / self.fft_size for x in primes_transformed])
        expected_result = (
            (-74.8629 - 63.2502j), (-3.5446 - 2.0365j), (2.9231 + 1.6827j),
            (-2.7852 - 0.8613j), (2.4763 + 2.7881j), (-2.7457 - 3.2602j),
            (4.7748 + 2.4145j), (-2.8807 - 4.5313j), (5.9949 + 4.1976j),
            (-6.1095 - 6.0681j), (5.2248 + 5.7743j), (-6.0436 - 6.3773j),
            (9.7184 + 9.2482j), (-8.2791 - 8.6507j), (6.3273 + 6.1560j),
            (-12.2841 - 12.4692j), (10.5816 + 10.0241j), (-13.0312 - 11.9451j),
            (12.2983 + 13.3644j), (-13.0372 - 14.0795j), (14.4682 + 13.3079j),
            (-16.7673 - 16.7287j), (14.3946 + 11.5916j), (-16.8368 - 21.3156j),
            (20.4528 + 16.8499j), (-18.4075 - 18.2446j), (17.7507 + 19.2109j),
            (-21.5207 - 20.7159j), (22.2183 + 19.8012j), (-22.2144 - 20.0343j),
            (17.0359 + 17.6910j), (-91.8955 - 103.1093j))
        window = fft.window_hamming(ntaps=self.fft_size)

        src = blocks.vector_source_c(src_data)
        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
        op = fft.fft_vcc(self.fft_size, False, window, True)
        v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.fft_size)
        dst = blocks.vector_sink_c()
        self.tb.connect(src, s2v, op, v2s, dst)
        self.tb.run()
        result_data = dst.data()
        self.assert_fft_ok2(expected_result, result_data)
コード例 #2
0
    def test_window(self):
        src_data = tuple([
            complex(primes[2 * i], primes[2 * i + 1])
            for i in range(self.fft_size)
        ])
        expected_result = (
            (2238.9174 + 2310.4750j), (-1603.7416 - 466.7420j),
            (116.7449 - 70.8553j), (-13.9157 + 19.0855j), (-4.8283 + 16.7025j),
            (-43.7425 + 16.9871j), (-16.1904 + 1.7494j), (-32.3797 + 6.9964j),
            (-13.5283 + 7.7721j), (-24.3276 - 7.5378j), (-29.2711 + 4.5709j),
            (-2.7124 - 6.6307j), (-33.5486 - 8.3485j), (-8.3016 - 9.9534j),
            (-18.8590 - 8.3501j), (-13.9092 - 1.1396j), (-17.7626 - 26.9281j),
            (0.0182 - 8.9000j), (-19.9143 - 14.1320j), (-10.3073 - 15.5759j),
            (3.5800 - 29.1835j), (-7.5263 - 1.5900j), (-3.0392 - 31.7445j),
            (-15.1355 - 33.6158j), (28.2345 - 11.4373j), (-6.0055 - 27.0418j),
            (5.2074 - 21.2431j), (23.1617 - 31.8610j), (13.6494 - 11.1982j),
            (14.7145 - 14.4113j), (-60.0053 + 114.7418j), (-440.1561 -
                                                           1632.9807j))
        window = fft.window_hamming(ntaps=self.fft_size)

        src = blocks.vector_source_c(src_data)
        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
        op = fft.fft_vcc(self.fft_size, True, window, False)
        v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.fft_size)
        dst = blocks.vector_sink_c()
        self.tb.connect(src, s2v, op, v2s, dst)
        self.tb.run()
        result_data = dst.data()
        self.assert_fft_ok2(expected_result, result_data)
コード例 #3
0
    def __init__(self, sample_rate, fft_size, ref_scale, frame_rate):
        gr.hier_block2.__init__(
            self, "logpowerfft_win", gr.io_signature(1, 1,
                                                     gr.sizeof_gr_complex),
            gr.io_signature(1, 1, gr.sizeof_float * fft_size))

        self._sd = blocks.stream_to_vector_decimator(
            item_size=gr.sizeof_gr_complex,
            sample_rate=sample_rate,
            vec_rate=frame_rate,
            vec_len=fft_size)

        fft_window = fft_lib.window_hamming(fft_size)
        fft = fft_lib.fft_vcc(fft_size, True, fft_window, True)
        window_power = sum([x * x for x in fft_window])

        c2magsq = blocks.complex_to_mag_squared(fft_size)
        self._avg = filter.single_pole_iir_filter_ff(1.0, fft_size)
        self._log = blocks.nlog10_ff(
            10,
            fft_size,
            -20 * math.log10(fft_size)  # Adjust for number of bins
            - 10 * math.log10(
                float(window_power) / fft_size)  # Adjust for windowing loss
            - 20 *
            math.log10(float(ref_scale) / 2))  # Adjust for reference scale
        self.connect(self, self._sd, fft, c2magsq, self._avg, self._log, self)
コード例 #4
0
ファイル: qa_fft.py プロジェクト: hofschroeer/gnuradio
    def test_windows(self):
        src_data = tuple([complex(primes[2 * i], primes[2 * i + 1]) for i in range(self.fft_size)])
        expected_result = ((2238.9174 + 2310.4750j),
                           (-1603.7416 - 466.7420j),
                           (116.7449 - 70.8553j),
                           (-13.9157 + 19.0855j),
                           (-4.8283 + 16.7025j),
                           (-43.7425 + 16.9871j),
                           (-16.1904 + 1.7494j),
                           (-32.3797 + 6.9964j),
                           (-13.5283 + 7.7721j),
                           (-24.3276 - 7.5378j),
                           (-29.2711 + 4.5709j),
                           (-2.7124 - 6.6307j),
                           (-33.5486 - 8.3485j),
                           (-8.3016 - 9.9534j),
                           (-18.8590 - 8.3501j),
                           (-13.9092 - 1.1396j),
                           (-17.7626 - 26.9281j),
                           (0.0182 - 8.9000j),
                           (-19.9143 - 14.1320j),
                           (-10.3073 - 15.5759j),
                           (3.5800 - 29.1835j),
                           (-7.5263 - 1.5900j),
                           (-3.0392 - 31.7445j),
                           (-15.1355 - 33.6158j),
                           (28.2345 - 11.4373j),
                           (-6.0055 - 27.0418j),
                           (5.2074 - 21.2431j),
                           (23.1617 - 31.8610j),
                           (13.6494 - 11.1982j),
                           (14.7145 - 14.4113j),
                           (-60.0053 + 114.7418j),
                           (-440.1561 - 1632.9807j))
        window = fft.window_hamming(ntaps=self.fft_size)

        src = blocks.vector_source_c(src_data)
        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
        op = fft.fft_vcc(self.fft_size, True, window, False)
        v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.fft_size)
        dst = blocks.vector_sink_c()
        self.tb.connect(src, s2v, op, v2s, dst)
        self.tb.run()
        result_data = dst.data()
        self.assert_fft_ok2(expected_result, result_data)
コード例 #5
0
ファイル: qa_fft.py プロジェクト: danbar/gnuradio
    def test_reverse_window_shift(self):
        src_data = tuple([x / self.fft_size for x in primes_transformed])
        expected_result = ((-74.8629 - 63.2502j),
                           (-3.5446 - 2.0365j),
                           (2.9231 + 1.6827j),
                           (-2.7852 - 0.8613j),
                           (2.4763 + 2.7881j),
                           (-2.7457 - 3.2602j),
                           (4.7748 + 2.4145j),
                           (-2.8807 - 4.5313j),
                           (5.9949 + 4.1976j),
                           (-6.1095 - 6.0681j),
                           (5.2248 + 5.7743j),
                           (-6.0436 - 6.3773j),
                           (9.7184 + 9.2482j),
                           (-8.2791 - 8.6507j),
                           (6.3273 + 6.1560j),
                           (-12.2841 - 12.4692j),
                           (10.5816 + 10.0241j),
                           (-13.0312 - 11.9451j),
                           (12.2983 + 13.3644j),
                           (-13.0372 - 14.0795j),
                           (14.4682 + 13.3079j),
                           (-16.7673 - 16.7287j),
                           (14.3946 + 11.5916j),
                           (-16.8368 - 21.3156j),
                           (20.4528 + 16.8499j),
                           (-18.4075 - 18.2446j),
                           (17.7507 + 19.2109j),
                           (-21.5207 - 20.7159j),
                           (22.2183 + 19.8012j),
                           (-22.2144 - 20.0343j),
                           (17.0359 + 17.6910j),
                           (-91.8955 - 103.1093j))
        window = fft.window_hamming(ntaps=self.fft_size)

        src = blocks.vector_source_c(src_data)
        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
        op = fft.fft_vcc(self.fft_size, False, window, True)
        v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.fft_size)
        dst = blocks.vector_sink_c()
        self.tb.connect(src, s2v, op, v2s, dst)
        self.tb.run()
        result_data = dst.data()
        self.assert_fft_ok2(expected_result, result_data)