def test_ccc_get0(self):
random.seed(0)
for i in xrange(25):
ntaps = int(random.uniform(2, 100))
taps = make_random_complex_tuple(ntaps)
op = filter.fft_filter_ccc(1, taps)
result_data = op.taps
#print result_data
self.assertComplexTuplesAlmostEqual(taps, result_data, 4)
def test_ccc_get0(self):
random.seed(0)
for i in xrange(25):
ntaps = int(random.uniform(2, 100))
taps = make_random_complex_tuple(ntaps)
op = filter.fft_filter_ccc(1, taps)
result_data = op.taps
#print result_data
self.assertComplexTuplesAlmostEqual(taps, result_data, 4)
def test_ccc_001(self):
tb = gr.top_block()
src_data = (0, 1, 2, 3, 4, 5, 6, 7)
taps = (complex(1), )
expected_result = tuple([complex(x) for x in (0, 1, 2, 3, 4, 5, 6, 7)])
src = gr.vector_source_c(src_data)
op = filter.fft_filter_ccc(1, taps)
dst = gr.vector_sink_c()
tb.connect(src, op, dst)
tb.run()
result_data = dst.data()
#print 'expected:', expected_result
#print 'results: ', result_data
self.assertComplexTuplesAlmostEqual(expected_result, result_data, 5)
def test_ccc_001(self):
tb = gr.top_block()
src_data = (0,1,2,3,4,5,6,7)
taps = (complex(1),)
expected_result = tuple([complex(x) for x in (0,1,2,3,4,5,6,7)])
src = gr.vector_source_c(src_data)
op = filter.fft_filter_ccc(1, taps)
dst = gr.vector_sink_c()
tb.connect(src, op, dst)
tb.run()
result_data = dst.data()
#print 'expected:', expected_result
#print 'results: ', result_data
self.assertComplexTuplesAlmostEqual (expected_result, result_data, 5)
def __init__(self, mpoints, taps=None):
"""
Takes 1 complex stream in, produces M complex streams out
that runs at 1/M times the input sample rate
Args:
mpoints: number of freq bins/interpolation factor/subbands
taps: filter taps for subband filter
Same channel to frequency mapping as described above.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(
self,
"analysis_filterbank",
gr.io_signature(1, 1, item_size), # Input signature
gr.io_signature(mpoints, mpoints, item_size)) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0, )
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
# print >> sys.stderr, "mpoints =", mpoints, "len(sub_taps) =", len(sub_taps)
self.s2ss = blocks.stream_to_streams(item_size, mpoints)
# filters here
self.ss2v = blocks.streams_to_vector(item_size, mpoints)
self.fft = fft.fft_vcc(mpoints, True, [])
self.v2ss = blocks.vector_to_streams(item_size, mpoints)
self.connect(self, self.s2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = fft_filter_ccc(1, sub_taps[mpoints - i - 1])
self.connect((self.s2ss, i), f)
self.connect(f, (self.ss2v, i))
self.connect((self.v2ss, i), (self, i))
self.connect(self.ss2v, self.fft, self.v2ss)
def __init__(self, mpoints, taps=None):
"""
Takes 1 complex stream in, produces M complex streams out
that runs at 1/M times the input sample rate
Args:
mpoints: number of freq bins/interpolation factor/subbands
taps: filter taps for subband filter
Same channel to frequency mapping as described above.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(self, "analysis_filterbank",
gr.io_signature(1, 1, item_size), # Input signature
gr.io_signature(mpoints, mpoints, item_size)) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0,)
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
# print >> sys.stderr, "mpoints =", mpoints, "len(sub_taps) =", len(sub_taps)
self.s2ss = blocks.stream_to_streams(item_size, mpoints)
# filters here
self.ss2v = blocks.streams_to_vector(item_size, mpoints)
self.fft = fft.fft_vcc(mpoints, True, [])
self.v2ss = blocks.vector_to_streams(item_size, mpoints)
self.connect(self, self.s2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = fft_filter_ccc(1, sub_taps[mpoints-i-1])
self.connect((self.s2ss, i), f)
self.connect(f, (self.ss2v, i))
self.connect((self.v2ss, i), (self, i))
self.connect(self.ss2v, self.fft, self.v2ss)
def test_ccc_004(self):
random.seed(0)
for i in xrange(25):
# sys.stderr.write("\n>>> Loop = %d\n" % (i,))
src_len = 4 * 1024
src_data = make_random_complex_tuple(src_len)
ntaps = int(random.uniform(2, 1000))
taps = make_random_complex_tuple(ntaps)
expected_result = reference_filter_ccc(1, taps, src_data)
src = gr.vector_source_c(src_data)
op = filter.fft_filter_ccc(1, taps)
dst = gr.vector_sink_c()
tb = gr.top_block()
tb.connect(src, op, dst)
tb.run()
result_data = dst.data()
del tb
self.assert_fft_ok2(expected_result, result_data)
def test_ccc_004(self):
random.seed(0)
for i in xrange(25):
# sys.stderr.write("\n>>> Loop = %d\n" % (i,))
src_len = 4*1024
src_data = make_random_complex_tuple(src_len)
ntaps = int(random.uniform(2, 1000))
taps = make_random_complex_tuple(ntaps)
expected_result = reference_filter_ccc(1, taps, src_data)
src = gr.vector_source_c(src_data)
op = filter.fft_filter_ccc(1, taps)
dst = gr.vector_sink_c()
tb = gr.top_block()
tb.connect(src, op, dst)
tb.run()
result_data = dst.data()
del tb
self.assert_fft_ok2(expected_result, result_data)
def __init__(self, decim, taps, center_freq, samp_rate):
gr.hier_block2.__init__(
self,
"freq_xlating_fft_filter_ccc",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_gr_complex),
)
# Save args
self.decim = decim
self.taps = taps
self.center_freq = center_freq
self.samp_rate = samp_rate
# Sub blocks
self._filter = fft_filter_ccc(decim, taps)
self._rotator = rotator_cc(0.0)
self.connect(self, self._filter, self._rotator, self)
# Refresh
self._refresh()
def __init__(self, decim, taps, center_freq, samp_rate):
gr.hier_block2.__init__(
self,
'freq_xlating_fft_filter_ccc',
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_gr_complex),
)
# Save args
self.decim = decim
self.taps = taps
self.center_freq = center_freq
self.samp_rate = samp_rate
# Sub blocks
self._filter = fft_filter_ccc(decim, taps)
self._rotator = rotator_cc(0.0)
self.connect(self, self._filter, self._rotator, self)
# Refresh
self._refresh()
def __init__(self, mpoints, taps=None):
"""
Takes M complex streams in, produces single complex stream out
that runs at M times the input sample rate
Args:
mpoints: number of freq bins/interpolation factor/subbands
taps: filter taps for subband filter
The channel spacing is equal to the input sample rate.
The total bandwidth and output sample rate are equal the input
sample rate * nchannels.
Output stream to frequency mapping:
channel zero is at zero frequency.
if mpoints is odd:
Channels with increasing positive frequencies come from
channels 1 through (N-1)/2.
Channel (N+1)/2 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
if mpoints is even:
Channels with increasing positive frequencies come from
channels 1 through (N/2)-1.
Channel (N/2) is evenly split between the max positive and
negative bins.
Channel (N/2)+1 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
Channels near the frequency extremes end up getting cut
off by subsequent filters and therefore have diminished
utility.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(self, "synthesis_filterbank",
gr.io_signature(mpoints, mpoints, item_size), # Input signature
gr.io_signature(1, 1, item_size)) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0,)
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
self.ss2v = blocks.streams_to_vector(item_size, mpoints)
self.ifft = fft.fft_vcc(mpoints, False, [])
self.v2ss = blocks.vector_to_streams(item_size, mpoints)
# mpoints filters go in here...
self.ss2s = blocks.streams_to_stream(item_size, mpoints)
for i in range(mpoints):
self.connect((self, i), (self.ss2v, i))
self.connect(self.ss2v, self.ifft, self.v2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = fft_filter_ccc(1, sub_taps[i])
self.connect((self.v2ss, i), f)
self.connect(f, (self.ss2s, i))
self.connect(self.ss2s, self)
def __init__(self, mpoints, taps=None):
"""
Takes M complex streams in, produces single complex stream out
that runs at M times the input sample rate
Args:
mpoints: number of freq bins/interpolation factor/subbands
taps: filter taps for subband filter
The channel spacing is equal to the input sample rate.
The total bandwidth and output sample rate are equal the input
sample rate * nchannels.
Output stream to frequency mapping:
channel zero is at zero frequency.
if mpoints is odd:
Channels with increasing positive frequencies come from
channels 1 through (N-1)/2.
Channel (N+1)/2 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
if mpoints is even:
Channels with increasing positive frequencies come from
channels 1 through (N/2)-1.
Channel (N/2) is evenly split between the max positive and
negative bins.
Channel (N/2)+1 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
Channels near the frequency extremes end up getting cut
off by subsequent filters and therefore have diminished
utility.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(
self,
"synthesis_filterbank",
gr.io_signature(mpoints, mpoints, item_size), # Input signature
gr.io_signature(1, 1, item_size)) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0, )
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
self.ss2v = blocks.streams_to_vector(item_size, mpoints)
self.ifft = fft.fft_vcc(mpoints, False, [])
self.v2ss = blocks.vector_to_streams(item_size, mpoints)
# mpoints filters go in here...
self.ss2s = blocks.streams_to_stream(item_size, mpoints)
for i in range(mpoints):
self.connect((self, i), (self.ss2v, i))
self.connect(self.ss2v, self.ifft, self.v2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = fft_filter_ccc(1, sub_taps[i])
self.connect((self.v2ss, i), f)
self.connect(f, (self.ss2s, i))
self.connect(self.ss2s, self)
