[Commit-gnuradio] r8806 - gnuradio/branches/developers/jblum/gr-wxglgui/src/python

[jcorgan]

Author: jcorgan
Date: 2008-07-05 15:40:37 -0600 (Sat, 05 Jul 2008)
New Revision: 8806

Modified:
   gnuradio/branches/developers/jblum/gr-wxglgui/src/python/common.py
Log:
Remove code ported to blks2

Modified: gnuradio/branches/developers/jblum/gr-wxglgui/src/python/common.py
===================================================================
--- gnuradio/branches/developers/jblum/gr-wxglgui/src/python/common.py  
2008-07-05 21:25:34 UTC (rev 8805)
+++ gnuradio/branches/developers/jblum/gr-wxglgui/src/python/common.py  
2008-07-05 21:40:37 UTC (rev 8806)
@@ -19,138 +19,12 @@
 # Boston, MA 02110-1301, USA.
 #
 
-from gnuradio import gr, window
 import threading
 import numpy
 import math
 import wx
 
 ##################################################
-# Stream decimator chain
-##################################################
-class stream_decimator(gr.hier_block2):
-       """!
-       Convert the stream to a vector, decimate the vector to achieve the 
vector rate.
-       """
-
-       def __init__(self, item_size, sample_rate, vec_rate, vec_len):
-               """!
-               Create the block chain.
-               @param item_size the number of bytes per sample
-               @param sample_rate the rate of incoming samples
-               @param vec_rate the rate of outgoing vectors
-               @param vec_len the length of the outgoing vectors
-               """
-               self.vec_rate = vec_rate
-               self.vec_len = vec_len
-               #init
-               gr.hier_block2.__init__(
-                       self,
-                       "stream_decimator_block",
-                       gr.io_signature(1, 1, item_size),
-                       gr.io_signature(1, 1, item_size*vec_len),
-               )
-               #create blocks
-               s2v = gr.stream_to_vector(item_size, vec_len)
-               self.one_in_n = gr.keep_one_in_n(item_size * vec_len, 1)
-               #connect
-               self.connect(self, s2v, self.one_in_n, self)
-               #initial update
-               self.set_sample_rate(sample_rate)
-
-       def set_sample_rate(self, sample_rate):
-               """!
-               Set the new sampling rate and update the decimator.
-               @param sample_rate the new rate
-               """
-               self.sample_rate = sample_rate
-               self.one_in_n.set_n(max(1, 
int(self.sample_rate/self.vec_len/self.vec_rate)))
-
-##################################################
-# FFT block chain
-##################################################
-class _fft_chain_base(gr.hier_block2):
-       """!
-       Create an fft block chain, with real/complex input.
-       The fft stream is written to a message sink.
-       This block provides a callback to set the average on/off.
-       """
-
-       def __init__(self, sample_rate, fft_size, frame_rate, ref_scale, 
avg_alpha, average):
-               """!
-               Create an fft block.
-               Provide access to the setting the filter and sample rate.
-               @param sample_rate, fft_size, frame_rate, ref_scale, avg_alpha, 
average the fft parameters
-               """
-               #init
-               gr.hier_block2.__init__(
-                       self,
-                       "fft_block",
-                       gr.io_signature(1, 1, self.item_size),
-                       gr.io_signature(1, 1, gr.sizeof_float*fft_size),
-               )
-               #create blocks
-               self.sd = stream_decimator(
-                       item_size=self.item_size,
-                       sample_rate=sample_rate,
-                       vec_rate=frame_rate,
-                       vec_len=fft_size,
-               )
-               #create fft
-               fft_window = window.blackmanharris(fft_size)
-               fft = self.fft_block[0](fft_size, True, fft_window)
-               power = sum(map(lambda x: x*x, fft_window))
-               #filter fft, convert to dB
-               c2mag = gr.complex_to_mag(fft_size)
-               self.avg = gr.single_pole_iir_filter_ff(1.0, fft_size)
-               log = gr.nlog10_ff(
-                       20,
-                       fft_size,
-                       -10*math.log10(fft_size) # Adjust for number of bins
-                       -10*math.log10(power/fft_size) # Adjust for windowing 
loss
-                       -20*math.log10(ref_scale/2) # Adjust for reference scale
-               )
-               #connect
-               self.connect(self, self.sd, fft, c2mag, self.avg, log, self)
-               #register
-               self.set_sample_rate = self.sd.set_sample_rate
-               #initial update
-               self.set_average(average)
-               self.set_avg_alpha(avg_alpha)
-
-       def set_sample_rate(self, sample_rate):
-               """!
-               Set the new sampling rate and update the decimator.
-               @param sample_rate the new rate
-               """
-               self.sample_rate = sample_rate
-               self.one_in_n.set_n(max(1, 
int(self.sample_rate/self.fft_size/self.frame_rate)))
-
-       def set_average(self, average):
-               """!
-               Set the averaging filter on/off.
-               @param average true to set averaging on
-               """
-               self.average = average
-               if self.average: self.avg.set_taps(self.avg_alpha)
-               else: self.avg.set_taps(1.0)
-
-       def set_avg_alpha(self, avg_alpha):
-               """!
-               Set the average alpha and set the taps if average was on.
-               @param avg_alpha the new iir filter tap
-               """
-               self.avg_alpha = avg_alpha
-               self.set_average(self.average)
-
-class fft_chain_f(_fft_chain_base):
-       item_size = gr.sizeof_float
-       fft_block = (gr.fft_vfc, )
-class fft_chain_c(_fft_chain_base):
-       item_size = gr.sizeof_gr_complex
-       fft_block = (gr.fft_vcc, )
-
-##################################################
 # Input Watcher Thread
 ##################################################
 class input_watcher(threading.Thread):