def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- Matplotlib widget with NavigationToolbar
- Frame with control elements
"""
self.cmbUnitsPhi = QComboBox(self)
units = ["rad", "rad/pi", "deg"]
scales = [1., 1. / np.pi, 180. / np.pi]
for unit, scale in zip(units, scales):
self.cmbUnitsPhi.addItem(unit, scale)
self.cmbUnitsPhi.setObjectName("cmbUnitsA")
self.cmbUnitsPhi.setToolTip("Set unit for phase.")
self.cmbUnitsPhi.setCurrentIndex(0)
self.cmbUnitsPhi.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.chkWrap = QCheckBox("Wrapped Phase", self)
self.chkWrap.setChecked(False)
self.chkWrap.setToolTip("Plot phase wrapped to +/- pi")
layHControls = QHBoxLayout()
layHControls.addWidget(self.cmbUnitsPhi)
layHControls.addWidget(self.chkWrap)
layHControls.addStretch(10)
#----------------------------------------------------------------------
# ### frmControls ###
#
# This widget encompasses all control subwidgets
#----------------------------------------------------------------------
self.frmControls = QFrame(self)
self.frmControls.setObjectName("frmControls")
self.frmControls.setLayout(layHControls)
#----------------------------------------------------------------------
# ### mplwidget ###
#
# main widget, encompassing the other widgets
#----------------------------------------------------------------------
self.mplwidget = MplWidget(self)
self.mplwidget.layVMainMpl.addWidget(self.frmControls)
self.mplwidget.layVMainMpl.setContentsMargins(*params['wdg_margins'])
self.setLayout(self.mplwidget.layVMainMpl)
self.init_axes()
self.draw() # initial drawing
#----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.chkWrap.clicked.connect(self.draw)
self.cmbUnitsPhi.currentIndexChanged.connect(self.unit_changed)
self.mplwidget.mplToolbar.sig_tx.connect(self.process_sig_rx)
def _construct_UI(self):
# =====================================================================
# Controls
# =====================================================================
self.butLoad = PushButton(self,
icon=QIcon(':/file.svg'),
checkable=False)
# self.butLoad.setIconSize(q_icon_size)
self.butLoad.setToolTip("Load data from file.")
self.butLoad.setEnabled(False)
self.lbl_info = QLabel(to_html(" coming soon ...", frmt="b"))
# ----------------------------------------------------------------------
# Main Widget
# ----------------------------------------------------------------------
layH_io_par = QHBoxLayout()
layH_io_par.addWidget(self.butLoad)
layH_io_par.addWidget(self.lbl_info)
layV_io = QVBoxLayout()
layV_io.addLayout(layH_io_par)
layH_io = QHBoxLayout()
layH_io.addLayout(layV_io)
layH_io.addStretch(10)
self.wdg_top = QWidget(self)
self.wdg_top.setLayout(layH_io)
self.wdg_top.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- Matplotlib widget with NavigationToolbar
- Frame with control elements
"""
self.chkWarnings = QCheckBox(self.tr("Verbose"), self)
self.chkWarnings.setChecked(self.verbose)
self.chkWarnings.setToolTip(
self.
tr("<span>Print messages about singular group delay and calculation times."
"</span>"))
self.cmbAlgorithm = QComboBox(self)
qcmb_box_populate(self.cmbAlgorithm, self.cmb_algorithm_items,
self.algorithm)
layHControls = QHBoxLayout()
layHControls.addStretch(10)
layHControls.addWidget(self.chkWarnings)
# layHControls.addWidget(self.chkScipy)
layHControls.addWidget(self.cmbAlgorithm)
# This widget encompasses all control subwidgets:
self.frmControls = QFrame(self)
self.frmControls.setObjectName("frmControls")
self.frmControls.setLayout(layHControls)
self.mplwidget = MplWidget(self)
self.mplwidget.layVMainMpl.addWidget(self.frmControls)
self.mplwidget.layVMainMpl.setContentsMargins(*params['mpl_margins'])
self.mplwidget.mplToolbar.a_he.setEnabled(True)
self.mplwidget.mplToolbar.a_he.info = "manual/plot_tau_g.html"
self.setLayout(self.mplwidget.layVMainMpl)
self.init_axes()
self.draw() # initial drawing of tau_g
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.mplwidget.mplToolbar.sig_tx.connect(self.process_sig_rx)
self.cmbAlgorithm.currentIndexChanged.connect(self.draw)
def __init__(self, parent):
super(MplWidget, self).__init__(parent)
# Create the mpl figure and subplot (white bg, 100 dots-per-inch).
# Construct the canvas with the figure:
self.plt_lim = [] # define variable for x,y plot limits
if cmp_version("matplotlib", "2.2.0") >= 0:
self.fig = Figure(constrained_layout=True)
else:
self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
self.canvas.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
# Needed for mouse modifiers (x,y, <CTRL>, ...):
# Key press events in general are not processed unless you
# "activate the focus of Qt onto your mpl canvas"
# http://stackoverflow.com/questions/22043549/matplotlib-and-qt-mouse-press-event-key-is-always-none
self.canvas.setFocusPolicy( QtCore.Qt.ClickFocus )
self.canvas.setFocus()
self.canvas.updateGeometry()
# Create a custom navigation toolbar, tied to the canvas and
# initialize toolbar settings
#
self.mplToolbar = MplToolbar(self.canvas, self)
self.mplToolbar.zoom_locked = False
self.mplToolbar.cursor_enabled = False
#self.mplToolbar.enable_plot(state = True)
self.mplToolbar.sig_tx.connect(self.process_signals)
layHToolbar = QHBoxLayout()
layHToolbar.addWidget(self.mplToolbar, 1, QtCore.Qt.AlignLeft)
layHToolbar.addStretch(1)
#=============================================
# Main plot widget layout
#=============================================
self.layVMainMpl = QVBoxLayout()
self.layVMainMpl.addLayout(layHToolbar)
self.layVMainMpl.addWidget(self.canvas)
self.setLayout(self.layVMainMpl)
def _construct_UI(self):
"""
Construct the User Interface
"""
bfont = QFont()
bfont.setBold(True)
lblTitle = QLabel(str(self.title), self) # field for widget title
lblTitle.setFont(bfont)
lblTitle.setWordWrap(True)
self.lblUnit = QLabel(self)
self.lblUnit.setText("in " +
to_html(fb.fil[0]['freq_specs_unit'], frmt='bi'))
layHTitle = QHBoxLayout()
layHTitle.addWidget(lblTitle)
layHTitle.addWidget(self.lblUnit)
layHTitle.addStretch(1)
# Create a gridLayout consisting of QLabel and QLineEdit fields
# for the frequency specs:
self.layGSpecs = QGridLayout() # sublayout for spec fields
# set the title as the first (fixed) entry in grid layout. The other
# fields are added and hidden dynamically in _show_entries and _hide_entries()
self.layGSpecs.addLayout(layHTitle, 0, 0, 1, 2)
self.layGSpecs.setAlignment(Qt.AlignLeft)
self.frmMain = QFrame(self)
self.frmMain.setLayout(self.layGSpecs)
self.layVMain = QVBoxLayout() # Widget main layout
self.layVMain.addWidget(self.frmMain) #, Qt.AlignLeft)
self.layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(self.layVMain)
self.n_cur_labels = 0 # number of currently visible labels / qlineedits
#----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- Matplotlib widget with NavigationToolbar
- Frame with control elements
"""
self.chkHf = QCheckBox("Show |H(f)|", self)
self.chkHf.setToolTip(
"<span>Display |H(f)| around unit circle.</span>")
self.chkHf.setEnabled(True)
self.chkHfLog = QCheckBox("Log. Scale", self)
self.chkHfLog.setToolTip("<span>Log. scale for |H(f)|.</span>")
self.chkHfLog.setEnabled(True)
self.diaRad_Hf = QDial(self)
self.diaRad_Hf.setRange(2., 10.)
self.diaRad_Hf.setValue(2)
self.diaRad_Hf.setTracking(False) # produce less events when turning
self.diaRad_Hf.setFixedHeight(30)
self.diaRad_Hf.setFixedWidth(30)
self.diaRad_Hf.setWrapping(False)
self.diaRad_Hf.setToolTip(
"<span>Set max. radius for |H(f)| plot.</span>")
self.lblRad_Hf = QLabel("Radius", self)
self.chkFIR_P = QCheckBox("Plot FIR Poles", self)
self.chkFIR_P.setToolTip("<span>Show FIR poles at the origin.</span>")
self.chkFIR_P.setChecked(True)
layHControls = QHBoxLayout()
layHControls.addWidget(self.chkHf)
layHControls.addWidget(self.chkHfLog)
layHControls.addWidget(self.diaRad_Hf)
layHControls.addWidget(self.lblRad_Hf)
layHControls.addStretch(10)
layHControls.addWidget(self.chkFIR_P)
#----------------------------------------------------------------------
# ### frmControls ###
#
# This widget encompasses all control subwidgets
#----------------------------------------------------------------------
self.frmControls = QFrame(self)
self.frmControls.setObjectName("frmControls")
self.frmControls.setLayout(layHControls)
#----------------------------------------------------------------------
# ### mplwidget ###
#
# main widget, encompassing the other widgets
#----------------------------------------------------------------------
self.mplwidget = MplWidget(self)
self.mplwidget.layVMainMpl.addWidget(self.frmControls)
self.mplwidget.layVMainMpl.setContentsMargins(*params['wdg_margins'])
self.setLayout(self.mplwidget.layVMainMpl)
self.init_axes()
self.draw() # calculate and draw poles and zeros
#----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.mplwidget.mplToolbar.sig_tx.connect(self.process_sig_rx)
self.chkHf.clicked.connect(self.draw)
self.chkHfLog.clicked.connect(self.draw)
self.diaRad_Hf.valueChanged.connect(self.draw)
self.chkFIR_P.clicked.connect(self.draw)
class EllipZeroPhz(QWidget):
# Since we are also using poles/residues -> let's force zpk
# if SOS_AVAIL:
# output format of filter design routines 'zpk' / 'ba' / 'sos'
# FRMT = 'sos'
# else:
FRMT = 'zpk'
info = """
**Elliptic filters with zero phase**
(also known as Cauer filters) have the steepest rate of transition between the
frequency response’s passband and stopband of all IIR filters. This comes
at the expense of a constant ripple (equiripple) :math:`A_PB` and :math:`A_SB`
in both pass and stop band. Ringing of the step response is increased in
comparison to Chebychev filters.
As the passband ripple :math:`A_PB` approaches 0, the elliptical filter becomes
a Chebyshev type II filter. As the stopband ripple :math:`A_SB` approaches 0,
it becomes a Chebyshev type I filter. As both approach 0, becomes a Butterworth
filter (butter).
For the filter design, the order :math:`N`, minimum stopband attenuation
:math:`A_SB` and the critical frequency / frequencies :math:`F_PB` where the
gain first drops below the maximum passband ripple :math:`-A_PB` have to be specified.
The ``ellipord()`` helper routine calculates the minimum order :math:`N` and
critical passband frequency :math:`F_C` from pass and stop band specifications.
The Zero Phase Elliptic Filter squares an elliptic filter designed in
a way to produce the required Amplitude specifications. So initially the
amplitude specs design an elliptic filter with the square root of the amp specs.
The filter is then squared to produce a zero phase filter.
The filter coefficients are applied to the signal data in a backward and forward
time fashion. This filter can only be applied to stored signal data (not
real-time streaming data that comes in a forward time order).
We are forcing the order N of the filter to be even. This simplifies the poles/zeros
to be complex (no real values).
**Design routines:**
``scipy.signal.ellip()``, ``scipy.signal.ellipord()``
"""
sig_tx = pyqtSignal(object)
def __init__(self):
QWidget.__init__(self)
self.ft = 'IIR'
c = Common()
self.rt_dict = c.rt_base_iir
self.rt_dict_add = {
'COM':{'man':{'msg':('a',
"Enter the filter order <b><i>N</i></b>, the minimum stop "
"band attenuation <b><i>A<sub>SB</sub></i></b> and frequency or "
"frequencies <b><i>F<sub>C</sub></i></b> where gain first drops "
"below the max passband ripple <b><i>-A<sub>PB</sub></i></b> .")}},
'LP': {'man':{}, 'min':{}},
'HP': {'man':{}, 'min':{}},
'BS': {'man':{}, 'min':{}},
'BP': {'man':{}, 'min':{}},
}
self.info_doc = []
self.info_doc.append('ellip()\n========')
self.info_doc.append(sig.ellip.__doc__)
self.info_doc.append('ellipord()\n==========')
self.info_doc.append(ellipord.__doc__)
#--------------------------------------------------------------------------
def construct_UI(self):
"""
Create additional subwidget(s) needed for filter design:
These subwidgets are instantiated dynamically when needed in
select_filter.py using the handle to the filter instance, fb.fil_inst.
"""
self.chkComplex = QCheckBox("ComplexFilter", self)
self.chkComplex.setToolTip("Designs BP or BS Filter for complex data.")
self.chkComplex.setObjectName('wdg_lbl_el')
self.chkComplex.setChecked(False)
#--------------------------------------------------
# Layout for filter optional subwidgets
self.layHWin = QHBoxLayout()
self.layHWin.setObjectName('wdg_layGWin')
#self.layHWin.addWidget(self.chkComplex)
self.layHWin.addStretch()
self.layHWin.setContentsMargins(0,0,0,0)
# Widget containing all subwidgets
self.wdg_fil = QWidget(self)
self.wdg_fil.setObjectName('wdg_fil')
self.wdg_fil.setLayout(self.layHWin)
def _get_params(self, fil_dict):
"""
Translate parameters from the passed dictionary to instance
parameters, scaling / transforming them if needed.
For zero phase filter, we take square root of amplitude specs
since we later square filter. Define design around smallest amp spec
"""
# Frequencies are normalized to f_Nyq = f_S/2, ripple specs are in dB
self.analog = False # set to True for analog filters
self.manual = False # default is normal design
self.N = int(fil_dict['N'])
# force N to be even
if (self.N % 2) == 1:
self.N += 1
self.F_PB = fil_dict['F_PB'] * 2
self.F_SB = fil_dict['F_SB'] * 2
self.F_PB2 = fil_dict['F_PB2'] * 2
self.F_SB2 = fil_dict['F_SB2'] * 2
self.F_PBC = None
# find smallest spec'd linear value and rewrite dictionary
ampPB = fil_dict['A_PB']
ampSB = fil_dict['A_SB']
# take square roots of amp specs so resulting squared
# filter will meet specifications
if (ampPB < ampSB):
ampSB = sqrt(ampPB)
ampPB = sqrt(1+ampPB)-1
else:
ampPB = sqrt(1+ampSB)-1
ampSB = sqrt(ampSB)
self.A_PB = lin2unit(ampPB, 'IIR', 'A_PB', unit='dB')
self.A_SB = lin2unit(ampSB, 'IIR', 'A_SB', unit='dB')
#logger.warning("design with "+str(self.A_PB)+","+str(self.A_SB))
# ellip filter routines support only one amplitude spec for
# pass- and stop band each
if str(fil_dict['rt']) == 'BS':
fil_dict['A_PB2'] = self.A_PB
elif str(fil_dict['rt']) == 'BP':
fil_dict['A_SB2'] = self.A_SB
# partial fraction expansion to define residue vector
def _partial(self, k, p, z, norder):
# create diff array
diff = p - z
# now compute residual vector
cone = complex(1.,0.)
residues = zeros(norder, complex)
for i in range(norder):
residues[i] = k * (diff[i] / p[i])
for j in range(norder):
if (j != i):
residues[i] = residues[i] * (cone + diff[j]/(p[i] - p[j]))
# now compute DC term for new expansion
sumRes = 0.
for i in range(norder):
sumRes = sumRes + residues[i].real
dc = k - sumRes
return (dc, residues)
#
# Take a causal filter and square it. The result has the square
# of the amplitude response of the input, and zero phase. Filter
# is noncausal.
# Input:
# k - gain in pole/zero form
# p - numpy array of poles
# z - numpy array of zeros
# g - gain in pole/residue form
# r - numpy array of residues
# nn- order of filter
# Output:
# kn - new gain (pole/zero)
# pn - new poles
# zn - new zeros (numpy array)
# gn - new gain (pole/residue)
# rn - new residues
def _sqCausal (self, k, p, z, g, r, nn):
# Anticausal poles have conjugate-reciprocal symmetry
# Starting anticausal residues are conjugates (adjusted below)
pA = conj(1./p) # antiCausal poles
zA = conj(z) # antiCausal zeros (store reciprocal)
rA = conj(r) # antiCausal residues (to start)
rC = zeros(nn, complex)
# Adjust residues. Causal part first.
for j in range(nn):
# Evaluate the anticausal filter at each causal pole
tmpx = rA / (1. - p[j]/pA)
ztmp = g + sum(tmpx)
# Adjust residue
rC[j] = r[j]*ztmp
# anticausal residues are just conjugates of causal residues
# r3 = np.conj(r2)
# Compute the constant term
dc2 = (g + sum(r))*g - sum(rC)
# Populate output (2nn elements)
gn = dc2.real
# Drop complex poles/residues in LHP, keep only UHP
pA = conj(p) #store AntiCasual pole (reciprocal)
p0 = zeros(int(nn/2), complex)
r0 = zeros(int(nn/2), complex)
cnt = 0
for j in range(nn):
if (p[j].imag > 0.0):
p0[cnt] = p[j]
r0[cnt] = rC[j]
cnt = cnt+1
# Let operator know we squared filter
# logger.info('After squaring filter, order: '+str(nn*2))
# For now and our case, only store causal residues
# Filters are symmetric and can generate antiCausal residues
return (pA, zA, gn, p0, r0)
def _test_N(self):
"""
Warn the user if the calculated order is too high for a reasonable filter
design.
"""
if self.N > 30:
return qfilter_warning(self, self.N, "Zero-phase Elliptic")
else:
return True
# custom save of filter dictionary
def _save(self, fil_dict, arg):
"""
First design initial elliptic filter meeting sqRoot Amp specs;
- Then create residue vector from poles/zeros;
- Then square filter (k,p,z and dc,p,r) to get zero phase filter;
- Then Convert results of filter design to all available formats (pz, pr, ba, sos)
and store them in the global filter dictionary.
Corner frequencies and order calculated for minimum filter order are
also stored to allow for an easy subsequent manual filter optimization.
"""
fil_save(fil_dict, arg, self.FRMT, __name__)
# For min. filter order algorithms, update filter dict with calculated
# new values for filter order N and corner frequency(s) F_PBC
fil_dict['N'] = self.N
if str(fil_dict['fo']) == 'min':
if str(fil_dict['rt']) == 'LP' or str(fil_dict['rt']) == 'HP':
# HP or LP - single corner frequency
fil_dict['F_PB'] = self.F_PBC / 2.
else: # BP or BS - two corner frequencies
fil_dict['F_PB'] = self.F_PBC[0] / 2.
fil_dict['F_PB2'] = self.F_PBC[1] / 2.
# Now generate poles/residues for custom file save of new parameters
if (not self.manual):
z = fil_dict['zpk'][0]
p = fil_dict['zpk'][1]
k = fil_dict['zpk'][2]
n = len(z)
gain, residues = self._partial (k, p, z, n)
pA, zA, gn, pC, rC = self._sqCausal (k, p, z, gain, residues, n)
fil_dict['rpk'] = [rC, pC, gn]
# save antiCausal b,a (nonReciprocal) also [easier to compute h(n)
try:
fil_dict['baA'] = sig.zpk2tf(zA, pA, k)
except Exception as e:
logger.error(e)
# 'rpk' is our signal that this is a non-Causal filter with zero phase
# inserted into fil dictionary after fil_save and convert
# sig_tx -> select_filter -> filter_specs
self.sig_tx.emit({'sender':__name__, 'filt_changed':'ellip_zero'})
#------------------------------------------------------------------------------
#
# DESIGN ROUTINES
#
#------------------------------------------------------------------------------
# LP: F_PB < F_stop -------------------------------------------------------
def LPmin(self, fil_dict):
"""Elliptic LP filter, minimum order"""
self._get_params(fil_dict)
self.N, self.F_PBC = ellipord(self.F_PB,self.F_SB, self.A_PB,self.A_SB, analog=self.analog)
# force even N
if (self.N%2)== 1:
self.N += 1
if not self._test_N():
return -1
#logger.warning("and "+str(self.F_PBC) + " " + str(self.N))
self._save(fil_dict, sig.ellip(self.N, self.A_PB, self.A_SB, self.F_PBC,
btype='low', analog=self.analog, output=self.FRMT))
def LPman(self, fil_dict):
"""Elliptic LP filter, manual order"""
self._get_params(fil_dict)
if not self._test_N():
return -1
self._save(fil_dict, sig.ellip(self.N, self.A_PB, self.A_SB, self.F_PB,
btype='low', analog=self.analog, output=self.FRMT))
# HP: F_stop < F_PB -------------------------------------------------------
def HPmin(self, fil_dict):
"""Elliptic HP filter, minimum order"""
self._get_params(fil_dict)
self.N, self.F_PBC = ellipord(self.F_PB,self.F_SB, self.A_PB,self.A_SB,
analog=self.analog)
# force even N
if (self.N%2)== 1:
self.N += 1
if not self._test_N():
return -1
self._save(fil_dict, sig.ellip(self.N, self.A_PB, self.A_SB, self.F_PBC,
btype='highpass', analog=self.analog, output=self.FRMT))
def HPman(self, fil_dict):
"""Elliptic HP filter, manual order"""
self._get_params(fil_dict)
if not self._test_N():
return -1
self._save(fil_dict, sig.ellip(self.N, self.A_PB, self.A_SB, self.F_PB,
btype='highpass', analog=self.analog, output=self.FRMT))
# For BP and BS, F_XX have two elements each, A_XX has only one
# BP: F_SB[0] < F_PB[0], F_SB[1] > F_PB[1] --------------------------------
def BPmin(self, fil_dict):
"""Elliptic BP filter, minimum order"""
self._get_params(fil_dict)
self.N, self.F_PBC = ellipord([self.F_PB, self.F_PB2],
[self.F_SB, self.F_SB2], self.A_PB, self.A_SB, analog=self.analog)
#logger.warning(" "+str(self.F_PBC) + " " + str(self.N))
if (self.N%2)== 1:
self.N += 1
if not self._test_N():
return -1
#logger.warning("-"+str(self.F_PBC) + " " + str(self.A_SB))
self._save(fil_dict, sig.ellip(self.N, self.A_PB, self.A_SB, self.F_PBC,
btype='bandpass', analog=self.analog, output=self.FRMT))
def BPman(self, fil_dict):
"""Elliptic BP filter, manual order"""
self._get_params(fil_dict)
if not self._test_N():
return -1
self._save(fil_dict, sig.ellip(self.N, self.A_PB, self.A_SB,
[self.F_PB,self.F_PB2], btype='bandpass', analog=self.analog,
output=self.FRMT))
# BS: F_SB[0] > F_PB[0], F_SB[1] < F_PB[1] --------------------------------
def BSmin(self, fil_dict):
"""Elliptic BP filter, minimum order"""
self._get_params(fil_dict)
self.N, self.F_PBC = ellipord([self.F_PB, self.F_PB2],
[self.F_SB, self.F_SB2], self.A_PB,self.A_SB, analog=self.analog)
# force even N
if (self.N%2)== 1:
self.N += 1
if not self._test_N():
return -1
self._save(fil_dict, sig.ellip(self.N, self.A_PB, self.A_SB, self.F_PBC,
btype='bandstop', analog=self.analog, output=self.FRMT))
def BSman(self, fil_dict):
"""Elliptic BS filter, manual order"""
self._get_params(fil_dict)
if not self._test_N():
return -1
self._save(fil_dict, sig.ellip(self.N, self.A_PB, self.A_SB,
[self.F_PB,self.F_PB2], btype='bandstop', analog=self.analog,
output=self.FRMT))
def _construct_UI(self):
"""
Construct User Interface
"""
amp_units = ["dB", "V", "W"]
bfont = QFont()
bfont.setBold(True)
lblTitle = QLabel(str(self.title), self) # field for widget title
lblTitle.setFont(bfont)
lblTitle.setWordWrap(True)
lblUnits = QLabel("in", self)
self.cmbUnitsA = QComboBox(self)
self.cmbUnitsA.addItems(amp_units)
self.cmbUnitsA.setObjectName("cmbUnitsA")
self.cmbUnitsA.setToolTip(
"<span>Unit for amplitude specifications:"
" dB is attenuation (> 0); levels in V and W have to be < 1.</span>"
)
# fit size dynamically to largest element:
self.cmbUnitsA.setSizeAdjustPolicy(QComboBox.AdjustToContents)
# find index for default unit from dictionary and set the unit
amp_idx = self.cmbUnitsA.findData(fb.fil[0]['amp_specs_unit'])
if amp_idx < 0:
amp_idx = 0
self.cmbUnitsA.setCurrentIndex(amp_idx) # initialize for dBs
layHTitle = QHBoxLayout() # layout for title and unit
layHTitle.addWidget(lblTitle)
layHTitle.addWidget(lblUnits, Qt.AlignLeft)
layHTitle.addWidget(self.cmbUnitsA, Qt.AlignLeft)
layHTitle.addStretch(1)
self.layGSpecs = QGridLayout() # sublayout for spec fields
# set the title as the first (fixed) entry in grid layout. The other
# fields are added and hidden dynamically in _show_entries and _hide_entries()
self.layGSpecs.addLayout(layHTitle, 0, 0, 1, 2)
self.layGSpecs.setAlignment(Qt.AlignLeft)
# This is the top level widget, encompassing the other widgets
self.frmMain = QFrame(self)
self.frmMain.setLayout(self.layGSpecs)
self.layVMain = QVBoxLayout() # Widget main layout
self.layVMain.addWidget(self.frmMain)
self.layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(self.layVMain)
self.n_cur_labels = 0 # number of currently visible labels / qlineedits
# - Build a list from all entries in the fil_dict dictionary starting
# with "A" (= amplitude specifications of the current filter)
# - Pass the list to update_UI which recreates the widget
# ATTENTION: Entries need to be converted from QString to str for Py 2
new_labels = [str(l) for l in fb.fil[0] if l[0] == 'A']
self.update_UI(new_labels=new_labels)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs / EVENT MONITORING
#----------------------------------------------------------------------
self.cmbUnitsA.currentIndexChanged.connect(self._set_amp_unit)
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- Matplotlib widget with NavigationToolbar
- Frame with control elements
"""
self.chkWarnings = QCheckBox(self.tr("Verbose"), self)
self.chkWarnings.setChecked(self.verbose)
self.chkWarnings.setToolTip(self.tr("<span>Print messages about singular group delay"
"and calculation times."))
self.cmbAlgorithm = QComboBox(self)
for t in [(self.tr("Auto"),"auto"),(self.tr("Scipy"),"scipy"), (self.tr("JOS"), "jos"),
(self.tr("Diff"), "diff"), (self.tr("Shpak"), "shpak")]: # text, data
self.cmbAlgorithm.addItem(*t)
qset_cmb_box(self.cmbAlgorithm, self.algorithm,data=True)
self.cmbAlgorithm.setToolTip(self.tr("<span>Select algorithm for calculating "
"the group delay.</span>"))
self.cmbAlgorithm.setItemData(0, self.tr("<span>Try to find best-suited algorithm."
"</span>"),Qt.ToolTipRole)
self.cmbAlgorithm.setItemData(1, self.tr("<span>Scipy algorithm.</span>"),Qt.ToolTipRole)
self.cmbAlgorithm.setItemData(2, self.tr("<span>J.O. Smith's algorithm.</span>"),Qt.ToolTipRole)
self.cmbAlgorithm.setItemData(3, self.tr("<span>Textbook-style, differentiate "
"the phase.</span>"),Qt.ToolTipRole)
self.cmbAlgorithm.setItemData(4, self.tr("<span>Shpak's algorithm for SOS and other "
"IIR filters.</span>"),Qt.ToolTipRole)
#self.chkScipy = QCheckBox("Scipy", self)
#self.chkScipy.setChecked(False)
#self.chkScipy.setToolTip("Use scipy group delay routine")
layHControls = QHBoxLayout()
layHControls.addStretch(10)
layHControls.addWidget(self.chkWarnings)
#layHControls.addWidget(self.chkScipy)
layHControls.addWidget(self.cmbAlgorithm)
# This widget encompasses all control subwidgets:
self.frmControls = QFrame(self)
self.frmControls.setObjectName("frmControls")
self.frmControls.setLayout(layHControls)
self.mplwidget = MplWidget(self)
self.mplwidget.layVMainMpl.addWidget(self.frmControls)
self.mplwidget.layVMainMpl.setContentsMargins(*params['wdg_margins'])
self.mplwidget.mplToolbar.a_he.setEnabled(True)
self.mplwidget.mplToolbar.a_he.info = "manual/plot_tau_g.html"
self.setLayout(self.mplwidget.layVMainMpl)
self.init_axes()
self.draw() # initial drawing of tau_g
#----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.mplwidget.mplToolbar.sig_tx.connect(self.process_sig_rx)
self.cmbAlgorithm.currentIndexChanged.connect(self.draw)
def _construct_UI(self, **kwargs):
"""
Construct widget from quantization dict, individual settings and
the default dict below """
# default settings
dict_ui = {
'wdg_name': 'ui_w',
'label': 'WI.WF',
'lbl_sep': '.',
'max_led_width': 30,
'WI': 0,
'WI_len': 2,
'tip_WI': 'Number of integer bits',
'WF': 15,
'WF_len': 2,
'tip_WF': 'Number of fractional bits',
'enabled': True,
'visible': True,
'fractional': True,
'combo_visible': False,
'combo_items': ['auto', 'full', 'man'],
'tip_combo': 'Calculate Acc. width.',
'lock_visible': False,
'tip_lock': 'Lock input/output quantization.'
} #: default values
if self.q_dict:
dict_ui.update(self.q_dict)
for k, v in kwargs.items():
if k not in dict_ui:
logger.warning("Unknown key {0}".format(k))
else:
dict_ui.update({k: v})
self.wdg_name = dict_ui['wdg_name']
if not dict_ui['fractional']:
dict_ui['WF'] = 0
self.WI = dict_ui['WI']
self.WF = dict_ui['WF']
self.W = int(self.WI + self.WF + 1)
if self.q_dict:
self.q_dict.update({'WI': self.WI, 'WF': self.WF, 'W': self.W})
else:
self.q_dict = {'WI': self.WI, 'WF': self.WF, 'W': self.W}
lblW = QLabel(to_html(dict_ui['label'], frmt='bi'), self)
self.cmbW = QComboBox(self)
self.cmbW.addItems(dict_ui['combo_items'])
self.cmbW.setVisible(dict_ui['combo_visible'])
self.cmbW.setToolTip(dict_ui['tip_combo'])
self.cmbW.setObjectName("cmbW")
self.butLock = QPushButton(self)
self.butLock.setCheckable(True)
self.butLock.setChecked(False)
self.butLock.setVisible(dict_ui['lock_visible'])
self.butLock.setToolTip(dict_ui['tip_lock'])
self.ledWI = QLineEdit(self)
self.ledWI.setToolTip(dict_ui['tip_WI'])
self.ledWI.setMaxLength(dict_ui['WI_len']) # maximum of 2 digits
self.ledWI.setFixedWidth(
dict_ui['max_led_width']) # width of lineedit in points
self.ledWI.setObjectName("WI")
lblDot = QLabel(dict_ui['lbl_sep'], self)
lblDot.setVisible(dict_ui['fractional'])
self.ledWF = QLineEdit(self)
self.ledWF.setToolTip(dict_ui['tip_WF'])
self.ledWF.setMaxLength(dict_ui['WI_len']) # maximum of 2 digits
self.ledWF.setFixedWidth(
dict_ui['max_led_width']) # width of lineedit in points
self.ledWF.setVisible(dict_ui['fractional'])
self.ledWF.setObjectName("WF")
layH = QHBoxLayout()
layH.addWidget(lblW)
layH.addStretch()
layH.addWidget(self.cmbW)
layH.addWidget(self.butLock)
layH.addWidget(self.ledWI)
layH.addWidget(lblDot)
layH.addWidget(self.ledWF)
layH.setContentsMargins(0, 0, 0, 0)
frmMain = QFrame(self)
frmMain.setLayout(layH)
layVMain = QVBoxLayout() # Widget main layout
layVMain.addWidget(frmMain)
layVMain.setContentsMargins(0, 5, 0, 0) # *params['wdg_margins'])
self.setLayout(layVMain)
# ----------------------------------------------------------------------
# INITIAL SETTINGS
# ----------------------------------------------------------------------
self.ledWI.setText(qstr(dict_ui['WI']))
self.ledWF.setText(qstr(dict_ui['WF']))
frmMain.setEnabled(dict_ui['enabled'])
frmMain.setVisible(dict_ui['visible'])
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.ledWI.editingFinished.connect(self.ui2dict)
self.ledWF.editingFinished.connect(self.ui2dict)
self.butLock.clicked.connect(self.butLock_clicked)
self.cmbW.currentIndexChanged.connect(self.ui2dict)
# initialize button icon
self.butLock_clicked(self.butLock.isChecked())
def _construct_UI(self):
# ----------- ---------------------------------------------------
# Run control widgets
# ---------------------------------------------------------------
self.chk_auto_run = QCheckBox("Auto", self)
self.chk_auto_run.setObjectName("chk_auto_run")
self.chk_auto_run.setToolTip("<span>Update response automatically when "
"parameters have been changed.</span>")
self.chk_auto_run.setChecked(True)
self.but_run = QPushButton(self)
self.but_run.setText("RUN")
self.but_run.setToolTip("Run simulation")
self.but_run.setEnabled(not self.chk_auto_run.isChecked())
self.cmb_sim_select = QComboBox(self)
self.cmb_sim_select.addItems(["Float","Fixpoint"])
qset_cmb_box(self.cmb_sim_select, "Float")
self.cmb_sim_select.setToolTip("<span>Simulate floating-point or fixpoint response."
"</span>")
self.lbl_N_points = QLabel(to_html("N", frmt='bi') + " =", self)
self.led_N_points = QLineEdit(self)
self.led_N_points.setText(str(self.N))
self.led_N_points.setToolTip("<span>Number of displayed data points. "
"<i>N</i> = 0 tries to choose for you.</span>")
self.lbl_N_start = QLabel(to_html("N_0", frmt='bi') + " =", self)
self.led_N_start = QLineEdit(self)
self.led_N_start.setText(str(self.N_start))
self.led_N_start.setToolTip("<span>First point to plot.</span>")
self.chk_fx_scale = QCheckBox("Int. scale", self)
self.chk_fx_scale.setObjectName("chk_fx_scale")
self.chk_fx_scale.setToolTip("<span>Display data with integer (fixpoint) scale.</span>")
self.chk_fx_scale.setChecked(False)
self.chk_stim_options = QCheckBox("Stim. Options", self)
self.chk_stim_options.setObjectName("chk_stim_options")
self.chk_stim_options.setToolTip("<span>Show stimulus options.</span>")
self.chk_stim_options.setChecked(True)
self.but_fft_win = QPushButton(self)
self.but_fft_win.setText("WIN FFT")
self.but_fft_win.setToolTip('<span> time and frequency response of FFT Window '
'(can be modified in the "Frequency" tab)</span>')
self.but_fft_win.setCheckable(True)
self.but_fft_win.setChecked(False)
layH_ctrl_run = QHBoxLayout()
layH_ctrl_run.addWidget(self.but_run)
#layH_ctrl_run.addWidget(self.lbl_sim_select)
layH_ctrl_run.addWidget(self.cmb_sim_select)
layH_ctrl_run.addWidget(self.chk_auto_run)
layH_ctrl_run.addStretch(1)
layH_ctrl_run.addWidget(self.lbl_N_start)
layH_ctrl_run.addWidget(self.led_N_start)
layH_ctrl_run.addStretch(1)
layH_ctrl_run.addWidget(self.lbl_N_points)
layH_ctrl_run.addWidget(self.led_N_points)
layH_ctrl_run.addStretch(2)
layH_ctrl_run.addWidget(self.chk_fx_scale)
layH_ctrl_run.addStretch(2)
layH_ctrl_run.addWidget(self.chk_stim_options)
layH_ctrl_run.addStretch(2)
layH_ctrl_run.addWidget(self.but_fft_win)
layH_ctrl_run.addStretch(10)
#layH_ctrl_run.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_run = QWidget(self)
self.wdg_ctrl_run.setLayout(layH_ctrl_run)
# --- end of run control ----------------------------------------
# ----------- ---------------------------------------------------
# Controls for time domain
# ---------------------------------------------------------------
plot_styles_list = ["None","Dots","Line","Line*","Stem","Stem*","Step","Step*"]
lbl_plt_time_title = QLabel("<b>View:</b>", self)
self.lbl_plt_time_stim = QLabel(to_html("Stimulus x", frmt='bi'), self)
self.cmb_plt_time_stim = QComboBox(self)
self.cmb_plt_time_stim.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_time_stim, self.plt_time_stim)
self.cmb_plt_time_stim.setToolTip("<span>Plot style for stimulus.</span>")
self.lbl_plt_time_stmq = QLabel(to_html(" Fixp. Stim. x_Q", frmt='bi'), self)
self.cmb_plt_time_stmq = QComboBox(self)
self.cmb_plt_time_stmq.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_time_stmq, self.plt_time_stmq)
self.cmb_plt_time_stmq.setToolTip("<span>Plot style for <em>fixpoint</em> (quantized) stimulus.</span>")
lbl_plt_time_resp = QLabel(to_html(" Response y", frmt='bi'), self)
self.cmb_plt_time_resp = QComboBox(self)
self.cmb_plt_time_resp.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_time_resp, self.plt_time_resp)
self.cmb_plt_time_resp.setToolTip("<span>Plot style for response.</span>")
lbl_win_time = QLabel(to_html(" FFT Window", frmt='bi'), self)
self.chk_win_time = QCheckBox(self)
self.chk_win_time.setObjectName("chk_win_time")
self.chk_win_time.setToolTip('<span>Show FFT windowing function (can be modified in the "Frequency" tab).</span>')
self.chk_win_time.setChecked(False)
lbl_log_time = QLabel(to_html("dB", frmt='b'), self)
self.chk_log_time = QCheckBox(self)
self.chk_log_time.setObjectName("chk_log_time")
self.chk_log_time.setToolTip("<span>Logarithmic scale for y-axis.</span>")
self.chk_log_time.setChecked(False)
self.lbl_log_bottom_time = QLabel(to_html("min =", frmt='bi'), self)
self.lbl_log_bottom_time.setVisible(True)
self.led_log_bottom_time = QLineEdit(self)
self.led_log_bottom_time.setText(str(self.bottom_t))
self.led_log_bottom_time.setToolTip("<span>Minimum display value for time "
"and spectrogram plots with log. scale.</span>")
self.led_log_bottom_time.setVisible(True)
lbl_plt_time_spgr = QLabel(to_html(" Spectrogram", frmt='bi'), self)
self.cmb_plt_time_spgr = QComboBox(self)
self.cmb_plt_time_spgr.addItems(["None", "x[n]", "x_q[n]", "y[n]"])
qset_cmb_box(self.cmb_plt_time_spgr, self.plt_time_spgr)
self.cmb_plt_time_spgr.setToolTip("<span>Show Spectrogram for selected signal.</span>")
spgr_en = self.plt_time_spgr != "None"
self.lbl_log_spgr_time = QLabel(to_html(" dB", frmt='b'), self)
self.lbl_log_spgr_time.setVisible(spgr_en)
self.chk_log_spgr_time = QCheckBox(self)
self.chk_log_spgr_time.setObjectName("chk_log_spgr")
self.chk_log_spgr_time.setToolTip("<span>Logarithmic scale for spectrogram.</span>")
self.chk_log_spgr_time.setChecked(True)
self.chk_log_spgr_time.setVisible(spgr_en)
self.lbl_nfft_spgr_time = QLabel(to_html(" N_FFT =", frmt='bi'), self)
self.lbl_nfft_spgr_time.setVisible(spgr_en)
self.led_nfft_spgr_time = QLineEdit(self)
self.led_nfft_spgr_time.setText(str(self.nfft_spgr_time))
self.led_nfft_spgr_time.setToolTip("<span>Number of FFT points per spectrogram segment.</span>")
self.led_nfft_spgr_time.setVisible(spgr_en)
self.lbl_ovlp_spgr_time = QLabel(to_html(" N_OVLP =", frmt='bi'), self)
self.lbl_ovlp_spgr_time.setVisible(spgr_en)
self.led_ovlp_spgr_time = QLineEdit(self)
self.led_ovlp_spgr_time.setText(str(self.ovlp_spgr_time))
self.led_ovlp_spgr_time.setToolTip("<span>Number of overlap data points between spectrogram segments.</span>")
self.led_ovlp_spgr_time.setVisible(spgr_en)
self.lbl_mode_spgr_time = QLabel(to_html(" Mode", frmt='bi'), self)
self.lbl_mode_spgr_time.setVisible(spgr_en)
self.cmb_mode_spgr_time = QComboBox(self)
spgr_modes = [("PSD","psd"), ("Mag.","magnitude"),\
("Angle","angle"), ("Phase","phase")]
for i in spgr_modes:
self.cmb_mode_spgr_time.addItem(*i)
qset_cmb_box(self.cmb_mode_spgr_time, self.mode_spgr_time, data=True)
self.cmb_mode_spgr_time.setToolTip("<span>Spectrogram display mode.</span>")
self.cmb_mode_spgr_time.setVisible(spgr_en)
self.lbl_byfs_spgr_time = QLabel(to_html(" per f_S", frmt='b'), self)
self.lbl_byfs_spgr_time.setVisible(spgr_en)
self.chk_byfs_spgr_time = QCheckBox(self)
self.chk_byfs_spgr_time.setObjectName("chk_log_spgr")
self.chk_byfs_spgr_time.setToolTip("<span>Display spectral density i.e. scale by f_S</span>")
self.chk_byfs_spgr_time.setChecked(True)
self.chk_byfs_spgr_time.setVisible(spgr_en)
# self.lbl_colorbar_time = QLabel(to_html(" Col.bar", frmt='b'), self)
# self.lbl_colorbar_time.setVisible(spgr_en)
# self.chk_colorbar_time = QCheckBox(self)
# self.chk_colorbar_time.setObjectName("chk_colorbar_time")
# self.chk_colorbar_time.setToolTip("<span>Enable colorbar</span>")
# self.chk_colorbar_time.setChecked(True)
# self.chk_colorbar_time.setVisible(spgr_en)
self.chk_fx_limits = QCheckBox("Min/max.", self)
self.chk_fx_limits.setObjectName("chk_fx_limits")
self.chk_fx_limits.setToolTip("<span>Display limits of fixpoint range.</span>")
self.chk_fx_limits.setChecked(False)
layH_ctrl_time = QHBoxLayout()
layH_ctrl_time.addWidget(lbl_plt_time_title)
layH_ctrl_time.addStretch(1)
layH_ctrl_time.addWidget(self.lbl_plt_time_stim)
layH_ctrl_time.addWidget(self.cmb_plt_time_stim)
#
layH_ctrl_time.addWidget(self.lbl_plt_time_stmq)
layH_ctrl_time.addWidget(self.cmb_plt_time_stmq)
#
layH_ctrl_time.addWidget(lbl_plt_time_resp)
layH_ctrl_time.addWidget(self.cmb_plt_time_resp)
#
layH_ctrl_time.addWidget(lbl_win_time)
layH_ctrl_time.addWidget(self.chk_win_time)
layH_ctrl_time.addStretch(1)
layH_ctrl_time.addWidget(lbl_log_time)
layH_ctrl_time.addWidget(self.chk_log_time)
layH_ctrl_time.addWidget(self.lbl_log_bottom_time)
layH_ctrl_time.addWidget(self.led_log_bottom_time)
#
layH_ctrl_time.addStretch(1)
#
layH_ctrl_time.addWidget(lbl_plt_time_spgr)
layH_ctrl_time.addWidget(self.cmb_plt_time_spgr)
layH_ctrl_time.addWidget(self.lbl_log_spgr_time)
layH_ctrl_time.addWidget(self.chk_log_spgr_time)
layH_ctrl_time.addWidget(self.lbl_nfft_spgr_time)
layH_ctrl_time.addWidget(self.led_nfft_spgr_time)
layH_ctrl_time.addWidget(self.lbl_ovlp_spgr_time)
layH_ctrl_time.addWidget(self.led_ovlp_spgr_time)
layH_ctrl_time.addWidget(self.lbl_mode_spgr_time)
layH_ctrl_time.addWidget(self.cmb_mode_spgr_time)
layH_ctrl_time.addWidget(self.lbl_byfs_spgr_time)
layH_ctrl_time.addWidget(self.chk_byfs_spgr_time)
layH_ctrl_time.addStretch(2)
layH_ctrl_time.addWidget(self.chk_fx_limits)
layH_ctrl_time.addStretch(10)
#layH_ctrl_time.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_time = QWidget(self)
self.wdg_ctrl_time.setLayout(layH_ctrl_time)
# ---- end time domain ------------------
# ---------------------------------------------------------------
# Controls for frequency domain
# ---------------------------------------------------------------
lbl_plt_freq_title = QLabel("<b>View:</b>", self)
self.lbl_plt_freq_stim = QLabel(to_html("Stimulus X", frmt='bi'), self)
self.cmb_plt_freq_stim = QComboBox(self)
self.cmb_plt_freq_stim.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_freq_stim, self.plt_freq_stim)
self.cmb_plt_freq_stim.setToolTip("<span>Plot style for stimulus.</span>")
self.lbl_plt_freq_stmq = QLabel(to_html(" Fixp. Stim. X_Q", frmt='bi'), self)
self.cmb_plt_freq_stmq = QComboBox(self)
self.cmb_plt_freq_stmq.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_freq_stmq, self.plt_freq_stmq)
self.cmb_plt_freq_stmq.setToolTip("<span>Plot style for <em>fixpoint</em> (quantized) stimulus.</span>")
lbl_plt_freq_resp = QLabel(to_html(" Response Y", frmt='bi'), self)
self.cmb_plt_freq_resp = QComboBox(self)
self.cmb_plt_freq_resp.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_freq_resp, self.plt_freq_resp)
self.cmb_plt_freq_resp.setToolTip("<span>Plot style for response.</span>")
lbl_log_freq = QLabel(to_html("dB", frmt='b'), self)
self.chk_log_freq = QCheckBox(self)
self.chk_log_freq.setObjectName("chk_log_freq")
self.chk_log_freq.setToolTip("<span>Logarithmic scale for y-axis.</span>")
self.chk_log_freq.setChecked(True)
self.lbl_log_bottom_freq = QLabel(to_html("min =", frmt='bi'), self)
self.lbl_log_bottom_freq.setVisible(self.chk_log_freq.isChecked())
self.led_log_bottom_freq = QLineEdit(self)
self.led_log_bottom_freq.setText(str(self.bottom_f))
self.led_log_bottom_freq.setToolTip("<span>Minimum display value for log. scale.</span>")
self.led_log_bottom_freq.setVisible(self.chk_log_freq.isChecked())
if not self.chk_log_freq.isChecked():
self.bottom_f = 0
lbl_re_im_freq = QLabel(to_html("Re / Im", frmt='b'), self)
self.chk_re_im_freq = QCheckBox(self)
self.chk_re_im_freq.setObjectName("chk_re_im_freq")
self.chk_re_im_freq.setToolTip("<span>Show real and imaginary part of spectrum</span>")
self.chk_re_im_freq.setChecked(False)
self.lbl_win_fft = QLabel(to_html("Window", frmt='bi'), self)
self.cmb_win_fft = QComboBox(self)
self.cmb_win_fft.addItems(get_window_names())
self.cmb_win_fft.setToolTip("FFT window type.")
qset_cmb_box(self.cmb_win_fft, self.window_name)
self.cmb_win_fft_variant = QComboBox(self)
self.cmb_win_fft_variant.setToolTip("FFT window variant.")
self.cmb_win_fft_variant.setVisible(False)
self.lblWinPar1 = QLabel("Param1")
self.ledWinPar1 = QLineEdit(self)
self.ledWinPar1.setText("1")
self.ledWinPar1.setObjectName("ledWinPar1")
self.lblWinPar2 = QLabel("Param2")
self.ledWinPar2 = QLineEdit(self)
self.ledWinPar2.setText("2")
self.ledWinPar2.setObjectName("ledWinPar2")
self.chk_Hf = QCheckBox(self)
self.chk_Hf.setObjectName("chk_Hf")
self.chk_Hf.setToolTip("<span>Show ideal frequency response, calculated "
"from the filter coefficients.</span>")
self.chk_Hf.setChecked(False)
self.chk_Hf_lbl = QLabel(to_html("H_id (f)", frmt="bi"), self)
lbl_show_info_freq = QLabel(to_html("Info", frmt='b'), self)
self.chk_show_info_freq = QCheckBox(self)
self.chk_show_info_freq.setObjectName("chk_show_info_freq")
self.chk_show_info_freq.setToolTip("<span>Show infos about signal power "
"and window properties.</span>")
self.chk_show_info_freq.setChecked(False)
layH_ctrl_freq = QHBoxLayout()
layH_ctrl_freq.addWidget(lbl_plt_freq_title)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(self.lbl_plt_freq_stim)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_stim)
#
layH_ctrl_freq.addWidget(self.lbl_plt_freq_stmq)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_stmq)
#
layH_ctrl_freq.addWidget(lbl_plt_freq_resp)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_resp)
#
layH_ctrl_freq.addWidget(self.chk_Hf_lbl)
layH_ctrl_freq.addWidget(self.chk_Hf)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(lbl_log_freq)
layH_ctrl_freq.addWidget(self.chk_log_freq)
layH_ctrl_freq.addWidget(self.lbl_log_bottom_freq)
layH_ctrl_freq.addWidget(self.led_log_bottom_freq)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(lbl_re_im_freq)
layH_ctrl_freq.addWidget(self.chk_re_im_freq)
layH_ctrl_freq.addStretch(2)
layH_ctrl_freq.addWidget(self.lbl_win_fft)
layH_ctrl_freq.addWidget(self.cmb_win_fft)
layH_ctrl_freq.addWidget(self.cmb_win_fft_variant)
layH_ctrl_freq.addWidget(self.lblWinPar1)
layH_ctrl_freq.addWidget(self.ledWinPar1)
layH_ctrl_freq.addWidget(self.lblWinPar2)
layH_ctrl_freq.addWidget(self.ledWinPar2)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(lbl_show_info_freq)
layH_ctrl_freq.addWidget(self.chk_show_info_freq)
layH_ctrl_freq.addStretch(10)
#layH_ctrl_freq.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_freq = QWidget(self)
self.wdg_ctrl_freq.setLayout(layH_ctrl_freq)
# ---- end Frequency Domain ------------------
# ---------------------------------------------------------------
# Controls for stimuli
# ---------------------------------------------------------------
lbl_title_stim = QLabel("<b>Stimulus:</b>", self)
self.lblStimulus = QLabel(to_html("Type", frmt='bi'), self)
self.cmbStimulus = QComboBox(self)
self.cmbStimulus.addItems(["None","Impulse","Step","StepErr","Cos","Sine", "Chirp",
"Triang","Saw","Rect","Comb","AM","PM / FM","Formula"])
self.cmbStimulus.setToolTip("Stimulus type.")
qset_cmb_box(self.cmbStimulus, self.stim)
self.chk_stim_bl = QCheckBox("BL", self)
self.chk_stim_bl.setToolTip("<span>The signal is bandlimited to the Nyquist frequency "
"to avoid aliasing. However, it is much slower to generate "
"than the regular version.</span>")
self.chk_stim_bl.setChecked(True)
self.chk_stim_bl.setObjectName("stim_bl")
self.cmbChirpMethod = QComboBox(self)
for t in [("Lin","Linear"),("Square","Quadratic"),("Log", "Logarithmic"), ("Hyper", "Hyperbolic")]:
self.cmbChirpMethod.addItem(*t)
qset_cmb_box(self.cmbChirpMethod, self.chirp_method, data=False)
self.chk_scale_impz_f = QCheckBox("Scale", self)
self.chk_scale_impz_f.setToolTip("<span>Scale the FFT of the impulse response with <i>N<sub>FFT</sub></i> "
"so that it has the same magnitude as |H(f)|. DC and Noise need to be "
"turned off.</span>")
self.chk_scale_impz_f.setChecked(True)
self.chk_scale_impz_f.setObjectName("scale_impz_f")
self.lblDC = QLabel(to_html("DC =", frmt='bi'), self)
self.ledDC = QLineEdit(self)
self.ledDC.setText(str(self.DC))
self.ledDC.setToolTip("DC Level")
self.ledDC.setObjectName("stimDC")
layHCmbStim = QHBoxLayout()
layHCmbStim.addWidget(self.cmbStimulus)
layHCmbStim.addWidget(self.chk_stim_bl)
layHCmbStim.addWidget(self.chk_scale_impz_f)
layHCmbStim.addWidget(self.cmbChirpMethod)
#----------------------------------------------
self.lblAmp1 = QLabel(to_html(" A_1", frmt='bi') + " =", self)
self.ledAmp1 = QLineEdit(self)
self.ledAmp1.setText(str(self.A1))
self.ledAmp1.setToolTip("Stimulus amplitude, complex values like 3j - 1 are allowed")
self.ledAmp1.setObjectName("stimAmp1")
self.lblAmp2 = QLabel(to_html(" A_2", frmt='bi') + " =", self)
self.ledAmp2 = QLineEdit(self)
self.ledAmp2.setText(str(self.A2))
self.ledAmp2.setToolTip("Stimulus amplitude 2, complex values like 3j - 1 are allowed")
self.ledAmp2.setObjectName("stimAmp2")
#----------------------------------------------
self.lblPhi1 = QLabel(to_html(" φ_1", frmt='bi') + " =", self)
self.ledPhi1 = QLineEdit(self)
self.ledPhi1.setText(str(self.phi1))
self.ledPhi1.setToolTip("Stimulus phase")
self.ledPhi1.setObjectName("stimPhi1")
self.lblPhU1 = QLabel(to_html("°", frmt='b'), self)
self.lblPhi2 = QLabel(to_html(" φ_2", frmt='bi') + " =", self)
self.ledPhi2 = QLineEdit(self)
self.ledPhi2.setText(str(self.phi2))
self.ledPhi2.setToolTip("Stimulus phase 2")
self.ledPhi2.setObjectName("stimPhi2")
self.lblPhU2 = QLabel(to_html("°", frmt='b'), self)
#----------------------------------------------
self.lblFreq1 = QLabel(to_html(" f_1", frmt='bi') + " =", self)
self.ledFreq1 = QLineEdit(self)
self.ledFreq1.setText(str(self.f1))
self.ledFreq1.setToolTip("Stimulus frequency 1")
self.ledFreq1.setObjectName("stimFreq1")
self.lblFreqUnit1 = QLabel("f_S", self)
self.lblFreq2 = QLabel(to_html(" f_2", frmt='bi') + " =", self)
self.ledFreq2 = QLineEdit(self)
self.ledFreq2.setText(str(self.f2))
self.ledFreq2.setToolTip("Stimulus frequency 2")
self.ledFreq2.setObjectName("stimFreq2")
self.lblFreqUnit2 = QLabel("f_S", self)
#----------------------------------------------
self.lblNoise = QLabel(to_html(" Noise", frmt='bi'), self)
self.cmbNoise = QComboBox(self)
self.cmbNoise.addItems(["None","Gauss","Uniform","PRBS"])
self.cmbNoise.setToolTip("Type of additive noise.")
qset_cmb_box(self.cmbNoise, self.noise)
self.lblNoi = QLabel("not initialized", self)
self.ledNoi = QLineEdit(self)
self.ledNoi.setText(str(self.noi))
self.ledNoi.setToolTip("not initialized")
self.ledNoi.setObjectName("stimNoi")
layGStim = QGridLayout()
layGStim.addWidget(self.lblStimulus, 0, 0)
layGStim.addWidget(self.lblDC, 1, 0)
layGStim.addLayout(layHCmbStim, 0, 1)
layGStim.addWidget(self.ledDC, 1, 1)
layGStim.addWidget(self.lblAmp1, 0, 2)
layGStim.addWidget(self.lblAmp2, 1, 2)
layGStim.addWidget(self.ledAmp1, 0, 3)
layGStim.addWidget(self.ledAmp2, 1, 3)
layGStim.addWidget(self.lblPhi1, 0, 4)
layGStim.addWidget(self.lblPhi2, 1, 4)
layGStim.addWidget(self.ledPhi1, 0, 5)
layGStim.addWidget(self.ledPhi2, 1, 5)
layGStim.addWidget(self.lblPhU1, 0, 6)
layGStim.addWidget(self.lblPhU2, 1, 6)
layGStim.addWidget(self.lblFreq1, 0, 7)
layGStim.addWidget(self.lblFreq2, 1, 7)
layGStim.addWidget(self.ledFreq1, 0, 8)
layGStim.addWidget(self.ledFreq2, 1, 8)
layGStim.addWidget(self.lblFreqUnit1, 0, 9)
layGStim.addWidget(self.lblFreqUnit2, 1, 9)
layGStim.addWidget(self.lblNoise, 0, 10)
layGStim.addWidget(self.lblNoi, 1, 10)
layGStim.addWidget(self.cmbNoise, 0, 11)
layGStim.addWidget(self.ledNoi, 1, 11)
#----------------------------------------------
self.lblStimFormula = QLabel(to_html("x =", frmt='bi'), self)
self.ledStimFormula = QLineEdit(self)
self.ledStimFormula.setText(str(self.stim_formula))
self.ledStimFormula.setToolTip("<span>Enter formula for stimulus in numexpr syntax"
"</span>")
self.ledStimFormula.setObjectName("stimFormula")
layH_ctrl_stim_formula = QHBoxLayout()
layH_ctrl_stim_formula.addWidget(self.lblStimFormula)
layH_ctrl_stim_formula.addWidget(self.ledStimFormula,10)
#----------------------------------------------
#layG_ctrl_stim = QGridLayout()
layH_ctrl_stim_par = QHBoxLayout()
layH_ctrl_stim_par.addLayout(layGStim)
layV_ctrl_stim = QVBoxLayout()
layV_ctrl_stim.addLayout(layH_ctrl_stim_par)
layV_ctrl_stim.addLayout(layH_ctrl_stim_formula)
layH_ctrl_stim = QHBoxLayout()
layH_ctrl_stim.addWidget(lbl_title_stim)
layH_ctrl_stim.addStretch(1)
layH_ctrl_stim.addLayout(layV_ctrl_stim)
layH_ctrl_stim.addStretch(10)
self.wdg_ctrl_stim = QWidget(self)
self.wdg_ctrl_stim.setLayout(layH_ctrl_stim)
# --------- end stimuli ---------------------------------
# frequency widgets require special handling as they are scaled with f_s
self.ledFreq1.installEventFilter(self)
self.ledFreq2.installEventFilter(self)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
# --- run control ---
self.led_N_start.editingFinished.connect(self.update_N)
self.led_N_points.editingFinished.connect(self.update_N)
# --- frequency control ---
# careful! currentIndexChanged passes the current index to _update_win_fft
self.cmb_win_fft.currentIndexChanged.connect(self._update_win_fft)
self.ledWinPar1.editingFinished.connect(self._read_param1)
self.ledWinPar2.editingFinished.connect(self._read_param2)
# --- stimulus control ---
self.chk_stim_options.clicked.connect(self._show_stim_options)
self.chk_stim_bl.clicked.connect(self._enable_stim_widgets)
self.cmbStimulus.currentIndexChanged.connect(self._enable_stim_widgets)
self.cmbNoise.currentIndexChanged.connect(self._update_noi)
self.ledNoi.editingFinished.connect(self._update_noi)
self.ledAmp1.editingFinished.connect(self._update_amp1)
self.ledAmp2.editingFinished.connect(self._update_amp2)
self.ledPhi1.editingFinished.connect(self._update_phi1)
self.ledPhi2.editingFinished.connect(self._update_phi2)
self.cmbChirpMethod.currentIndexChanged.connect(self._update_chirp_method)
self.ledDC.editingFinished.connect(self._update_DC)
self.ledStimFormula.editingFinished.connect(self._update_stim_formula)
def _construct_UI(self):
# ----------- ---------------------------------------------------
# Run control widgets
# ---------------------------------------------------------------
self.chk_auto_run = QCheckBox("Auto", self)
self.chk_auto_run.setObjectName("chk_auto_run")
self.chk_auto_run.setToolTip(
"<span>Update response automatically when "
"parameters have been changed.</span>")
self.chk_auto_run.setChecked(True)
self.but_run = QPushButton(self)
self.but_run.setText("RUN")
self.but_run.setToolTip("Run simulation")
self.but_run.setEnabled(not self.chk_auto_run.isChecked())
self.cmb_sim_select = QComboBox(self)
self.cmb_sim_select.addItems(["Float", "Fixpoint"])
qset_cmb_box(self.cmb_sim_select, "Float")
self.cmb_sim_select.setToolTip(
"<span>Simulate floating-point or fixpoint response."
"</span>")
self.lbl_N_points = QLabel(to_html("N", frmt='bi') + " =", self)
self.led_N_points = QLineEdit(self)
self.led_N_points.setText(str(self.N))
self.led_N_points.setToolTip(
"<span>Number of displayed data points. "
"<i>N</i> = 0 tries to choose for you.</span>")
self.lbl_N_start = QLabel(to_html("N_0", frmt='bi') + " =", self)
self.led_N_start = QLineEdit(self)
self.led_N_start.setText(str(self.N_start))
self.led_N_start.setToolTip("<span>First point to plot.</span>")
self.chk_fx_scale = QCheckBox("Int. scale", self)
self.chk_fx_scale.setObjectName("chk_fx_scale")
self.chk_fx_scale.setToolTip(
"<span>Display data with integer (fixpoint) scale.</span>")
self.chk_fx_scale.setChecked(False)
self.chk_stim_options = QCheckBox("Stim. Options", self)
self.chk_stim_options.setObjectName("chk_stim_options")
self.chk_stim_options.setToolTip("<span>Show stimulus options.</span>")
self.chk_stim_options.setChecked(True)
self.but_fft_win = QPushButton(self)
self.but_fft_win.setText("WIN FFT")
self.but_fft_win.setToolTip(
"Show time and frequency response of FFT Window")
self.but_fft_win.setCheckable(True)
self.but_fft_win.setChecked(False)
layH_ctrl_run = QHBoxLayout()
layH_ctrl_run.addWidget(self.but_run)
#layH_ctrl_run.addWidget(self.lbl_sim_select)
layH_ctrl_run.addWidget(self.cmb_sim_select)
layH_ctrl_run.addWidget(self.chk_auto_run)
layH_ctrl_run.addStretch(1)
layH_ctrl_run.addWidget(self.lbl_N_start)
layH_ctrl_run.addWidget(self.led_N_start)
layH_ctrl_run.addStretch(1)
layH_ctrl_run.addWidget(self.lbl_N_points)
layH_ctrl_run.addWidget(self.led_N_points)
layH_ctrl_run.addStretch(2)
layH_ctrl_run.addWidget(self.chk_fx_scale)
layH_ctrl_run.addStretch(2)
layH_ctrl_run.addWidget(self.chk_stim_options)
layH_ctrl_run.addStretch(2)
layH_ctrl_run.addWidget(self.but_fft_win)
layH_ctrl_run.addStretch(10)
#layH_ctrl_run.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_run = QWidget(self)
self.wdg_ctrl_run.setLayout(layH_ctrl_run)
# --- end of run control ----------------------------------------
# ----------- ---------------------------------------------------
# Controls for time domain
# ---------------------------------------------------------------
plot_styles_list = [
"None", "Dots", "Line", "Line*", "Stem", "Stem*", "Step", "Step*"
]
lbl_plt_time_title = QLabel("<b>View:</b>", self)
lbl_plt_time_resp = QLabel("Response " + to_html("y", frmt='bi'), self)
self.cmb_plt_time_resp = QComboBox(self)
self.cmb_plt_time_resp.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_time_resp, self.plt_time_resp)
self.cmb_plt_time_resp.setToolTip(
"<span>Plot style for response.</span>")
self.lbl_plt_time_stim = QLabel("Stimulus " + to_html("x", frmt='bi'),
self)
self.cmb_plt_time_stim = QComboBox(self)
self.cmb_plt_time_stim.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_time_stim, self.plt_time_stim)
self.cmb_plt_time_stim.setToolTip(
"<span>Plot style for stimulus.</span>")
self.lbl_plt_time_stmq = QLabel(
"Fixp. Stim. " + to_html("x_Q", frmt='bi'), self)
self.cmb_plt_time_stmq = QComboBox(self)
self.cmb_plt_time_stmq.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_time_stmq, self.plt_time_stmq)
self.cmb_plt_time_stmq.setToolTip(
"<span>Plot style for <em>fixpoint</em> (quantized) stimulus.</span>"
)
self.chk_log_time = QCheckBox("dB : min.", self)
self.chk_log_time.setObjectName("chk_log_time")
self.chk_log_time.setToolTip(
"<span>Logarithmic scale for y-axis.</span>")
self.chk_log_time.setChecked(False)
self.led_log_bottom_time = QLineEdit(self)
self.led_log_bottom_time.setText(str(self.bottom_t))
self.led_log_bottom_time.setToolTip(
"<span>Minimum display value for log. scale.</span>")
self.led_log_bottom_time.setVisible(self.chk_log_time.isChecked())
if not self.chk_log_time.isChecked():
self.chk_log_time.setText("dB")
self.bottom_t = 0
self.chk_win_time = QCheckBox("FFT Window", self)
self.chk_win_time.setObjectName("chk_win_time")
self.chk_win_time.setToolTip(
"<span>Show FFT windowing function.</span>")
self.chk_win_time.setChecked(False)
self.chk_fx_limits = QCheckBox("Min/max.", self)
self.chk_fx_limits.setObjectName("chk_fx_limits")
self.chk_fx_limits.setToolTip(
"<span>Display limits of fixpoint range.</span>")
self.chk_fx_limits.setChecked(False)
layH_ctrl_time = QHBoxLayout()
layH_ctrl_time.addWidget(lbl_plt_time_title)
layH_ctrl_time.addStretch(1)
layH_ctrl_time.addWidget(lbl_plt_time_resp)
layH_ctrl_time.addWidget(self.cmb_plt_time_resp)
layH_ctrl_time.addStretch(1)
layH_ctrl_time.addWidget(self.lbl_plt_time_stim)
layH_ctrl_time.addWidget(self.cmb_plt_time_stim)
layH_ctrl_time.addStretch(1)
layH_ctrl_time.addWidget(self.lbl_plt_time_stmq)
layH_ctrl_time.addWidget(self.cmb_plt_time_stmq)
layH_ctrl_time.addStretch(2)
layH_ctrl_time.addWidget(self.chk_log_time)
layH_ctrl_time.addWidget(self.led_log_bottom_time)
layH_ctrl_time.addStretch(1)
layH_ctrl_time.addWidget(self.chk_win_time)
layH_ctrl_time.addStretch(2)
layH_ctrl_time.addWidget(self.chk_fx_limits)
layH_ctrl_time.addStretch(10)
#layH_ctrl_time.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_time = QWidget(self)
self.wdg_ctrl_time.setLayout(layH_ctrl_time)
# ---- end time domain ------------------
# ---------------------------------------------------------------
# Controls for frequency domain
# ---------------------------------------------------------------
lbl_plt_freq_title = QLabel("<b>View:</b>", self)
lbl_plt_freq_resp = QLabel("Response " + to_html("Y", frmt='bi'), self)
self.cmb_plt_freq_resp = QComboBox(self)
self.cmb_plt_freq_resp.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_freq_resp, self.plt_freq_resp)
self.cmb_plt_freq_resp.setToolTip(
"<span>Plot style for response.</span>")
self.lbl_plt_freq_stim = QLabel("Stimulus " + to_html("X", frmt='bi'),
self)
self.cmb_plt_freq_stim = QComboBox(self)
self.cmb_plt_freq_stim.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_freq_stim, self.plt_freq_stim)
self.cmb_plt_freq_stim.setToolTip(
"<span>Plot style for stimulus.</span>")
self.lbl_plt_freq_stmq = QLabel(
"Fixp. Stim. " + to_html("X_Q", frmt='bi'), self)
self.cmb_plt_freq_stmq = QComboBox(self)
self.cmb_plt_freq_stmq.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_freq_stmq, self.plt_freq_stmq)
self.cmb_plt_freq_stmq.setToolTip(
"<span>Plot style for <em>fixpoint</em> (quantized) stimulus.</span>"
)
self.chk_log_freq = QCheckBox("dB : min.", self)
self.chk_log_freq.setObjectName("chk_log_freq")
self.chk_log_freq.setToolTip(
"<span>Logarithmic scale for y-axis.</span>")
self.chk_log_freq.setChecked(True)
self.led_log_bottom_freq = QLineEdit(self)
self.led_log_bottom_freq.setText(str(self.bottom_f))
self.led_log_bottom_freq.setToolTip(
"<span>Minimum display value for log. scale.</span>")
self.led_log_bottom_freq.setVisible(self.chk_log_freq.isChecked())
if not self.chk_log_freq.isChecked():
self.chk_log_freq.setText("dB")
self.bottom_f = 0
self.lbl_win_fft = QLabel("Window: ", self)
self.cmb_win_fft = QComboBox(self)
self.cmb_win_fft.addItems(get_window_names())
self.cmb_win_fft.setToolTip("FFT window type.")
qset_cmb_box(self.cmb_win_fft, self.window_name)
self.cmb_win_fft_variant = QComboBox(self)
self.cmb_win_fft_variant.setToolTip("FFT window variant.")
self.cmb_win_fft_variant.setVisible(False)
self.lblWinPar1 = QLabel("Param1")
self.ledWinPar1 = QLineEdit(self)
self.ledWinPar1.setText("1")
self.ledWinPar1.setObjectName("ledWinPar1")
self.lblWinPar2 = QLabel("Param2")
self.ledWinPar2 = QLineEdit(self)
self.ledWinPar2.setText("2")
self.ledWinPar2.setObjectName("ledWinPar2")
self.chk_Hf = QCheckBox(self)
self.chk_Hf.setObjectName("chk_Hf")
self.chk_Hf.setToolTip(
"<span>Show ideal frequency response, calculated "
"from the filter coefficients.</span>")
self.chk_Hf.setChecked(False)
self.chk_Hf_lbl = QLabel(to_html("H_id (f)", frmt="bi"), self)
layH_ctrl_freq = QHBoxLayout()
layH_ctrl_freq.addWidget(lbl_plt_freq_title)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(lbl_plt_freq_resp)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_resp)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(self.lbl_plt_freq_stim)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_stim)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(self.lbl_plt_freq_stmq)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_stmq)
layH_ctrl_freq.addStretch(2)
layH_ctrl_freq.addWidget(self.chk_log_freq)
layH_ctrl_freq.addWidget(self.led_log_bottom_freq)
layH_ctrl_freq.addStretch(2)
layH_ctrl_freq.addWidget(self.lbl_win_fft)
layH_ctrl_freq.addWidget(self.cmb_win_fft)
layH_ctrl_freq.addWidget(self.cmb_win_fft_variant)
layH_ctrl_freq.addWidget(self.lblWinPar1)
layH_ctrl_freq.addWidget(self.ledWinPar1)
layH_ctrl_freq.addWidget(self.lblWinPar2)
layH_ctrl_freq.addWidget(self.ledWinPar2)
layH_ctrl_freq.addStretch(2)
layH_ctrl_freq.addWidget(self.chk_Hf)
layH_ctrl_freq.addWidget(self.chk_Hf_lbl)
layH_ctrl_freq.addStretch(10)
#layH_ctrl_freq.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_freq = QWidget(self)
self.wdg_ctrl_freq.setLayout(layH_ctrl_freq)
# ---- end Frequency Domain ------------------
# ---------------------------------------------------------------
# Controls for stimuli
# ---------------------------------------------------------------
lbl_title_stim = QLabel("<b>Stimulus:</b>", self)
self.lblStimulus = QLabel(to_html("Shape ", frmt='bi'), self)
self.cmbStimulus = QComboBox(self)
self.cmbStimulus.addItems([
"None", "Pulse", "Step", "StepErr", "Cos", "Sine", "Triang", "Saw",
"Rect", "Comb", "AM", "FM", "PM"
])
self.cmbStimulus.setToolTip("Stimulus type.")
qset_cmb_box(self.cmbStimulus, self.stim)
self.chk_stim_bl = QCheckBox("BL", self)
self.chk_stim_bl.setToolTip(
"<span>The signal is bandlimited to the Nyquist frequency "
"to avoid aliasing. However, it is much slower to generate "
"than the regular version.</span>")
self.chk_stim_bl.setChecked(True)
self.chk_stim_bl.setObjectName("stim_bl")
self.chk_scale_impz_f = QCheckBox("Scale", self)
self.chk_scale_impz_f.setToolTip(
"<span>Scale the FFT of the impulse response with <i>N<sub>FFT</sub></i> "
"so that it has the same magnitude as |H(f)|. DC and Noise need to be "
"turned off.</span>")
self.chk_scale_impz_f.setChecked(True)
self.chk_scale_impz_f.setObjectName("scale_impz_f")
self.lblDC = QLabel(to_html("DC =", frmt='bi'), self)
self.ledDC = QLineEdit(self)
self.ledDC.setText(str(self.DC))
self.ledDC.setToolTip("DC Level")
self.ledDC.setObjectName("stimDC")
layHCmbStim = QHBoxLayout()
layHCmbStim.addWidget(self.cmbStimulus)
layHCmbStim.addWidget(self.chk_stim_bl)
layHCmbStim.addWidget(self.chk_scale_impz_f)
layVlblCmbDC = QVBoxLayout()
layVlblCmbDC.addWidget(self.lblStimulus)
layVlblCmbDC.addWidget(self.lblDC)
#layVlblAmp.setAlignment(Qt.AlignTop)
layVCmbDC = QVBoxLayout()
layVCmbDC.addLayout(layHCmbStim)
layVCmbDC.addWidget(self.ledDC)
#----------------------------------------------
self.lblAmp1 = QLabel(to_html("A_1", frmt='bi') + " =", self)
self.ledAmp1 = QLineEdit(self)
self.ledAmp1.setText(str(self.A1))
self.ledAmp1.setToolTip("Stimulus amplitude")
self.ledAmp1.setObjectName("stimAmp1")
self.lblAmp2 = QLabel(to_html("A_2", frmt='bi') + " =", self)
self.ledAmp2 = QLineEdit(self)
self.ledAmp2.setText(str(self.A2))
self.ledAmp2.setToolTip("Stimulus amplitude 2")
self.ledAmp2.setObjectName("stimAmp2")
layVlblAmp = QVBoxLayout()
layVlblAmp.addWidget(self.lblAmp1)
layVlblAmp.addWidget(self.lblAmp2)
#layVlblAmp.setAlignment(Qt.AlignTop) # labels are aligned incorrectly
layVledAmp = QVBoxLayout()
layVledAmp.addWidget(self.ledAmp1)
layVledAmp.addWidget(self.ledAmp2)
#layVledAmp.setAlignment(Qt.AlignTop)
#----------------------------------------------
self.lblPhi1 = QLabel(to_html("φ_1", frmt='bi') + " =", self)
self.ledPhi1 = QLineEdit(self)
self.ledPhi1.setText(str(self.phi1))
self.ledPhi1.setToolTip("Stimulus phase")
self.ledPhi1.setObjectName("stimPhi1")
self.lblPhU1 = QLabel(to_html("°", frmt='b'), self)
self.lblPhi2 = QLabel(to_html("φ_2", frmt='bi') + " =", self)
self.ledPhi2 = QLineEdit(self)
self.ledPhi2.setText(str(self.phi2))
self.ledPhi2.setToolTip("Stimulus phase 2")
self.ledPhi2.setObjectName("stimPhi2")
self.lblPhU2 = QLabel(to_html("°", frmt='b'), self)
layVlblPhi = QVBoxLayout()
layVlblPhi.addWidget(self.lblPhi1)
layVlblPhi.addWidget(self.lblPhi2)
layVledPhi = QVBoxLayout()
layVledPhi.addWidget(self.ledPhi1)
layVledPhi.addWidget(self.ledPhi2)
layVlblPhU = QVBoxLayout()
layVlblPhU.addWidget(self.lblPhU1)
layVlblPhU.addWidget(self.lblPhU2)
#----------------------------------------------
self.lblFreq1 = QLabel(to_html("f_1", frmt='bi') + " =", self)
self.ledFreq1 = QLineEdit(self)
self.ledFreq1.setText(str(self.f1))
self.ledFreq1.setToolTip("Stimulus frequency 1")
self.ledFreq1.setObjectName("stimFreq1")
self.lblFreqUnit1 = QLabel("f_S", self)
self.lblFreq2 = QLabel(to_html("f_2", frmt='bi') + " =", self)
self.ledFreq2 = QLineEdit(self)
self.ledFreq2.setText(str(self.f2))
self.ledFreq2.setToolTip("Stimulus frequency 2")
self.ledFreq2.setObjectName("stimFreq2")
self.lblFreqUnit2 = QLabel("f_S", self)
layVlblfreq = QVBoxLayout()
layVlblfreq.addWidget(self.lblFreq1)
layVlblfreq.addWidget(self.lblFreq2)
layVledfreq = QVBoxLayout()
layVledfreq.addWidget(self.ledFreq1)
layVledfreq.addWidget(self.ledFreq2)
layVlblfreqU = QVBoxLayout()
layVlblfreqU.addWidget(self.lblFreqUnit1)
layVlblfreqU.addWidget(self.lblFreqUnit2)
#----------------------------------------------
self.lblNoise = QLabel(to_html("Noise: ", frmt='bi'), self)
self.cmbNoise = QComboBox(self)
self.cmbNoise.addItems(["None", "Gauss", "Uniform", "PRBS"])
self.cmbNoise.setToolTip("Type of additive noise.")
qset_cmb_box(self.cmbNoise, self.noise)
self.lblNoi = QLabel("not initialized", self)
self.ledNoi = QLineEdit(self)
self.ledNoi.setText(str(self.noi))
self.ledNoi.setToolTip("not initialized")
self.ledNoi.setObjectName("stimNoi")
layVlblNoi = QVBoxLayout()
layVlblNoi.addWidget(self.lblNoise)
layVlblNoi.addWidget(self.lblNoi)
layVcmbledNoi = QVBoxLayout()
layVcmbledNoi.addWidget(self.cmbNoise)
layVcmbledNoi.addWidget(self.ledNoi)
#----------------------------------------------
#layG_ctrl_stim = QGridLayout()
layH_ctrl_stim = QHBoxLayout()
layH_ctrl_stim.addWidget(lbl_title_stim)
layH_ctrl_stim.addStretch(1)
layH_ctrl_stim.addLayout(layVlblCmbDC)
layH_ctrl_stim.addLayout(layVCmbDC)
layH_ctrl_stim.addStretch(1)
layH_ctrl_stim.addLayout(layVlblAmp)
layH_ctrl_stim.addLayout(layVledAmp)
layH_ctrl_stim.addLayout(layVlblPhi)
layH_ctrl_stim.addLayout(layVledPhi)
layH_ctrl_stim.addLayout(layVlblPhU)
layH_ctrl_stim.addStretch(1)
layH_ctrl_stim.addLayout(layVlblfreq)
layH_ctrl_stim.addLayout(layVledfreq)
layH_ctrl_stim.addLayout(layVlblfreqU)
layH_ctrl_stim.addStretch(1)
layH_ctrl_stim.addLayout(layVlblNoi)
layH_ctrl_stim.addLayout(layVcmbledNoi)
layH_ctrl_stim.addStretch(10)
self.wdg_ctrl_stim = QWidget(self)
self.wdg_ctrl_stim.setLayout(layH_ctrl_stim)
# --------- end stimuli ---------------------------------
# frequency widgets require special handling as they are scaled with f_s
self.ledFreq1.installEventFilter(self)
self.ledFreq2.installEventFilter(self)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
# --- run control ---
self.led_N_start.editingFinished.connect(self.update_N)
self.led_N_points.editingFinished.connect(self.update_N)
# --- frequency control ---
# careful! currentIndexChanged passes the current index to _update_win_fft
self.cmb_win_fft.currentIndexChanged.connect(self._update_win_fft)
self.ledWinPar1.editingFinished.connect(self._read_param1)
self.ledWinPar2.editingFinished.connect(self._read_param2)
# --- stimulus control ---
self.chk_stim_options.clicked.connect(self._show_stim_options)
self.chk_stim_bl.clicked.connect(self._enable_stim_widgets)
self.cmbStimulus.currentIndexChanged.connect(self._enable_stim_widgets)
self.cmbNoise.currentIndexChanged.connect(self._update_noi)
self.ledNoi.editingFinished.connect(self._update_noi)
self.ledAmp1.editingFinished.connect(self._update_amp1)
self.ledAmp2.editingFinished.connect(self._update_amp2)
self.ledPhi1.editingFinished.connect(self._update_phi1)
self.ledPhi2.editingFinished.connect(self._update_phi2)
self.ledDC.editingFinished.connect(self._update_DC)
def _construct_UI(self):
"""
Construct UI with comboboxes for selecting filter:
- cmbResponseType for selecting response type rt (LP, HP, ...)
- cmbFilterType for selection of filter type (IIR, FIR, ...)
- cmbFilterClass for selection of design design class (Chebyshev, ...)
and populate them from the "filterTree" dict during the initial run.
Later, calling _set_response_type() updates the three combo boxes.
See filterbroker.py for structure and content of "filterTree" dict
"""
# ----------------------------------------------------------------------
# Combo boxes for filter selection
# ----------------------------------------------------------------------
self.cmbResponseType = QComboBox(self)
self.cmbResponseType.setObjectName("comboResponseType")
self.cmbResponseType.setToolTip("Select filter response type.")
self.cmbFilterType = QComboBox(self)
self.cmbFilterType.setObjectName("comboFilterType")
self.cmbFilterType.setToolTip(
"<span>Choose filter type, either recursive (Infinite Impulse Response) "
"or transversal (Finite Impulse Response).</span>")
self.cmbFilterClass = QComboBox(self)
self.cmbFilterClass.setObjectName("comboFilterClass")
self.cmbFilterClass.setToolTip("Select the filter design class.")
# Adapt comboboxes size dynamically to largest element
self.cmbResponseType.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmbFilterType.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmbFilterClass.setSizeAdjustPolicy(QComboBox.AdjustToContents)
# ----------------------------------------------------------------------
# Populate combo box with initial settings from fb.fil_tree
# ----------------------------------------------------------------------
# Translate short response type ("LP") to displayed names ("Lowpass")
# (correspondence is defined in pyfda_rc.py) and populate rt combo box
#
rt_list = sorted(list(fb.fil_tree.keys()))
for rt in rt_list:
try:
self.cmbResponseType.addItem(rc.rt_names[rt], rt)
except KeyError as e:
logger.warning(
f"KeyError: {e} has no corresponding full name in rc.rt_names."
)
idx = self.cmbResponseType.findData('LP') # find index for 'LP'
if idx == -1: # Key 'LP' does not exist, use first entry instead
idx = 0
self.cmbResponseType.setCurrentIndex(idx) # set initial index
rt = qget_cmb_box(self.cmbResponseType)
for ft in fb.fil_tree[rt]:
self.cmbFilterType.addItem(rc.ft_names[ft], ft)
self.cmbFilterType.setCurrentIndex(0) # set initial index
ft = qget_cmb_box(self.cmbFilterType)
for fc in fb.fil_tree[rt][ft]:
self.cmbFilterClass.addItem(fb.filter_classes[fc]['name'], fc)
self.cmbFilterClass.setCurrentIndex(0) # set initial index
# ----------------------------------------------------------------------
# Layout for Filter Type Subwidgets
# ----------------------------------------------------------------------
layHFilWdg = QHBoxLayout() # container for filter subwidgets
layHFilWdg.addWidget(self.cmbResponseType) # LP, HP, BP, etc.
layHFilWdg.addStretch()
layHFilWdg.addWidget(self.cmbFilterType) # FIR, IIR
layHFilWdg.addStretch()
layHFilWdg.addWidget(self.cmbFilterClass) # bessel, elliptic, etc.
# ----------------------------------------------------------------------
# Layout for dynamic filter subwidgets (empty frame)
# ----------------------------------------------------------------------
# see Summerfield p. 278
self.layHDynWdg = QHBoxLayout() # for additional dynamic subwidgets
# ----------------------------------------------------------------------
# Filter Order Subwidgets
# ----------------------------------------------------------------------
self.lblOrder = QLabel("<b>Order:</b>")
self.chkMinOrder = QCheckBox("Minimum", self)
self.chkMinOrder.setToolTip(
"<span>Minimum filter order / # of taps is determined automatically.</span>"
)
self.lblOrderN = QLabel("<b><i>N =</i></b>")
self.ledOrderN = QLineEdit(str(fb.fil[0]['N']), self)
self.ledOrderN.setToolTip("Filter order (# of taps - 1).")
# --------------------------------------------------
# Layout for filter order subwidgets
# --------------------------------------------------
layHOrdWdg = QHBoxLayout()
layHOrdWdg.addWidget(self.lblOrder)
layHOrdWdg.addWidget(self.chkMinOrder)
layHOrdWdg.addStretch()
layHOrdWdg.addWidget(self.lblOrderN)
layHOrdWdg.addWidget(self.ledOrderN)
# ----------------------------------------------------------------------
# OVERALL LAYOUT (stack standard + dynamic subwidgets vertically)
# ----------------------------------------------------------------------
self.layVAllWdg = QVBoxLayout()
self.layVAllWdg.addLayout(layHFilWdg)
self.layVAllWdg.addLayout(self.layHDynWdg)
self.layVAllWdg.addLayout(layHOrdWdg)
# ==============================================================================
frmMain = QFrame(self)
frmMain.setLayout(self.layVAllWdg)
layHMain = QHBoxLayout()
layHMain.addWidget(frmMain)
layHMain.setContentsMargins(*rc.params['wdg_margins'])
self.setLayout(layHMain)
# ==============================================================================
# ------------------------------------------------------------
# SIGNALS & SLOTS
# ------------------------------------------------------------
# Connect comboBoxes and setters, propgate change events hierarchically
# through all widget methods and emit 'filt_changed' in the end.
self.cmbResponseType.currentIndexChanged.connect(
lambda: self._set_response_type(enb_signal=True)) # 'LP'
self.cmbFilterType.currentIndexChanged.connect(
lambda: self._set_filter_type(enb_signal=True)) # 'IIR'
self.cmbFilterClass.currentIndexChanged.connect(
lambda: self._set_design_method(enb_signal=True)) # 'cheby1'
self.chkMinOrder.clicked.connect(
lambda: self._set_filter_order(enb_signal=True)) # Min. Order
self.ledOrderN.editingFinished.connect(
lambda: self._set_filter_order(enb_signal=True)) # Manual Order
def _construct_ui(self):
"""
Define and construct the subwidgets
"""
modes = ['| H |', 're{H}', 'im{H}']
self.cmbShowH = QComboBox(self)
self.cmbShowH.addItems(modes)
self.cmbShowH.setObjectName("cmbUnitsH")
self.cmbShowH.setToolTip("Show magnitude, real / imag. part of H or H \n"
"without linear phase (acausal system).")
self.cmbShowH.setCurrentIndex(0)
self.lblIn = QLabel(to_html("Unit:", frmt="b"), self)
self.cmb_units_a = QComboBox(self)
qcmb_box_populate(self.cmb_units_a, self.cmb_units_a_items,
self.cmb_units_a_default)
self.cmb_units_a.setObjectName("cmbUnitsA")
self.lbl_log_bottom = QLabel(to_html("min =", 'bi'), self)
self.led_log_bottom = QLineEdit(self)
self.led_log_bottom.setText(str(self.log_bottom))
self.led_log_bottom.setMaximumWidth(qtext_width(N_x=8))
self.led_log_bottom.setToolTip(
"<span>Minimum display value for dB. scale.</span>")
self.lbl_log_unit = QLabel("dB", self)
self.cmbShowH.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmb_units_a.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.but_zerophase = PushButton(" Zero phase ", checked=False)
self.but_zerophase.setToolTip(
"<span>Remove linear phase calculated from filter order.\n"
"Attention: This makes no sense for a non-linear phase system!</span>")
self.lblInset = QLabel(to_html("Inset", "bi"), self)
self.cmbInset = QComboBox(self)
self.cmbInset.addItems(['off', 'edit', 'fixed'])
self.cmbInset.setObjectName("cmbInset")
self.cmbInset.setToolTip("Display/edit second inset plot")
self.cmbInset.setCurrentIndex(0)
self.inset_idx = 0 # store previous index for comparison
self.but_specs = PushButton("Specs ", checked=False)
self.but_specs.setToolTip("Display filter specs as hatched regions")
self.but_phase = PushButton("Phase ", checked=False)
self.but_phase.setToolTip("Overlay phase")
self.but_align = PushButton("Align", checked=True)
self.but_align.setToolTip(
"<span>Try to align gridlines for magnitude and phase "
"(doesn't work in all cases).</span>")
self.but_align.setVisible(self.but_phase.isChecked())
# ----------------------------------------------------------------------
# ### frmControls ###
#
# This widget encompasses all control subwidgets
# ----------------------------------------------------------------------
layHControls = QHBoxLayout()
layHControls.addWidget(self.cmbShowH)
layHControls.addWidget(self.lblIn)
layHControls.addWidget(self.cmb_units_a)
layHControls.addStretch(1)
layHControls.addWidget(self.lbl_log_bottom)
layHControls.addWidget(self.led_log_bottom)
layHControls.addWidget(self.lbl_log_unit)
layHControls.addStretch(1)
layHControls.addWidget(self.but_zerophase)
layHControls.addStretch(1)
layHControls.addWidget(self.lblInset)
layHControls.addWidget(self.cmbInset)
layHControls.addStretch(1)
layHControls.addWidget(self.but_specs)
layHControls.addStretch(1)
layHControls.addWidget(self.but_phase)
layHControls.addWidget(self.but_align)
layHControls.addStretch(10)
self.frmControls = QFrame(self)
self.frmControls.setObjectName("frmControls")
self.frmControls.setLayout(layHControls)
# ----------------------------------------------------------------------
# ### mplwidget ###
#
# main widget, encompassing the other widgets
# ----------------------------------------------------------------------
self.mplwidget = MplWidget(self)
self.mplwidget.layVMainMpl.addWidget(self.frmControls)
self.mplwidget.layVMainMpl.setContentsMargins(*params['mpl_margins'])
self.mplwidget.mplToolbar.a_he.setEnabled(True)
self.mplwidget.mplToolbar.a_he.info = "manual/plot_hf.html"
self.setLayout(self.mplwidget.layVMainMpl)
self.init_axes()
self.draw() # calculate and draw |H(f)|
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.cmb_units_a.currentIndexChanged.connect(self.draw)
self.led_log_bottom.editingFinished.connect(self.update_view)
self.cmbShowH.currentIndexChanged.connect(self.draw)
self.but_zerophase.clicked.connect(self.draw)
self.cmbInset.currentIndexChanged.connect(self.draw_inset)
self.but_specs.clicked.connect(self.draw)
self.but_phase.clicked.connect(self.draw)
self.but_align.clicked.connect(self.draw)
self.mplwidget.mplToolbar.sig_tx.connect(self.process_sig_rx)
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- Matplotlib widget with NavigationToolbar
- Frame with control elements
"""
self.bfont = QFont()
self.bfont.setBold(True)
self.chk_auto_N = QCheckBox(self)
self.chk_auto_N.setChecked(False)
self.chk_auto_N.setToolTip(
"Use number of points from calling routine.")
self.lbl_auto_N = QLabel("Auto " + to_html("N", frmt='i'))
self.led_N = QLineEdit(self)
self.led_N.setText(str(self.N))
self.led_N.setMaximumWidth(70)
self.led_N.setToolTip("<span>Number of window data points.</span>")
self.chk_log_t = QCheckBox("Log", self)
self.chk_log_t.setChecked(False)
self.chk_log_t.setToolTip("Display in dB")
self.led_log_bottom_t = QLineEdit(self)
self.led_log_bottom_t.setText(str(self.bottom_t))
self.led_log_bottom_t.setMaximumWidth(50)
self.led_log_bottom_t.setEnabled(self.chk_log_t.isChecked())
self.led_log_bottom_t.setToolTip(
"<span>Minimum display value for log. scale.</span>")
self.lbl_log_bottom_t = QLabel("dB", self)
self.lbl_log_bottom_t.setEnabled(self.chk_log_t.isChecked())
self.chk_norm_f = QCheckBox("Norm", self)
self.chk_norm_f.setChecked(True)
self.chk_norm_f.setToolTip(
"Normalize window spectrum for a maximum of 1.")
self.chk_half_f = QCheckBox("Half", self)
self.chk_half_f.setChecked(True)
self.chk_half_f.setToolTip(
"Display window spectrum in the range 0 ... 0.5 f_S.")
self.chk_log_f = QCheckBox("Log", self)
self.chk_log_f.setChecked(True)
self.chk_log_f.setToolTip("Display in dB")
self.led_log_bottom_f = QLineEdit(self)
self.led_log_bottom_f.setText(str(self.bottom_f))
self.led_log_bottom_f.setMaximumWidth(50)
self.led_log_bottom_f.setEnabled(self.chk_log_f.isChecked())
self.led_log_bottom_f.setToolTip(
"<span>Minimum display value for log. scale.</span>")
self.lbl_log_bottom_f = QLabel("dB", self)
self.lbl_log_bottom_f.setEnabled(self.chk_log_f.isChecked())
layHControls = QHBoxLayout()
layHControls.addWidget(self.chk_auto_N)
layHControls.addWidget(self.lbl_auto_N)
layHControls.addWidget(self.led_N)
layHControls.addStretch(1)
layHControls.addWidget(self.chk_log_t)
layHControls.addWidget(self.led_log_bottom_t)
layHControls.addWidget(self.lbl_log_bottom_t)
layHControls.addStretch(10)
layHControls.addWidget(self.chk_norm_f)
layHControls.addStretch(1)
layHControls.addWidget(self.chk_half_f)
layHControls.addStretch(1)
layHControls.addWidget(self.chk_log_f)
layHControls.addWidget(self.led_log_bottom_f)
layHControls.addWidget(self.lbl_log_bottom_f)
self.tblWinProperties = QTableWidget(self.tbl_rows, self.tbl_cols,
self)
self.tblWinProperties.setAlternatingRowColors(True)
self.tblWinProperties.verticalHeader().setVisible(False)
self.tblWinProperties.horizontalHeader().setVisible(False)
self._init_table(self.tbl_rows, self.tbl_cols, " ")
self.txtInfoBox = QTextBrowser(self)
#----------------------------------------------------------------------
# ### frmControls ###
#
# This widget encompasses all control subwidgets
#----------------------------------------------------------------------
self.frmControls = QFrame(self)
self.frmControls.setObjectName("frmControls")
self.frmControls.setLayout(layHControls)
#----------------------------------------------------------------------
# ### mplwidget ###
#
# main widget: Layout layVMainMpl (VBox) is defined with MplWidget,
# additional widgets can be added (like self.frmControls)
# The widget encompasses all other widgets.
#----------------------------------------------------------------------
self.mplwidget = MplWidget(self)
self.mplwidget.layVMainMpl.addWidget(self.frmControls)
self.mplwidget.layVMainMpl.setContentsMargins(*params['wdg_margins'])
#----------------------------------------------------------------------
# ### frmInfo ###
#
# This widget encompasses the text info box and the table with window
# parameters.
#----------------------------------------------------------------------
layVInfo = QVBoxLayout(self)
layVInfo.addWidget(self.tblWinProperties)
layVInfo.addWidget(self.txtInfoBox)
self.frmInfo = QFrame(self)
self.frmInfo.setObjectName("frmInfo")
self.frmInfo.setLayout(layVInfo)
#----------------------------------------------------------------------
# ### splitter ###
#
# This widget encompasses all control subwidgets
#----------------------------------------------------------------------
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
splitter.addWidget(self.mplwidget)
splitter.addWidget(self.frmInfo)
# setSizes uses absolute pixel values, but can be "misused" by specifying values
# that are way too large: in this case, the space is distributed according
# to the _ratio_ of the values:
splitter.setSizes([3000, 1000])
layVMain = QVBoxLayout()
layVMain.addWidget(splitter)
self.setLayout(layVMain)
#----------------------------------------------------------------------
# Set subplots
#
self.ax = self.mplwidget.fig.subplots(nrows=1, ncols=2)
self.ax_t = self.ax[0]
self.ax_f = self.ax[1]
self.draw() # initial drawing
#----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.chk_log_f.clicked.connect(self.update_view)
self.chk_log_t.clicked.connect(self.update_view)
self.led_log_bottom_t.editingFinished.connect(self.update_bottom)
self.led_log_bottom_f.editingFinished.connect(self.update_bottom)
self.chk_auto_N.clicked.connect(self.calc_N)
self.led_N.editingFinished.connect(self.draw)
self.chk_norm_f.clicked.connect(self.draw)
self.chk_half_f.clicked.connect(self.update_view)
self.mplwidget.mplToolbar.sig_tx.connect(self.process_sig_rx)
self.tblWinProperties.itemClicked.connect(self._handle_item_clicked)
class MA(QWidget):
FRMT = (
'zpk', 'ba'
) # output format(s) of filter design routines 'zpk' / 'ba' / 'sos'
info = """
**Moving average filters**
can only be specified via their length and the number of cascaded sections.
The minimum order to obtain a certain attenuation at a given frequency is
calculated via the si function.
Moving average filters can be implemented very efficiently in hard- and software
as they require no multiplications but only addition and subtractions. Probably
only the lowpass is really useful, as the other response types only filter out resp.
leave components at ``f_S/4`` (bandstop resp. bandpass) resp. leave components
near ``f_S/2`` (highpass).
**Design routines:**
``ma.calc_ma()``
"""
sig_tx = pyqtSignal(object)
from pyfda.libs.pyfda_qt_lib import emit
def __init__(self):
QWidget.__init__(self)
self.delays = 12 # number of delays per stage
self.stages = 1 # number of stages
self.ft = 'FIR'
self.rt_dicts = ()
# Common data for all filter response types:
# This data is merged with the entries for individual response types
# (common data comes first):
self.rt_dict = {
'COM': {
'man': {
'fo': ('d', 'N'),
'msg':
('a',
"Enter desired order (= delays) <b><i>M</i></b> per stage and"
" the number of <b>stages</b>. Target frequencies and amplitudes"
" are only used for comparison, not for the design itself."
)
},
'min': {
'fo': ('d', 'N'),
'msg':
('a',
"Enter desired attenuation <b><i>A<sub>SB</sub></i></b> at "
"the corner of the stop band <b><i>F<sub>SB</sub></i></b>. "
"Choose the number of <b>stages</b>, the minimum order <b><i>M</i></b> "
"per stage will be determined. Passband specs are not regarded."
)
}
},
'LP': {
'man': {
'tspecs': ('u', {
'frq': ('u', 'F_PB', 'F_SB'),
'amp': ('u', 'A_PB', 'A_SB')
})
},
'min': {
'tspecs': ('a', {
'frq': ('a', 'F_PB', 'F_SB'),
'amp': ('a', 'A_PB', 'A_SB')
})
}
},
'HP': {
'man': {
'tspecs': ('u', {
'frq': ('u', 'F_SB', 'F_PB'),
'amp': ('u', 'A_SB', 'A_PB')
})
},
'min': {
'tspecs': ('a', {
'frq': ('a', 'F_SB', 'F_PB'),
'amp': ('a', 'A_SB', 'A_PB')
})
},
},
'BS': {
'man': {
'tspecs': ('u', {
'frq': ('u', 'F_PB', 'F_SB', 'F_SB2', 'F_PB2'),
'amp': ('u', 'A_PB', 'A_SB', 'A_PB2')
}),
'msg':
('a', "\nThis is not a proper band stop, it only lets pass"
" frequency components around DC and <i>f<sub>S</sub></i>/2."
" The order needs to be odd."),
}
},
'BP': {
'man': {
'tspecs': ('u', {
'frq': (
'u',
'F_SB',
'F_PB',
'F_PB2',
'F_SB2',
),
'amp': ('u', 'A_SB', 'A_PB', 'A_SB2')
}),
'msg':
('a', "\nThis is not a proper band pass, it only lets pass"
" frequency components around <i>f<sub>S</sub></i>/4."
" The order needs to be odd."),
}
},
}
self.info_doc = []
# self.info_doc.append('remez()\n=======')
# self.info_doc.append(sig.remez.__doc__)
# self.info_doc.append('remezord()\n==========')
# self.info_doc.append(remezord.__doc__)
#--------------------------------------------------------------------------
def construct_UI(self):
"""
Create additional subwidget(s) needed for filter design:
These subwidgets are instantiated dynamically when needed in
select_filter.py using the handle to the filter instance, fb.fil_inst.
"""
self.lbl_delays = QLabel("<b><i>M =</ i></ b>", self)
self.lbl_delays.setObjectName('wdg_lbl_ma_0')
self.led_delays = QLineEdit(self)
try:
self.led_delays.setText(str(fb.fil[0]['N']))
except KeyError:
self.led_delays.setText(str(self.delays))
self.led_delays.setObjectName('wdg_led_ma_0')
self.led_delays.setToolTip("Set number of delays per stage")
self.lbl_stages = QLabel("<b>Stages =</ b>", self)
self.lbl_stages.setObjectName('wdg_lbl_ma_1')
self.led_stages = QLineEdit(self)
self.led_stages.setText(str(self.stages))
self.led_stages.setObjectName('wdg_led_ma_1')
self.led_stages.setToolTip("Set number of stages ")
self.chk_norm = QCheckBox("Normalize", self)
self.chk_norm.setChecked(True)
self.chk_norm.setObjectName('wdg_chk_ma_2')
self.chk_norm.setToolTip("Normalize to| H_max = 1|")
self.layHWin = QHBoxLayout()
self.layHWin.setObjectName('wdg_layGWin')
self.layHWin.addWidget(self.lbl_delays)
self.layHWin.addWidget(self.led_delays)
self.layHWin.addStretch(1)
self.layHWin.addWidget(self.lbl_stages)
self.layHWin.addWidget(self.led_stages)
self.layHWin.addStretch(1)
self.layHWin.addWidget(self.chk_norm)
self.layHWin.setContentsMargins(0, 0, 0, 0)
# Widget containing all subwidgets (cmbBoxes, Labels, lineEdits)
self.wdg_fil = QWidget(self)
self.wdg_fil.setObjectName('wdg_fil')
self.wdg_fil.setLayout(self.layHWin)
#----------------------------------------------------------------------
# SIGNALS & SLOTs
#----------------------------------------------------------------------
self.led_delays.editingFinished.connect(self._update_UI)
self.led_stages.editingFinished.connect(self._update_UI)
# fires when edited line looses focus or when RETURN is pressed
self.chk_norm.clicked.connect(self._update_UI)
#----------------------------------------------------------------------
self._load_dict() # get initial / last setting from dictionary
self._update_UI()
def _load_dict(self):
"""
Reload parameter(s) from filter dictionary (if they exist) and set
corresponding UI elements. load_dict() is called upon initialization
and when the filter is loaded from disk.
"""
if 'wdg_fil' in fb.fil[0] and 'ma' in fb.fil[0]['wdg_fil']:
wdg_fil_par = fb.fil[0]['wdg_fil']['ma']
if 'delays' in wdg_fil_par:
self.delays = wdg_fil_par['delays']
self.led_delays.setText(str(self.delays))
if 'stages' in wdg_fil_par:
self.stages = wdg_fil_par['stages']
self.led_stages.setText(str(self.stages))
if 'normalize' in wdg_fil_par:
self.chk_norm.setChecked(wdg_fil_par['normalize'])
def _update_UI(self):
"""
Update UI when line edit field is changed (here, only the text is read
and converted to integer) and resize the textfields according to content.
"""
self.delays = safe_eval(self.led_delays.text(),
self.delays,
return_type='int',
sign='pos')
self.led_delays.setText(str(self.delays))
self.stages = safe_eval(self.led_stages.text(),
self.stages,
return_type='int',
sign='pos')
self.led_stages.setText(str(self.stages))
self._store_entries()
def _store_entries(self):
"""
Store parameter settings in filter dictionary. Called from _update_UI()
and _save()
"""
if not 'wdg_fil' in fb.fil[0]:
fb.fil[0].update({'wdg_fil': {}})
fb.fil[0]['wdg_fil'].update({
'ma': {
'delays': self.delays,
'stages': self.stages,
'normalize': self.chk_norm.isChecked()
}
})
# sig_tx -> select_filter -> filter_specs
self.emit({'filt_changed': 'ma'})
def _get_params(self, fil_dict):
"""
Translate parameters from the passed dictionary to instance
parameters, scaling / transforming them if needed.
"""
# N is total order, L is number of taps per stage
self.F_SB = fil_dict['F_SB']
self.A_SB = fil_dict['A_SB']
def _save(self, fil_dict):
"""
Save MA-filters both in 'zpk' and 'ba' format; no conversion has to be
performed except maybe deleting an 'sos' entry from an earlier
filter design.
"""
if 'zpk' in self.FRMT:
fil_save(fil_dict, self.zpk, 'zpk', __name__, convert=False)
if 'ba' in self.FRMT:
fil_save(fil_dict, self.b, 'ba', __name__, convert=False)
fil_convert(fil_dict, self.FRMT)
# always update filter dict and LineEdit, in case the design algorithm
# has changed the number of delays:
fil_dict['N'] = self.delays * self.stages # updated filter order
self.led_delays.setText(str(self.delays)) # updated number of delays
self._store_entries()
def calc_ma(self, fil_dict, rt='LP'):
"""
Calculate coefficients and P/Z for moving average filter based on
filter length L = N + 1 and number of cascaded stages and save the
result in the filter dictionary.
"""
b = 1.
k = 1.
L = self.delays + 1
if rt == 'LP':
b0 = np.ones(L) # h[n] = {1; 1; 1; ...}
i = np.arange(1, L)
norm = L
elif rt == 'HP':
b0 = np.ones(L)
b0[::2] = -1. # h[n] = {1; -1; 1; -1; ...}
i = np.arange(L)
if (L % 2 == 0): # even order, remove middle element
i = np.delete(i, round(L / 2.))
else: # odd order, shift by 0.5 and remove middle element
i = np.delete(i, int(L / 2.)) + 0.5
norm = L
elif rt == 'BP':
# N is even, L is odd
b0 = np.ones(L)
b0[1::2] = 0
b0[::4] = -1 # h[n] = {1; 0; -1; 0; 1; ... }
L = L + 1
i = np.arange(L) # create N + 2 zeros around the unit circle, ...
# ... remove first and middle element and rotate by L / 4
i = np.delete(i, [0, L // 2]) + L / 4
norm = np.sum(abs(b0))
elif rt == 'BS':
# N is even, L is odd
b0 = np.ones(L)
b0[1::2] = 0
L = L + 1
i = np.arange(
L) # create N + 2 zeros around the unit circle and ...
i = np.delete(i,
[0, L // 2]) # ... remove first and middle element
norm = np.sum(b0)
if self.delays > 1000:
if not qfilter_warning(None, self.delays * self.stages,
"Moving Average"):
return -1
z0 = np.exp(-2j * np.pi * i / L)
# calculate filter for multiple cascaded stages
for i in range(self.stages):
b = np.convolve(b0, b)
z = np.repeat(z0, self.stages)
# normalize filter to |H_max| = 1 if checked:
if self.chk_norm.isChecked():
b = b / (norm**self.stages)
k = 1. / norm**self.stages
p = np.zeros(len(z))
# store in class attributes for the _save method
self.zpk = [z, p, k]
self.b = b
self._save(fil_dict)
def LPman(self, fil_dict):
self._get_params(fil_dict)
self.calc_ma(fil_dict, rt='LP')
def LPmin(self, fil_dict):
self._get_params(fil_dict)
self.delays = int(
np.ceil(
1 /
(self.A_SB**(1 / self.stages) * np.sin(self.F_SB * np.pi))))
self.calc_ma(fil_dict, rt='LP')
def HPman(self, fil_dict):
self._get_params(fil_dict)
self.calc_ma(fil_dict, rt='HP')
def HPmin(self, fil_dict):
self._get_params(fil_dict)
self.delays = int(
np.ceil(1 / (self.A_SB**(1 / self.stages) * np.sin(
(0.5 - self.F_SB) * np.pi))))
self.calc_ma(fil_dict, rt='HP')
def BSman(self, fil_dict):
self._get_params(fil_dict)
self.delays = ceil_odd(self.delays) # enforce odd order
self.calc_ma(fil_dict, rt='BS')
def BPman(self, fil_dict):
self._get_params(fil_dict)
self.delays = ceil_odd(self.delays) # enforce odd order
self.calc_ma(fil_dict, rt='BP')
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- Matplotlib widget with NavigationToolbar
- Frame with control elements
"""
self.bfont = QFont()
self.bfont.setBold(True)
self.qfft_win_select = QFFTWinSelector(self, self.win_dict)
self.lbl_N = QLabel(to_html("N =", frmt='bi'))
self.led_N = QLineEdit(self)
self.led_N.setText(str(self.N_view))
self.led_N.setMaximumWidth(qtext_width(N_x=8))
self.led_N.setToolTip(
"<span>Number of window data points to display.</span>")
# By default, the enter key triggers the default 'dialog action' in QDialog
# widgets. This activates one of the pushbuttons.
self.but_log_t = QPushButton("dB", default=False, autoDefault=False)
self.but_log_t.setMaximumWidth(qtext_width(" dB "))
self.but_log_t.setObjectName("chk_log_time")
self.but_log_t.setCheckable(True)
self.but_log_t.setChecked(False)
self.but_log_t.setToolTip("Display in dB")
self.led_log_bottom_t = QLineEdit(self)
self.led_log_bottom_t.setVisible(self.but_log_t.isChecked())
self.led_log_bottom_t.setText(str(self.bottom_t))
self.led_log_bottom_t.setMaximumWidth(qtext_width(N_x=6))
self.led_log_bottom_t.setToolTip(
"<span>Minimum display value for log. scale.</span>")
self.lbl_log_bottom_t = QLabel(to_html("min =", frmt='bi'), self)
self.lbl_log_bottom_t.setVisible(self.but_log_t.isChecked())
self.but_norm_f = QPushButton("Max=1",
default=False,
autoDefault=False)
self.but_norm_f.setCheckable(True)
self.but_norm_f.setChecked(True)
self.but_norm_f.setMaximumWidth(qtext_width(text=" Max=1 "))
self.but_norm_f.setToolTip(
"Normalize window spectrum for a maximum of 1.")
self.but_half_f = QPushButton("0...½",
default=False,
autoDefault=False)
self.but_half_f.setCheckable(True)
self.but_half_f.setChecked(True)
self.but_half_f.setMaximumWidth(qtext_width(text=" 0...½ "))
self.but_half_f.setToolTip(
"Display window spectrum in the range 0 ... 0.5 f_S.")
# By default, the enter key triggers the default 'dialog action' in QDialog
# widgets. This activates one of the pushbuttons.
self.but_log_f = QPushButton("dB", default=False, autoDefault=False)
self.but_log_f.setMaximumWidth(qtext_width(" dB "))
self.but_log_f.setObjectName("chk_log_freq")
self.but_log_f.setToolTip("<span>Display in dB.</span>")
self.but_log_f.setCheckable(True)
self.but_log_f.setChecked(True)
self.lbl_log_bottom_f = QLabel(to_html("min =", frmt='bi'), self)
self.lbl_log_bottom_f.setVisible(self.but_log_f.isChecked())
self.led_log_bottom_f = QLineEdit(self)
self.led_log_bottom_f.setVisible(self.but_log_t.isChecked())
self.led_log_bottom_f.setText(str(self.bottom_f))
self.led_log_bottom_f.setMaximumWidth(qtext_width(N_x=6))
self.led_log_bottom_f.setToolTip(
"<span>Minimum display value for log. scale.</span>")
# ----------------------------------------------------------------------
# ### frmControls ###
#
# This widget encompasses all control subwidgets
# ----------------------------------------------------------------------
layH_win_select = QHBoxLayout()
layH_win_select.addWidget(self.qfft_win_select)
layH_win_select.setContentsMargins(0, 0, 0, 0)
layH_win_select.addStretch(1)
frmQFFT = QFrame(self)
frmQFFT.setObjectName("frmQFFT")
frmQFFT.setLayout(layH_win_select)
hline = QHLine()
layHControls = QHBoxLayout()
layHControls.addWidget(self.lbl_N)
layHControls.addWidget(self.led_N)
layHControls.addStretch(1)
layHControls.addWidget(self.lbl_log_bottom_t)
layHControls.addWidget(self.led_log_bottom_t)
layHControls.addWidget(self.but_log_t)
layHControls.addStretch(5)
layHControls.addWidget(QVLine(width=2))
layHControls.addStretch(5)
layHControls.addWidget(self.but_norm_f)
layHControls.addStretch(1)
layHControls.addWidget(self.but_half_f)
layHControls.addStretch(1)
layHControls.addWidget(self.lbl_log_bottom_f)
layHControls.addWidget(self.led_log_bottom_f)
layHControls.addWidget(self.but_log_f)
layVControls = QVBoxLayout()
layVControls.addWidget(frmQFFT)
layVControls.addWidget(hline)
layVControls.addLayout(layHControls)
frmControls = QFrame(self)
frmControls.setObjectName("frmControls")
frmControls.setLayout(layVControls)
# ----------------------------------------------------------------------
# ### mplwidget ###
#
# Layout layVMainMpl (VBox) is defined within MplWidget, additional
# widgets can be added below the matplotlib widget (here: frmControls)
#
# ----------------------------------------------------------------------
self.mplwidget = MplWidget(self)
self.mplwidget.layVMainMpl.addWidget(frmControls)
self.mplwidget.layVMainMpl.setContentsMargins(0, 0, 0, 0)
# ----------------------------------------------------------------------
# ### frmInfo ###
#
# This widget encompasses the text info box and the table with window
# parameters.
# ----------------------------------------------------------------------
self.tbl_win_props = QTableWidget(self.tbl_rows, self.tbl_cols, self)
self.tbl_win_props.setAlternatingRowColors(True)
# Auto-resize of table can be set using the header (although it is invisible)
self.tbl_win_props.verticalHeader().setSectionResizeMode(
QHeaderView.Stretch)
# Only the columns with data are stretched, the others are minimum size
self.tbl_win_props.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Stretch)
self.tbl_win_props.horizontalHeader().setSectionResizeMode(
4, QHeaderView.Stretch)
self.tbl_win_props.verticalHeader().setVisible(False)
self.tbl_win_props.horizontalHeader().setVisible(False)
self.tbl_win_props.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.tbl_win_props.setFixedHeight(
self.tbl_win_props.rowHeight(0) * self.tbl_rows +
self.tbl_win_props.frameWidth() * 2)
# self.tbl_win_props.setVerticalScrollBarPolicy(
# Qt.ScrollBarAlwaysOff)
# self.tbl_win_props.setHorizontalScrollBarPolicy(
# Qt.ScrollBarAlwaysOff)
self._construct_table(self.tbl_rows, self.tbl_cols, " ")
self.txtInfoBox = QTextBrowser(self)
layVInfo = QVBoxLayout(self)
layVInfo.addWidget(self.tbl_win_props)
layVInfo.addWidget(self.txtInfoBox)
frmInfo = QFrame(self)
frmInfo.setObjectName("frmInfo")
frmInfo.setLayout(layVInfo)
# ----------------------------------------------------------------------
# ### splitter ###
#
# This widget encompasses all subwidgets
# ----------------------------------------------------------------------
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
splitter.addWidget(self.mplwidget)
splitter.addWidget(frmInfo)
# setSizes uses absolute pixel values, but can be "misused" by
# specifying values that are way too large: in this case, the space
# is distributed according to the _ratio_ of the values:
splitter.setSizes([3000, 800])
layVMain = QVBoxLayout()
layVMain.addWidget(splitter)
self.setLayout(layVMain)
# ----------------------------------------------------------------------
# Set subplots
#
self.ax = self.mplwidget.fig.subplots(nrows=1, ncols=2)
self.ax_t = self.ax[0]
self.ax_f = self.ax[1]
self.calc_win_draw() # initial calculation and drawing
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
self.sig_rx.connect(self.qfft_win_select.sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.but_log_f.clicked.connect(self.update_view)
self.but_log_t.clicked.connect(self.update_view)
self.led_log_bottom_t.editingFinished.connect(self.update_bottom)
self.led_log_bottom_f.editingFinished.connect(self.update_bottom)
self.led_N.editingFinished.connect(self.calc_win_draw)
self.but_norm_f.clicked.connect(self.calc_win_draw)
self.but_half_f.clicked.connect(self.update_view)
self.mplwidget.mplToolbar.sig_tx.connect(self.process_sig_rx)
self.tbl_win_props.itemClicked.connect(self._handle_item_clicked)
self.qfft_win_select.sig_tx.connect(self.update_fft_win)
class Input_Info(QWidget):
"""
Create widget for displaying infos about filter specs and filter design method
"""
sig_rx = pyqtSignal(object) # incoming signals from input_tab_widgets
def __init__(self, parent):
super(Input_Info, self).__init__(parent)
self.tab_label = 'Info'
self.tool_tip = (
"<span>Display the achieved filter specifications"
" and more info about the filter design algorithm.</span>")
self._construct_UI()
self.load_dict()
def process_sig_rx(self, dict_sig=None):
"""
Process signals coming from sig_rx
"""
logger.debug("Processing {0}: {1}".format(
type(dict_sig).__name__, dict_sig))
if 'data_changed' in dict_sig or 'view_changed' in dict_sig or 'specs_changed' in dict_sig:
self.load_dict()
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- Checkboxes for selecting the info to be displayed
- A large text window for displaying infos about the filter design
algorithm
"""
bfont = QFont()
bfont.setBold(True)
# ============== UI Layout =====================================
# widget / subwindow for filter infos
self.chkFiltPerf = QCheckBox("H(f)", self)
self.chkFiltPerf.setChecked(True)
self.chkFiltPerf.setToolTip(
"Display frequency response at test frequencies.")
self.chkDocstring = QCheckBox("Doc$", self)
self.chkDocstring.setChecked(False)
self.chkDocstring.setToolTip(
"Display docstring from python filter method.")
self.chkRichText = QCheckBox("RTF", self)
self.chkRichText.setChecked(HAS_DOCUTILS)
self.chkRichText.setEnabled(HAS_DOCUTILS)
self.chkRichText.setToolTip(
"Render documentation in Rich Text Format.")
self.chkFiltDict = QCheckBox("FiltDict", self)
self.chkFiltDict.setToolTip("Show filter dictionary for debugging.")
self.chkFiltTree = QCheckBox("FiltTree", self)
self.chkFiltTree.setToolTip("Show filter tree for debugging.")
self.layHChkBoxes = QHBoxLayout()
self.layHChkBoxes.addWidget(self.chkFiltPerf)
self.layHChkBoxes.addStretch(1)
self.layHChkBoxes.addWidget(self.chkDocstring)
self.layHChkBoxes.addStretch(1)
self.layHChkBoxes.addWidget(self.chkRichText)
self.layHChkBoxes.addStretch(1)
self.layHChkBoxes.addWidget(self.chkFiltDict)
self.layHChkBoxes.addStretch(1)
self.layHChkBoxes.addWidget(self.chkFiltTree)
self.frmMain = QFrame(self)
self.frmMain.setLayout(self.layHChkBoxes)
self.tblFiltPerf = QTableWidget(self)
self.tblFiltPerf.setAlternatingRowColors(True)
# self.tblFiltPerf.verticalHeader().setVisible(False)
self.tblFiltPerf.horizontalHeader().setHighlightSections(False)
self.tblFiltPerf.horizontalHeader().setFont(bfont)
self.tblFiltPerf.verticalHeader().setHighlightSections(False)
self.tblFiltPerf.verticalHeader().setFont(bfont)
self.txtFiltInfoBox = QTextBrowser(self)
self.txtFiltDict = QTextBrowser(self)
self.txtFiltTree = QTextBrowser(self)
layVMain = QVBoxLayout()
layVMain.addWidget(self.frmMain)
# layVMain.addLayout(self.layHChkBoxes)
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
splitter.addWidget(self.tblFiltPerf)
splitter.addWidget(self.txtFiltInfoBox)
splitter.addWidget(self.txtFiltDict)
splitter.addWidget(self.txtFiltTree)
# setSizes uses absolute pixel values, but can be "misused" by specifying values
# that are way too large: in this case, the space is distributed according
# to the _ratio_ of the values:
splitter.setSizes([3000, 10000, 1000, 1000])
layVMain.addWidget(splitter)
layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(layVMain)
#----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.chkFiltPerf.clicked.connect(self._show_filt_perf)
self.chkFiltDict.clicked.connect(self._show_filt_dict)
self.chkFiltTree.clicked.connect(self._show_filt_tree)
self.chkDocstring.clicked.connect(self._show_doc)
self.chkRichText.clicked.connect(self._show_doc)
#------------------------------------------------------------------------------
def load_dict(self):
"""
update docs and filter performance
"""
self._show_doc()
self._show_filt_perf()
self._show_filt_dict()
self._show_filt_tree()
#------------------------------------------------------------------------------
def _show_doc(self):
"""
Display info from filter design file and docstring
"""
if hasattr(ff.fil_inst, 'info'):
if self.chkRichText.isChecked():
self.txtFiltInfoBox.setText(
publish_string(
self._clean_doc(ff.fil_inst.info),
writer_name='html',
settings_overrides={'output_encoding': 'unicode'}))
else:
self.txtFiltInfoBox.setText(textwrap.dedent(ff.fil_inst.info))
else:
self.txtFiltInfoBox.setText("")
if self.chkDocstring.isChecked() and hasattr(ff.fil_inst, 'info_doc'):
if self.chkRichText.isChecked():
self.txtFiltInfoBox.append(
'<hr /><b>Python module docstring:</b>\n')
for doc in ff.fil_inst.info_doc:
self.txtFiltInfoBox.append(
publish_string(
self._clean_doc(doc),
writer_name='html',
settings_overrides={'output_encoding': 'unicode'}))
else:
self.txtFiltInfoBox.append('\nPython module docstring:\n')
for doc in ff.fil_inst.info_doc:
self.txtFiltInfoBox.append(self._clean_doc(doc))
self.txtFiltInfoBox.moveCursor(QTextCursor.Start)
def _clean_doc(self, doc):
"""
Remove uniform number of leading blanks from docstrings for subsequent
processing of rich text. The first line is treated differently, _all_
leading blanks are removed (if any). This allows for different formats
of docstrings.
"""
lines = doc.splitlines()
result = lines[0].lstrip() + "\n" + textwrap.dedent("\n".join(
lines[1:]))
return result
#------------------------------------------------------------------------------
def _show_filt_perf(self):
"""
Print filter properties in a table at frequencies of interest. When
specs are violated, colour the table entry in red.
"""
antiC = False
def _find_min_max(self, f_start, f_stop, unit='dB'):
"""
Find minimum and maximum magnitude and the corresponding frequencies
for the filter defined in the filter dict in a given frequency band
[f_start, f_stop].
"""
w = np.linspace(f_start, f_stop, params['N_FFT']) * 2 * np.pi
[w, H] = sig.freqz(bb, aa, worN=w)
# add antiCausals if we have them
if (antiC):
#
# Evaluate transfer function of anticausal half on the same freq grid.
#
wa, ha = sig.freqz(bbA, aaA, worN=w)
ha = ha.conjugate()
#
# Total transfer function is the product
#
H = H * ha
f = w / (2.0 * pi) # frequency normalized to f_S
H_abs = abs(H)
H_max = max(H_abs)
H_min = min(H_abs)
F_max = f[np.argmax(H_abs)] # find the frequency where H_abs
F_min = f[np.argmin(H_abs)] # becomes max resp. min
if unit == 'dB':
H_max = 20 * log10(H_max)
H_min = 20 * log10(H_min)
return F_min, H_min, F_max, H_max
#------------------------------------------------------------------
self.tblFiltPerf.setVisible(self.chkFiltPerf.isChecked())
if self.chkFiltPerf.isChecked():
bb = fb.fil[0]['ba'][0]
aa = fb.fil[0]['ba'][1]
#'rpk' means nonCausal filter
if 'rpk' in fb.fil[0]:
antiC = True
bbA = fb.fil[0]['baA'][0]
aaA = fb.fil[0]['baA'][1]
bbA = bbA.conjugate()
aaA = aaA.conjugate()
f_S = fb.fil[0]['f_S']
f_lbls = []
f_vals = []
a_lbls = []
a_targs = []
a_targs_dB = []
a_test = []
ft = fb.fil[0]['ft'] # get filter type ('IIR', 'FIR')
unit = fb.fil[0]['amp_specs_unit']
unit = 'dB' # fix this for the moment
# construct pairs of corner frequency and corresponding amplitude
# labels in ascending frequency for each response type
if fb.fil[0]['rt'] in {'LP', 'HP', 'BP', 'BS', 'HIL'}:
if fb.fil[0]['rt'] == 'LP':
f_lbls = ['F_PB', 'F_SB']
a_lbls = ['A_PB', 'A_SB']
elif fb.fil[0]['rt'] == 'HP':
f_lbls = ['F_SB', 'F_PB']
a_lbls = ['A_SB', 'A_PB']
elif fb.fil[0]['rt'] == 'BP':
f_lbls = ['F_SB', 'F_PB', 'F_PB2', 'F_SB2']
a_lbls = ['A_SB', 'A_PB', 'A_PB', 'A_SB2']
elif fb.fil[0]['rt'] == 'BS':
f_lbls = ['F_PB', 'F_SB', 'F_SB2', 'F_PB2']
a_lbls = ['A_PB', 'A_SB', 'A_SB', 'A_PB2']
elif fb.fil[0]['rt'] == 'HIL':
f_lbls = ['F_PB', 'F_PB2']
a_lbls = ['A_PB', 'A_PB']
# Try to get lists of frequency / amplitude specs from the filter dict
# that correspond to the f_lbls / a_lbls pairs defined above
# When one of the labels doesn't exist in the filter dict, delete
# all corresponding amplitude and frequency entries.
err = [False] * len(f_lbls) # initialize error list
f_vals = []
a_targs = []
for i in range(len(f_lbls)):
try:
f = fb.fil[0][f_lbls[i]]
f_vals.append(f)
except KeyError as e:
f_vals.append('')
err[i] = True
logger.debug(e)
try:
a = fb.fil[0][a_lbls[i]]
a_dB = lin2unit(fb.fil[0][a_lbls[i]], ft, a_lbls[i],
unit)
a_targs.append(a)
a_targs_dB.append(a_dB)
except KeyError as e:
a_targs.append('')
a_targs_dB.append('')
err[i] = True
logger.debug(e)
for i in range(len(f_lbls)):
if err[i]:
del f_lbls[i]
del f_vals[i]
del a_lbls[i]
del a_targs[i]
del a_targs_dB[i]
f_vals = np.asarray(f_vals) # convert to numpy array
logger.debug("F_test_labels = %s" % f_lbls)
# Calculate frequency response at test frequencies
[w_test,
a_test] = sig.freqz(bb, aa,
2.0 * pi * f_vals.astype(np.float))
# add antiCausals if we have them
if (antiC):
wa, ha = sig.freqz(bbA, aaA,
2.0 * pi * f_vals.astype(np.float))
ha = ha.conjugate()
a_test = a_test * ha
(F_min, H_min, F_max, H_max) = _find_min_max(self, 0, 1, unit='V')
# append frequencies and values for min. and max. filter reponse to
# test vector
f_lbls += ['Min.', 'Max.']
# QTableView does not support direct formatting, use QLabel
f_vals = np.append(f_vals, [F_min, F_max])
a_targs = np.append(a_targs, [np.nan, np.nan])
a_targs_dB = np.append(a_targs_dB, [np.nan, np.nan])
a_test = np.append(a_test, [H_min, H_max])
# calculate response of test frequencies in dB
a_test_dB = -20 * log10(abs(a_test))
ft = fb.fil[0][
'ft'] # get filter type ('IIR', 'FIR') for dB <-> lin conversion
# unit = fb.fil[0]['amp_specs_unit']
unit = 'dB' # make this fixed for the moment
# build a list with the corresponding target specs:
a_targs_pass = []
eps = 1e-3
for i in range(len(f_lbls)):
if 'PB' in f_lbls[i]:
a_targs_pass.append((a_test_dB[i] - a_targs_dB[i]) < eps)
a_test[i] = 1 - abs(a_test[i])
elif 'SB' in f_lbls[i]:
a_targs_pass.append(a_test_dB[i] >= a_targs_dB[i])
else:
a_targs_pass.append(True)
self.targs_spec_passed = np.all(a_targs_pass)
logger.debug("H_targ = {0}\n"
"H_test = {1}\n"
"H_test_dB = {2}\n"
"F_test = {3}\n"
"H_targ_pass = {4}\n"
"passed: {5}\n".format(a_targs, a_test, a_test_dB,
f_vals, a_targs_pass,
self.targs_spec_passed))
self.tblFiltPerf.setRowCount(len(a_test)) # number of table rows
self.tblFiltPerf.setColumnCount(5) # number of table columns
self.tblFiltPerf.setHorizontalHeaderLabels([
'f/{0:s}'.format(fb.fil[0]['freq_specs_unit']), 'Spec\n(dB)',
'|H(f)|\n(dB)', 'Spec', '|H(f)|'
])
self.tblFiltPerf.setVerticalHeaderLabels(f_lbls)
for row in range(len(a_test)):
self.tblFiltPerf.setItem(
row, 0,
QTableWidgetItem(str('{0:.4g}'.format(f_vals[row] * f_S))))
self.tblFiltPerf.setItem(
row, 1,
QTableWidgetItem(str('%2.3g' % (-a_targs_dB[row]))))
self.tblFiltPerf.setItem(
row, 2, QTableWidgetItem(str('%2.3f' % (-a_test_dB[row]))))
if a_targs[row] < 0.01:
self.tblFiltPerf.setItem(
row, 3, QTableWidgetItem(str('%.3e' % (a_targs[row]))))
else:
self.tblFiltPerf.setItem(
row, 3,
QTableWidgetItem(str('%2.4f' % (a_targs[row]))))
if a_test[row] < 0.01:
self.tblFiltPerf.setItem(
row, 4,
QTableWidgetItem(str('%.3e' % (abs(a_test[row])))))
else:
self.tblFiltPerf.setItem(
row, 4,
QTableWidgetItem(str('%.4f' % (abs(a_test[row])))))
if not a_targs_pass[row]:
self.tblFiltPerf.item(row,
1).setBackground(QtGui.QColor('red'))
self.tblFiltPerf.item(row,
3).setBackground(QtGui.QColor('red'))
self.tblFiltPerf.resizeColumnsToContents()
self.tblFiltPerf.resizeRowsToContents()
#------------------------------------------------------------------------------
def _show_filt_dict(self):
"""
Print filter dict for debugging
"""
self.txtFiltDict.setVisible(self.chkFiltDict.isChecked())
fb_sorted = [
str(key) + ' : ' + str(fb.fil[0][key])
for key in sorted(fb.fil[0].keys())
]
dictstr = pprint.pformat(fb_sorted)
# dictstr = pprint.pformat(fb.fil[0])
self.txtFiltDict.setText(dictstr)
#------------------------------------------------------------------------------
def _show_filt_tree(self):
"""
Print filter tree for debugging
"""
self.txtFiltTree.setVisible(self.chkFiltTree.isChecked())
ftree_sorted = [
'<b>' + str(key) + ' : ' + '</b>' + str(fb.fil_tree[key])
for key in sorted(fb.fil_tree.keys())
]
dictstr = pprint.pformat(ftree_sorted, indent=4)
# dictstr = pprint.pformat(fb.fil[0])
self.txtFiltTree.setText(dictstr)
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- top chkbox row
- coefficient table
- two bottom rows with action buttons
"""
self.bfont = QFont()
self.bfont.setBold(True)
self.bifont = QFont()
self.bifont.setBold(True)
self.bifont.setItalic(True)
# q_icon_size = QSize(20, 20) # optional, size is derived from butEnable
#######################################################################
# frmMain
#
# This frame contains all the buttons
#######################################################################
# ---------------------------------------------
# layHDisplay
#
# UI Elements for controlling the display
# ---------------------------------------------
self.butEnable = PushButton(self, icon=QIcon(':/circle-check.svg'), checked=True)
q_icon_size = self.butEnable.iconSize() # <- uncomment this for manual sizing
self.butEnable.setToolTip(
"<span>Show / hide filter coefficients in an editable table."
" For high order systems, table display might be slow.</span>")
fix_formats = ['Dec', 'Hex', 'Bin', 'CSD']
self.cmbFormat = QComboBox(self)
model = self.cmbFormat.model()
item = QtGui.QStandardItem('Float')
item.setData('child', Qt.AccessibleDescriptionRole)
model.appendRow(item)
item = QtGui.QStandardItem('Fixp.:')
item.setData('parent', Qt.AccessibleDescriptionRole)
item.setData(0, QtGui.QFont.Bold)
item.setFlags(item.flags() & ~Qt.ItemIsEnabled) # | Qt.ItemIsSelectable))
model.appendRow(item)
for idx in range(len(fix_formats)):
item = QtGui.QStandardItem(fix_formats[idx])
# item.setForeground(QtGui.QColor('red'))
model.appendRow(item)
self.cmbFormat.insertSeparator(1)
qset_cmb_box(self.cmbFormat, 'float')
self.cmbFormat.setToolTip('Set the display format.')
self.cmbFormat.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.spnDigits = QSpinBox(self)
self.spnDigits.setRange(0, 16)
self.spnDigits.setValue(params['FMT_ba'])
self.spnDigits.setToolTip("Number of digits to display.")
self.lblDigits = QLabel("Digits", self)
self.lblDigits.setFont(self.bifont)
self.cmbQFrmt = QComboBox(self)
q_formats = [('Norm. Frac.', 'qnfrac'), ('Integer', 'qint'),
('Fractional', 'qfrac')]
for q in q_formats:
self.cmbQFrmt.addItem(*q)
self.lbl_W = QLabel("W = ", self)
self.lbl_W.setFont(self.bifont)
self.ledW = QLineEdit(self)
self.ledW.setToolTip("Specify total wordlength.")
self.ledW.setText("16")
self.ledW.setMaxLength(2) # maximum of 2 digits
self.ledW.setFixedWidth(30) # width of lineedit in points(?)
layHDisplay = QHBoxLayout()
layHDisplay.setAlignment(Qt.AlignLeft)
layHDisplay.addWidget(self.butEnable)
layHDisplay.addWidget(self.cmbFormat)
layHDisplay.addWidget(self.spnDigits)
layHDisplay.addWidget(self.lblDigits)
layHDisplay.addWidget(self.cmbQFrmt)
layHDisplay.addWidget(self.lbl_W)
layHDisplay.addWidget(self.ledW)
layHDisplay.addStretch()
#######################################################################
# frmButtonsCoeffs
#
# This frame contains all buttons for manipulating coefficients
#######################################################################
# -----------------------------------------------------------------
# layHButtonsCoeffs1
#
# UI Elements for loading / storing / manipulating cells and rows
# -----------------------------------------------------------------
self.cmbFilterType = QComboBox(self)
self.cmbFilterType.setObjectName("comboFilterType")
self.cmbFilterType.setToolTip(
"<span>Select between IIR and FIR filter for manual entry."
"Changing the type reloads the filter from the filter dict.</span>")
self.cmbFilterType.addItems(["FIR", "IIR"])
self.cmbFilterType.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.butAddCells = QPushButton(self)
self.butAddCells.setIcon(QIcon(':/row_insert_above.svg'))
self.butAddCells.setIconSize(q_icon_size)
self.butAddCells.setToolTip(
"<span>Select cells to insert a new cell above each selected cell. "
"Use <SHIFT> or <CTRL> to select multiple cells. "
"When nothing is selected, add a row at the end.</span>")
self.butDelCells = QPushButton(self)
self.butDelCells.setIcon(QIcon(':/row_delete.svg'))
self.butDelCells.setIconSize(q_icon_size)
self.butDelCells.setToolTip(
"<span>Delete selected cell(s) from the table. "
"Use <SHIFT> or <CTRL> to select multiple cells. "
"When nothing is selected, delete the last row.</span>")
self.butSave = QPushButton(self)
self.butSave.setIcon(QIcon(':/upload.svg'))
self.butSave.setIconSize(q_icon_size)
self.butSave.setToolTip(
"<span>Copy coefficient table to filter dict and update all plots"
"and widgets.</span>")
self.butLoad = QPushButton(self)
self.butLoad.setIcon(QIcon(':/download.svg'))
self.butLoad.setIconSize(q_icon_size)
self.butLoad.setToolTip("Reload coefficient table from filter dict.")
self.butClear = QPushButton(self)
self.butClear.setIcon(QIcon(':/trash.svg'))
self.butClear.setIconSize(q_icon_size)
self.butClear.setToolTip("Clear all table entries.")
self.butFromTable = QPushButton(self)
self.butFromTable.setIconSize(q_icon_size)
self.butToTable = QPushButton(self)
self.butToTable.setIconSize(q_icon_size)
self.but_csv_options = PushButton(self, icon=QIcon(':/settings.svg'),
checked=False)
self.but_csv_options.setIconSize(q_icon_size)
self.but_csv_options.setToolTip(
"<span>Select CSV format and whether "
"to copy to/from clipboard or file.</span>")
self._set_load_save_icons() # initialize icon / button settings
layHButtonsCoeffs1 = QHBoxLayout()
layHButtonsCoeffs1.addWidget(self.cmbFilterType)
layHButtonsCoeffs1.addWidget(self.butAddCells)
layHButtonsCoeffs1.addWidget(self.butDelCells)
layHButtonsCoeffs1.addWidget(self.butClear)
layHButtonsCoeffs1.addWidget(self.butSave)
layHButtonsCoeffs1.addWidget(self.butLoad)
layHButtonsCoeffs1.addWidget(self.butFromTable)
layHButtonsCoeffs1.addWidget(self.butToTable)
layHButtonsCoeffs1.addWidget(self.but_csv_options)
layHButtonsCoeffs1.addStretch()
# ----------------------------------------------------------------------
# layHButtonsCoeffs2
#
# Eps / set zero settings
# ---------------------------------------------------------------------
self.butSetZero = QPushButton("= 0", self)
self.butSetZero.setToolTip(
"<span>Set selected coefficients = 0 with a magnitude < ε. "
"When nothing is selected, test the whole table.</span>")
self.butSetZero.setIconSize(q_icon_size)
lblEps = QLabel(self)
lblEps.setText("<b><i>for b, a</i> <</b>")
self.ledEps = QLineEdit(self)
self.ledEps.setToolTip("Specify tolerance value.")
layHButtonsCoeffs2 = QHBoxLayout()
layHButtonsCoeffs2.addWidget(self.butSetZero)
layHButtonsCoeffs2.addWidget(lblEps)
layHButtonsCoeffs2.addWidget(self.ledEps)
layHButtonsCoeffs2.addStretch()
# -------------------------------------------------------------------
# Now put the ButtonsCoeffs HBoxes into frmButtonsCoeffs
# ---------------------------------------------------------------------
layVButtonsCoeffs = QVBoxLayout()
layVButtonsCoeffs.addLayout(layHButtonsCoeffs1)
layVButtonsCoeffs.addLayout(layHButtonsCoeffs2)
layVButtonsCoeffs.setContentsMargins(0, 5, 0, 0)
# This frame encompasses all Quantization Settings
self.frmButtonsCoeffs = QFrame(self)
self.frmButtonsCoeffs.setLayout(layVButtonsCoeffs)
# ######################################################################
# frmQSettings
#
# This frame contains all quantization settings
# ######################################################################
# -------------------------------------------------------------------
# layHW_Scale
#
# QFormat and scale settings
# ---------------------------------------------------------------------
lbl_Q = QLabel("Q =", self)
lbl_Q.setFont(self.bifont)
self.ledWI = QLineEdit(self)
self.ledWI.setToolTip("Specify number of integer bits.")
self.ledWI.setText("0")
self.ledWI.setMaxLength(2) # maximum of 2 digits
self.ledWI.setFixedWidth(30) # width of lineedit in points(?)
self.lblDot = QLabel(".", self) # class attribute, visibility is toggled
self.lblDot.setFont(self.bfont)
self.ledWF = QLineEdit(self)
self.ledWF.setToolTip("Specify number of fractional bits.")
self.ledWF.setText("15")
self.ledWF.setMaxLength(2) # maximum of 2 digits
# self.ledWF.setFixedWidth(30) # width of lineedit in points(?)
self.ledWF.setMaximumWidth(30)
self.lblScale = QLabel("<b><i>Scale</i> =</b>", self)
self.ledScale = QLineEdit(self)
self.ledScale.setToolTip(
"Set the scale for converting float to fixpoint representation.")
self.ledScale.setText(str(1))
self.ledScale.setEnabled(False)
layHWI_WF = QHBoxLayout()
layHWI_WF.addWidget(lbl_Q)
layHWI_WF.addWidget(self.ledWI)
layHWI_WF.addWidget(self.lblDot)
layHWI_WF.addWidget(self.ledWF)
layHWI_WF.addStretch()
layHScale = QHBoxLayout()
layHScale.addWidget(self.lblScale)
layHScale.addWidget(self.ledScale)
layHScale.addStretch()
layHW_Scale = QHBoxLayout()
layHW_Scale.addLayout(layHWI_WF)
layHW_Scale.addLayout(layHScale)
# -------------------------------------------------------------------
# layGQOpt
#
# Quantization / Overflow / MSB / LSB settings
# ---------------------------------------------------------------------
lblQOvfl = QLabel("Ovfl.:", self)
lblQOvfl.setFont(self.bifont)
lblQuant = QLabel("Quant.:", self)
lblQuant.setFont(self.bifont)
self.cmbQOvfl = QComboBox(self)
qOvfl = ['wrap', 'sat']
self.cmbQOvfl.addItems(qOvfl)
qset_cmb_box(self.cmbQOvfl, 'sat')
self.cmbQOvfl.setToolTip("Select overflow behaviour.")
# ComboBox size is adjusted automatically to fit the longest element
self.cmbQOvfl.setSizeAdjustPolicy(QComboBox.AdjustToContents)
layHQOvflOpt = QHBoxLayout()
layHQOvflOpt.addWidget(lblQOvfl)
layHQOvflOpt.addWidget(self.cmbQOvfl)
layHQOvflOpt.addStretch()
self.cmbQuant = QComboBox(self)
qQuant = ['none', 'round', 'fix', 'floor']
self.cmbQuant.addItems(qQuant)
qset_cmb_box(self.cmbQuant, 'round')
self.cmbQuant.setToolTip("Select the kind of quantization.")
self.cmbQuant.setSizeAdjustPolicy(QComboBox.AdjustToContents)
layHQuantOpt = QHBoxLayout()
layHQuantOpt.addWidget(lblQuant)
layHQuantOpt.addWidget(self.cmbQuant)
layHQuantOpt.addStretch()
self.butQuant = QPushButton(self)
self.butQuant.setToolTip(
"<span>Quantize selected coefficients / "
"whole table with specified settings.</span>")
self.butQuant.setIcon(QIcon(':/quantize.svg'))
self.butQuant.setIconSize(q_icon_size)
self.butQuant.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
lblMSBtxt = QLabel(self)
lblMSBtxt.setText("<b><i>MSB</i><sub>10</sub> =</b>")
self.lblMSB = QLabel(self)
layHMSB = QHBoxLayout()
layHMSB.addWidget(lblMSBtxt)
layHMSB.addWidget(self.lblMSB)
layHMSB.addStretch()
lblLSBtxt = QLabel(self)
lblLSBtxt.setText("<b><i>LSB</i><sub>10</sub> =</b>")
self.lblLSB = QLabel(self)
layHLSB = QHBoxLayout()
layHLSB.addWidget(lblLSBtxt)
layHLSB.addWidget(self.lblLSB)
layHLSB.addStretch()
layGQOpt = QGridLayout()
layGQOpt.addLayout(layHQOvflOpt, 0, 0)
layGQOpt.addLayout(layHQuantOpt, 0, 1)
layGQOpt.addWidget(self.butQuant, 0, 2, Qt.AlignCenter)
layGQOpt.addLayout(layHMSB, 1, 0)
layGQOpt.addLayout(layHLSB, 1, 1)
# -------------------------------------------------------------------
# Display MAX
# ---------------------------------------------------------------------
lblMAXtxt = QLabel(self)
lblMAXtxt.setText("<b><i>Max =</i></b>")
self.lblMAX = QLabel(self)
layHCoeffs_MAX = QHBoxLayout()
layHCoeffs_MAX.addWidget(lblMAXtxt)
layHCoeffs_MAX.addWidget(self.lblMAX)
layHCoeffs_MAX.addStretch()
#######################################################################
# Now put all the coefficient HBoxes into frmQSettings
# ---------------------------------------------------------------------
layVButtonsQ = QVBoxLayout()
layVButtonsQ.addLayout(layHW_Scale)
layVButtonsQ.addLayout(layGQOpt)
layVButtonsQ.addLayout(layHCoeffs_MAX)
layVButtonsQ.setContentsMargins(0, 0, 0, 0)
# This frame encompasses all Quantization Settings
self.frmQSettings = QFrame(self)
self.frmQSettings.setLayout(layVButtonsQ)
#######################################################################
# ######################## Main UI Layout ############################
#######################################################################
# layout for frame (UI widget)
layVMainF = QVBoxLayout()
layVMainF.addLayout(layHDisplay)
layVMainF.addWidget(self.frmQSettings)
layVMainF.addWidget(QHLine())
layVMainF.addWidget(self.frmButtonsCoeffs)
# This frame encompasses all UI elements
frmMain = QFrame(self)
frmMain.setLayout(layVMainF)
layVMain = QVBoxLayout()
# the following affects only the first widget (intended here)
layVMain.setAlignment(Qt.AlignTop)
layVMain.addWidget(frmMain)
layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(layVMain)
#######################################################################
# --- set initial values from dict ------------
self.spnDigits.setValue(params['FMT_ba'])
self.ledEps.setText(str(self.eps))
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.but_csv_options.clicked.connect(self._open_csv_win)
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- top chkbox row
- coefficient table
- two bottom rows with action buttons
"""
self.bfont = QFont()
self.bfont.setBold(True)
self.bifont = QFont()
self.bifont.setBold(True)
self.bifont.setItalic(True)
# q_icon_size = QSize(20, 20) # optional, size is derived from butEnable
# ---------------------------------------------
# UI Elements for controlling the display
# ---------------------------------------------
self.butEnable = QPushButton(self)
self.butEnable.setIcon(QIcon(':/circle-x.svg'))
q_icon_size = self.butEnable.iconSize() # <- set this for manual icon sizing
self.butEnable.setIconSize(q_icon_size)
self.butEnable.setCheckable(True)
self.butEnable.setChecked(True)
self.butEnable.setToolTip("<span>Show / hide poles and zeros in an editable table."
" For high order systems, the table display might be slow.</span>")
self.cmbPZFrmt = QComboBox(self)
pz_formats = [('Cartesian', 'cartesian'), ('Polar (rad)', 'polar_rad'),
('Polar (pi)', 'polar_pi'), ('Polar (°)', 'polar_deg')] # display text, data
# π: u'3C0, °: u'B0, ∠: u'2220
for pz in pz_formats:
self.cmbPZFrmt.addItem(*pz)
self.cmbPZFrmt.setSizeAdjustPolicy(QComboBox.AdjustToContents)
# self.cmbPZFrmt.setEnabled(False)
self.cmbPZFrmt.setToolTip("<span>Set display format for poles and zeros to"
" either cartesian (x + jy) or polar (r * ∠ Ω)."
" Type 'o' for '°', '<' for '∠' and 'pi' for 'π'.</span>")
self.spnDigits = QSpinBox(self)
self.spnDigits.setRange(0,16)
self.spnDigits.setToolTip("Number of digits to display.")
self.lblDigits = QLabel("Digits", self)
self.lblDigits.setFont(self.bifont)
self.cmbCausal = QComboBox(self)
causal_types = ['Causal', 'Acausal', 'Anticausal']
for cs in causal_types:
self.cmbCausal.addItem(cs)
qset_cmb_box(self.cmbCausal, 'Causal')
self.cmbCausal.setToolTip('<span>Set the system type. Not implemented yet.</span>')
self.cmbCausal.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmbCausal.setEnabled(False)
layHDisplay = QHBoxLayout()
layHDisplay.setAlignment(Qt.AlignLeft)
layHDisplay.addWidget(self.butEnable)
layHDisplay.addWidget(self.cmbPZFrmt)
layHDisplay.addWidget(self.spnDigits)
layHDisplay.addWidget(self.lblDigits)
layHDisplay.addWidget(self.cmbCausal)
layHDisplay.addStretch()
# ---------------------------------------------
# UI Elements for setting the gain
# ---------------------------------------------
self.lblNorm = QLabel(to_html("Normalize:", frmt='bi'), self)
self.cmbNorm = QComboBox(self)
self.cmbNorm.addItems(["None", "1", "Max"])
self.cmbNorm.setToolTip("<span>Set the gain <i>k</i> so that H(f)<sub>max</sub> is "
"either 1 or the max. of the previous system.</span>")
self.lblGain = QLabel(to_html("k =", frmt='bi'), self)
self.ledGain = QLineEdit(self)
self.ledGain.setToolTip("<span>Specify gain factor <i>k</i>"
" (only possible for Normalize = 'None').</span>")
self.ledGain.setText(str(1.))
self.ledGain.setObjectName("ledGain")
layHGain = QHBoxLayout()
layHGain.addWidget(self.lblNorm)
layHGain.addWidget(self.cmbNorm)
layHGain.addWidget(self.lblGain)
layHGain.addWidget(self.ledGain)
layHGain.addStretch()
# ---------------------------------------------
# UI Elements for loading / storing / manipulating cells and rows
# ---------------------------------------------
# self.cmbFilterType = QComboBox(self)
# self.cmbFilterType.setObjectName("comboFilterType")
# self.cmbFilterType.setToolTip("Select between IIR and FIR filte for manual entry.")
# self.cmbFilterType.addItems(["FIR","IIR"])
# self.cmbFilterType.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.butAddCells = QPushButton(self)
self.butAddCells.setIcon(QIcon(':/row_insert_above.svg'))
self.butAddCells.setIconSize(q_icon_size)
self.butAddCells.setToolTip("<SPAN>Select cells to insert a new cell above each selected cell. "
"Use <SHIFT> or <CTRL> to select multiple cells. "
"When nothing is selected, add a row at the end.</SPAN>")
self.butDelCells = QPushButton(self)
self.butDelCells.setIcon(QIcon(':/row_delete.svg'))
self.butDelCells.setIconSize(q_icon_size)
self.butDelCells.setToolTip("<SPAN>Delete selected cell(s) from the table. "
"Use <SHIFT> or <CTRL> to select multiple cells. "
"When nothing is selected, delete the last row.</SPAN>")
self.butSave = QPushButton(self)
self.butSave.setIcon(QIcon(':/upload.svg'))
self.butSave.setIconSize(q_icon_size)
self.butSave.setToolTip("<span>Copy P/Z table to filter dict and update all plots and widgets.</span>")
self.butLoad = QPushButton(self)
self.butLoad.setIcon(QIcon(':/download.svg'))
self.butLoad.setIconSize(q_icon_size)
self.butLoad.setToolTip("Reload P/Z table from filter dict.")
self.butClear = QPushButton(self)
self.butClear.setIcon(QIcon(':/trash.svg'))
self.butClear.setIconSize(q_icon_size)
self.butClear.setToolTip("Clear all table entries.")
self.butFromTable = QPushButton(self)
self.butFromTable.setIconSize(q_icon_size)
self.butToTable = QPushButton(self)
self.butToTable.setIconSize(q_icon_size)
self.but_csv_options = QPushButton(self)
self.but_csv_options.setIcon(QIcon(':/settings.svg'))
self.but_csv_options.setIconSize(q_icon_size)
self.but_csv_options.setToolTip("<span>Select CSV format and whether "
"to copy to/from clipboard or file.</span>")
self.but_csv_options.setCheckable(True)
self.but_csv_options.setChecked(False)
self._set_load_save_icons() # initialize icon / button settings
layHButtonsCoeffs1 = QHBoxLayout()
# layHButtonsCoeffs1.addWidget(self.cmbFilterType)
layHButtonsCoeffs1.addWidget(self.butAddCells)
layHButtonsCoeffs1.addWidget(self.butDelCells)
layHButtonsCoeffs1.addWidget(self.butClear)
layHButtonsCoeffs1.addWidget(self.butSave)
layHButtonsCoeffs1.addWidget(self.butLoad)
layHButtonsCoeffs1.addWidget(self.butFromTable)
layHButtonsCoeffs1.addWidget(self.butToTable)
layHButtonsCoeffs1.addWidget(self.but_csv_options)
layHButtonsCoeffs1.addStretch()
#-------------------------------------------------------------------
# Eps / set zero settings
# ---------------------------------------------------------------------
self.butSetZero = QPushButton("= 0", self)
self.butSetZero.setToolTip("<span>Set selected poles / zeros = 0 with a magnitude < ε. "
"When nothing is selected, test the whole table.</span>")
self.butSetZero.setIconSize(q_icon_size)
lblEps = QLabel(self)
lblEps.setText("<b><i>for ε</i> <</b>")
self.ledEps = QLineEdit(self)
self.ledEps.setToolTip("Specify tolerance value.")
layHButtonsCoeffs2 = QHBoxLayout()
layHButtonsCoeffs2.addWidget(self.butSetZero)
layHButtonsCoeffs2.addWidget(lblEps)
layHButtonsCoeffs2.addWidget(self.ledEps)
layHButtonsCoeffs2.addStretch()
# ######################## Main UI Layout ############################
# layout for frame (UI widget)
layVMainF = QVBoxLayout()
layVMainF.addLayout(layHDisplay)
layVMainF.addLayout(layHGain)
layVMainF.addLayout(layHButtonsCoeffs1)
layVMainF.addLayout(layHButtonsCoeffs2)
# This frame encompasses all UI elements
frmMain = QFrame(self)
frmMain.setLayout(layVMainF)
layVMain = QVBoxLayout()
layVMain.setAlignment(Qt.AlignTop) # this affects only the first widget (intended here)
layVMain.addWidget(frmMain)
layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(layVMain)
#--- set initial values from dict ------------
self.spnDigits.setValue(params['FMT_pz'])
self.ledEps.setText(str(self.eps))
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.but_csv_options.clicked.connect(self._open_csv_win)
def _construct_UI(self):
# ----------- ---------------------------------------------------
# Run control widgets
# ---------------------------------------------------------------
# self.but_auto_run = QPushButtonRT(text=to_html("Auto", frmt="b"), margin=0)
self.but_auto_run = QPushButton(" Auto", self)
self.but_auto_run.setObjectName("but_auto_run")
self.but_auto_run.setToolTip(
"<span>Update response automatically when "
"parameters have been changed.</span>")
# self.but_auto_run.setMaximumWidth(qtext_width(text=" Auto "))
self.but_auto_run.setCheckable(True)
self.but_auto_run.setChecked(True)
but_height = self.but_auto_run.sizeHint().height()
self.but_run = QPushButton(self)
self.but_run.setIcon(QIcon(":/play.svg"))
self.but_run.setIconSize(QSize(but_height, but_height))
self.but_run.setFixedSize(QSize(2 * but_height, but_height))
self.but_run.setToolTip("Run simulation")
self.but_run.setEnabled(True)
self.cmb_sim_select = QComboBox(self)
self.cmb_sim_select.addItems(["Float", "Fixpoint"])
qset_cmb_box(self.cmb_sim_select, "Float")
self.cmb_sim_select.setToolTip("<span>Simulate floating-point or "
"fixpoint response.</span>")
self.lbl_N_points = QLabel(to_html("N", frmt='bi') + " =", self)
self.led_N_points = QLineEdit(self)
self.led_N_points.setText(str(self.N))
self.led_N_points.setToolTip(
"<span>Last data point. "
"<i>N</i> = 0 tries to choose for you.</span>")
self.led_N_points.setMaximumWidth(qtext_width(N_x=8))
self.lbl_N_start = QLabel(to_html("N_0", frmt='bi') + " =", self)
self.led_N_start = QLineEdit(self)
self.led_N_start.setText(str(self.N_start))
self.led_N_start.setToolTip("<span>First point to plot.</span>")
self.led_N_start.setMaximumWidth(qtext_width(N_x=8))
self.lbl_N_frame = QLabel(to_html("ΔN", frmt='bi') + " =", self)
self.led_N_frame = QLineEdit(self)
self.led_N_frame.setText(str(self.N_frame))
self.led_N_frame.setToolTip(
"<span>Frame length; longer frames calculate faster but calculation cannot "
"be stopped so quickly. "
"<i>ΔN</i> = 0 calculates all samples in one frame.</span>")
self.led_N_frame.setMaximumWidth(qtext_width(N_x=8))
self.prg_wdg = QProgressBar(self)
self.prg_wdg.setFixedHeight(but_height)
self.prg_wdg.setFixedWidth(qtext_width(N_x=6))
self.prg_wdg.setMinimum(0)
self.prg_wdg.setValue(0)
self.but_toggle_stim_options = PushButton(" Stimuli ", checked=True)
self.but_toggle_stim_options.setObjectName("but_stim_options")
self.but_toggle_stim_options.setToolTip(
"<span>Show / hide stimulus options.</span>")
self.lbl_stim_cmplx_warn = QLabel(self)
self.lbl_stim_cmplx_warn = QLabel(to_html("Cmplx!", frmt='b'), self)
self.lbl_stim_cmplx_warn.setToolTip(
'<span>Signal is complex valued; '
'single-sided and H<sub>id</sub> spectra may be wrong.</span>')
self.lbl_stim_cmplx_warn.setStyleSheet("background-color : yellow;"
"border : 1px solid grey")
self.but_fft_wdg = QPushButton(self)
self.but_fft_wdg.setIcon(QIcon(":/fft.svg"))
self.but_fft_wdg.setIconSize(QSize(but_height, but_height))
self.but_fft_wdg.setFixedSize(QSize(int(1.5 * but_height), but_height))
self.but_fft_wdg.setToolTip(
'<span>Show / hide FFT widget (select window type '
' and display its properties).</span>')
self.but_fft_wdg.setCheckable(True)
self.but_fft_wdg.setChecked(False)
self.qfft_win_select = QFFTWinSelector(self, self.win_dict)
self.but_fx_scale = PushButton(" FX:Int ")
self.but_fx_scale.setObjectName("but_fx_scale")
self.but_fx_scale.setToolTip(
"<span>Display data with integer (fixpoint) scale.</span>")
self.but_fx_range = PushButton(" FX:Range")
self.but_fx_range.setObjectName("but_fx_limits")
self.but_fx_range.setToolTip(
"<span>Display limits of fixpoint range.</span>")
layH_ctrl_run = QHBoxLayout()
layH_ctrl_run.addWidget(self.but_auto_run)
layH_ctrl_run.addWidget(self.but_run)
layH_ctrl_run.addWidget(self.cmb_sim_select)
layH_ctrl_run.addSpacing(10)
layH_ctrl_run.addWidget(self.lbl_N_start)
layH_ctrl_run.addWidget(self.led_N_start)
layH_ctrl_run.addWidget(self.lbl_N_points)
layH_ctrl_run.addWidget(self.led_N_points)
layH_ctrl_run.addWidget(self.lbl_N_frame)
layH_ctrl_run.addWidget(self.led_N_frame)
layH_ctrl_run.addWidget(self.prg_wdg)
layH_ctrl_run.addSpacing(20)
layH_ctrl_run.addWidget(self.but_toggle_stim_options)
layH_ctrl_run.addSpacing(5)
layH_ctrl_run.addWidget(self.lbl_stim_cmplx_warn)
layH_ctrl_run.addSpacing(20)
layH_ctrl_run.addWidget(self.but_fft_wdg)
layH_ctrl_run.addWidget(self.qfft_win_select)
layH_ctrl_run.addSpacing(20)
layH_ctrl_run.addWidget(self.but_fx_scale)
layH_ctrl_run.addWidget(self.but_fx_range)
layH_ctrl_run.addStretch(10)
# layH_ctrl_run.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_run = QWidget(self)
self.wdg_ctrl_run.setLayout(layH_ctrl_run)
# --- end of run control ----------------------------------------
# ----------- ---------------------------------------------------
# Controls for time domain
# ---------------------------------------------------------------
self.lbl_plt_time_stim = QLabel(to_html("Stim. x", frmt='bi'), self)
self.cmb_plt_time_stim = QComboBox(self)
qcmb_box_populate(self.cmb_plt_time_stim, self.plot_styles_list,
self.plt_time_stim)
self.cmb_plt_time_stim.setToolTip(
"<span>Plot style for stimulus.</span>")
self.lbl_plt_time_stmq = QLabel(
to_html(" Fixp. Stim. x_Q", frmt='bi'), self)
self.cmb_plt_time_stmq = QComboBox(self)
qcmb_box_populate(self.cmb_plt_time_stmq, self.plot_styles_list,
self.plt_time_stmq)
self.cmb_plt_time_stmq.setToolTip(
"<span>Plot style for <em>fixpoint</em> "
"(quantized) stimulus.</span>")
lbl_plt_time_resp = QLabel(to_html(" Resp. y", frmt='bi'),
self)
self.cmb_plt_time_resp = QComboBox(self)
qcmb_box_populate(self.cmb_plt_time_resp, self.plot_styles_list,
self.plt_time_resp)
self.cmb_plt_time_resp.setToolTip(
"<span>Plot style for response.</span>")
self.lbl_win_time = QLabel(to_html(" Win", frmt='bi'), self)
self.chk_win_time = QCheckBox(self)
self.chk_win_time.setObjectName("chk_win_time")
self.chk_win_time.setToolTip(
'<span>Plot FFT windowing function.</span>')
self.chk_win_time.setChecked(False)
line1 = QVLine()
line2 = QVLine(width=5)
self.but_log_time = PushButton(" dB")
self.but_log_time.setObjectName("but_log_time")
self.but_log_time.setToolTip(
"<span>Logarithmic scale for y-axis.</span>")
lbl_plt_time_spgr = QLabel(to_html("Spectrogram", frmt='bi'), self)
self.cmb_plt_time_spgr = QComboBox(self)
qcmb_box_populate(self.cmb_plt_time_spgr, self.cmb_time_spgr_items,
self.plt_time_spgr)
spgr_en = self.plt_time_spgr != "none"
self.cmb_mode_spgr_time = QComboBox(self)
qcmb_box_populate(self.cmb_mode_spgr_time,
self.cmb_mode_spgr_time_items, self.mode_spgr_time)
self.cmb_mode_spgr_time.setVisible(spgr_en)
self.lbl_byfs_spgr_time = QLabel(to_html(" per f_S", frmt='b'),
self)
self.lbl_byfs_spgr_time.setVisible(spgr_en)
self.chk_byfs_spgr_time = QCheckBox(self)
self.chk_byfs_spgr_time.setObjectName("chk_log_spgr")
self.chk_byfs_spgr_time.setToolTip("<span>Display spectral density "
"i.e. scale by f_S</span>")
self.chk_byfs_spgr_time.setChecked(True)
self.chk_byfs_spgr_time.setVisible(spgr_en)
self.but_log_spgr_time = QPushButton("dB")
self.but_log_spgr_time.setMaximumWidth(qtext_width(text=" dB"))
self.but_log_spgr_time.setObjectName("but_log_spgr")
self.but_log_spgr_time.setToolTip(
"<span>Logarithmic scale for spectrogram.</span>")
self.but_log_spgr_time.setCheckable(True)
self.but_log_spgr_time.setChecked(True)
self.but_log_spgr_time.setVisible(spgr_en)
self.lbl_time_nfft_spgr = QLabel(to_html(" N_FFT =", frmt='bi'),
self)
self.lbl_time_nfft_spgr.setVisible(spgr_en)
self.led_time_nfft_spgr = QLineEdit(self)
self.led_time_nfft_spgr.setText(str(self.time_nfft_spgr))
self.led_time_nfft_spgr.setToolTip("<span>Number of FFT points per "
"spectrogram segment.</span>")
self.led_time_nfft_spgr.setVisible(spgr_en)
self.lbl_time_ovlp_spgr = QLabel(to_html(" N_OVLP =", frmt='bi'),
self)
self.lbl_time_ovlp_spgr.setVisible(spgr_en)
self.led_time_ovlp_spgr = QLineEdit(self)
self.led_time_ovlp_spgr.setText(str(self.time_ovlp_spgr))
self.led_time_ovlp_spgr.setToolTip(
"<span>Number of overlap data points "
"between spectrogram segments.</span>")
self.led_time_ovlp_spgr.setVisible(spgr_en)
self.lbl_log_bottom_time = QLabel(to_html("min =", frmt='bi'), self)
self.led_log_bottom_time = QLineEdit(self)
self.led_log_bottom_time.setText(str(self.bottom_t))
self.led_log_bottom_time.setMaximumWidth(qtext_width(N_x=8))
self.led_log_bottom_time.setToolTip(
"<span>Minimum display value for time and spectrogram plots with log. scale."
"</span>")
self.lbl_log_bottom_time.setVisible(
self.but_log_time.isChecked()
or (spgr_en and self.but_log_spgr_time.isChecked()))
self.led_log_bottom_time.setVisible(
self.lbl_log_bottom_time.isVisible())
# self.lbl_colorbar_time = QLabel(to_html(" Col.bar", frmt='b'), self)
# self.lbl_colorbar_time.setVisible(spgr_en)
# self.chk_colorbar_time = QCheckBox(self)
# self.chk_colorbar_time.setObjectName("chk_colorbar_time")
# self.chk_colorbar_time.setToolTip("<span>Enable colorbar</span>")
# self.chk_colorbar_time.setChecked(True)
# self.chk_colorbar_time.setVisible(spgr_en)
layH_ctrl_time = QHBoxLayout()
layH_ctrl_time.addWidget(self.lbl_plt_time_stim)
layH_ctrl_time.addWidget(self.cmb_plt_time_stim)
#
layH_ctrl_time.addWidget(self.lbl_plt_time_stmq)
layH_ctrl_time.addWidget(self.cmb_plt_time_stmq)
#
layH_ctrl_time.addWidget(lbl_plt_time_resp)
layH_ctrl_time.addWidget(self.cmb_plt_time_resp)
#
layH_ctrl_time.addWidget(self.lbl_win_time)
layH_ctrl_time.addWidget(self.chk_win_time)
layH_ctrl_time.addSpacing(5)
layH_ctrl_time.addWidget(line1)
layH_ctrl_time.addSpacing(5)
#
layH_ctrl_time.addWidget(self.lbl_log_bottom_time)
layH_ctrl_time.addWidget(self.led_log_bottom_time)
layH_ctrl_time.addWidget(self.but_log_time)
layH_ctrl_time.addSpacing(5)
layH_ctrl_time.addWidget(line2)
layH_ctrl_time.addSpacing(5)
#
layH_ctrl_time.addWidget(lbl_plt_time_spgr)
layH_ctrl_time.addWidget(self.cmb_plt_time_spgr)
layH_ctrl_time.addWidget(self.cmb_mode_spgr_time)
layH_ctrl_time.addWidget(self.lbl_byfs_spgr_time)
layH_ctrl_time.addWidget(self.chk_byfs_spgr_time)
layH_ctrl_time.addWidget(self.but_log_spgr_time)
layH_ctrl_time.addWidget(self.lbl_time_nfft_spgr)
layH_ctrl_time.addWidget(self.led_time_nfft_spgr)
layH_ctrl_time.addWidget(self.lbl_time_ovlp_spgr)
layH_ctrl_time.addWidget(self.led_time_ovlp_spgr)
layH_ctrl_time.addStretch(10)
# layH_ctrl_time.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_time = QWidget(self)
self.wdg_ctrl_time.setLayout(layH_ctrl_time)
# ---- end time domain ------------------
# ---------------------------------------------------------------
# Controls for frequency domain
# ---------------------------------------------------------------
self.lbl_plt_freq_stim = QLabel(to_html("Stimulus X", frmt='bi'), self)
self.cmb_plt_freq_stim = QComboBox(self)
qcmb_box_populate(self.cmb_plt_freq_stim, self.plot_styles_list,
self.plt_freq_stim)
self.cmb_plt_freq_stim.setToolTip(
"<span>Plot style for stimulus.</span>")
self.lbl_plt_freq_stmq = QLabel(
to_html(" Fixp. Stim. X_Q", frmt='bi'), self)
self.cmb_plt_freq_stmq = QComboBox(self)
qcmb_box_populate(self.cmb_plt_freq_stmq, self.plot_styles_list,
self.plt_freq_stmq)
self.cmb_plt_freq_stmq.setToolTip(
"<span>Plot style for <em>fixpoint</em> (quantized) stimulus.</span>"
)
lbl_plt_freq_resp = QLabel(to_html(" Response Y", frmt='bi'),
self)
self.cmb_plt_freq_resp = QComboBox(self)
qcmb_box_populate(self.cmb_plt_freq_resp, self.plot_styles_list,
self.plt_freq_resp)
self.cmb_plt_freq_resp.setToolTip(
"<span>Plot style for response.</span>")
self.but_log_freq = QPushButton("dB")
self.but_log_freq.setMaximumWidth(qtext_width(" dB"))
self.but_log_freq.setObjectName(".but_log_freq")
self.but_log_freq.setToolTip(
"<span>Logarithmic scale for y-axis.</span>")
self.but_log_freq.setCheckable(True)
self.but_log_freq.setChecked(True)
self.lbl_log_bottom_freq = QLabel(to_html("min =", frmt='bi'), self)
self.lbl_log_bottom_freq.setVisible(self.but_log_freq.isChecked())
self.led_log_bottom_freq = QLineEdit(self)
self.led_log_bottom_freq.setText(str(self.bottom_f))
self.led_log_bottom_freq.setMaximumWidth(qtext_width(N_x=8))
self.led_log_bottom_freq.setToolTip(
"<span>Minimum display value for log. scale.</span>")
self.led_log_bottom_freq.setVisible(self.but_log_freq.isChecked())
if not self.but_log_freq.isChecked():
self.bottom_f = 0
self.cmb_freq_display = QComboBox(self)
qcmb_box_populate(self.cmb_freq_display, self.cmb_freq_display_items,
self.cmb_freq_display_item)
self.cmb_freq_display.setObjectName("cmb_re_im_freq")
self.but_Hf = QPushButtonRT(self, to_html("H_id", frmt="bi"), margin=5)
self.but_Hf.setObjectName("chk_Hf")
self.but_Hf.setToolTip(
"<span>Show ideal frequency response, calculated "
"from the filter coefficients.</span>")
self.but_Hf.setChecked(False)
self.but_Hf.setCheckable(True)
self.but_freq_norm_impz = QPushButtonRT(
text="<b><i>E<sub>X</sub></i> = 1</b>", margin=5)
self.but_freq_norm_impz.setToolTip(
"<span>Normalize the FFT of the stimulus with <i>N<sub>FFT</sub></i> for "
"<i>E<sub>X</sub></i> = 1. For a dirac pulse, this yields "
"|<i>Y(f)</i>| = |<i>H(f)</i>|. DC and Noise need to be "
"turned off, window should be <b>Rectangular</b>.</span>")
self.but_freq_norm_impz.setCheckable(True)
self.but_freq_norm_impz.setChecked(True)
self.but_freq_norm_impz.setObjectName("freq_norm_impz")
self.but_freq_show_info = QPushButton("Info", self)
self.but_freq_show_info.setMaximumWidth(qtext_width(" Info "))
self.but_freq_show_info.setObjectName("but_show_info_freq")
self.but_freq_show_info.setToolTip(
"<span>Show signal power in legend.</span>")
self.but_freq_show_info.setCheckable(True)
self.but_freq_show_info.setChecked(False)
layH_ctrl_freq = QHBoxLayout()
layH_ctrl_freq.addWidget(self.lbl_plt_freq_stim)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_stim)
#
layH_ctrl_freq.addWidget(self.lbl_plt_freq_stmq)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_stmq)
#
layH_ctrl_freq.addWidget(lbl_plt_freq_resp)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_resp)
#
layH_ctrl_freq.addSpacing(5)
layH_ctrl_freq.addWidget(self.but_Hf)
layH_ctrl_freq.addStretch(1)
#
layH_ctrl_freq.addWidget(self.lbl_log_bottom_freq)
layH_ctrl_freq.addWidget(self.led_log_bottom_freq)
layH_ctrl_freq.addWidget(self.but_log_freq)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(self.cmb_freq_display)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(self.but_freq_norm_impz)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(self.but_freq_show_info)
layH_ctrl_freq.addStretch(10)
# layH_ctrl_freq.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_freq = QWidget(self)
self.wdg_ctrl_freq.setLayout(layH_ctrl_freq)
# ---- end Frequency Domain ------------------
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
# connect FFT widget to qfft_selector and vice versa and to and signals upstream:
self.fft_widget.sig_tx.connect(self.process_sig_rx)
self.qfft_win_select.sig_tx.connect(self.process_sig_rx)
# connect process_sig_rx output to both FFT widgets
self.sig_tx_fft.connect(self.fft_widget.sig_rx)
self.sig_tx_fft.connect(self.qfft_win_select.sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
# --- run control ---
self.led_N_start.editingFinished.connect(self.update_N)
self.led_N_points.editingFinished.connect(self.update_N)
self.led_N_frame.editingFinished.connect(self.update_N)
self.but_fft_wdg.clicked.connect(self.toggle_fft_wdg)
def _construct_UI(self):
# =====================================================================
# Controls for stimuli
# =====================================================================
self.cmbStimulus = QComboBox(self)
qcmb_box_populate(self.cmbStimulus, self.cmb_stim_items,
self.cmb_stim_item)
self.lblStimPar1 = QLabel(to_html("α =", frmt='b'), self)
self.ledStimPar1 = QLineEdit(self)
self.ledStimPar1.setText("0.5")
self.ledStimPar1.setToolTip("Duty Cycle, 0 ... 1")
self.ledStimPar1.setObjectName("ledStimPar1")
self.but_stim_bl = QPushButton(self)
self.but_stim_bl.setText("BL")
self.but_stim_bl.setToolTip(
"<span>Bandlimit the signal to the Nyquist "
"frequency to avoid aliasing. However, this is much slower "
"to calculate especially for a large number of points.</span>")
self.but_stim_bl.setMaximumWidth(qtext_width(text="BL "))
self.but_stim_bl.setCheckable(True)
self.but_stim_bl.setChecked(True)
self.but_stim_bl.setObjectName("stim_bl")
# -------------------------------------
self.cmbChirpType = QComboBox(self)
qcmb_box_populate(self.cmbChirpType, self.cmb_stim_chirp_items,
self.chirp_type)
self.cmbImpulseType = QComboBox(self)
qcmb_box_populate(self.cmbImpulseType, self.cmb_stim_impulse_items,
self.impulse_type)
self.cmbSinusoidType = QComboBox(self)
qcmb_box_populate(self.cmbSinusoidType, self.cmb_stim_sinusoid_items,
self.sinusoid_type)
self.cmbPeriodicType = QComboBox(self)
qcmb_box_populate(self.cmbPeriodicType, self.cmb_stim_periodic_items,
self.cmb_stim_periodic_item)
self.cmbModulationType = QComboBox(self)
for t in [("AM", "am"), ("PM / FM", "pmfm")]: # text, data
self.cmbModulationType.addItem(*t)
qset_cmb_box(self.cmbModulationType, self.modulation_type, data=True)
# -------------------------------------
self.chk_step_err = QPushButton("Error", self)
self.chk_step_err.setToolTip(
"<span>Display the step response error.</span>")
self.chk_step_err.setMaximumWidth(qtext_width(text="Error "))
self.chk_step_err.setCheckable(True)
self.chk_step_err.setChecked(False)
self.chk_step_err.setObjectName("stim_step_err")
layHCmbStim = QHBoxLayout()
layHCmbStim.addWidget(self.cmbStimulus)
layHCmbStim.addWidget(self.cmbImpulseType)
layHCmbStim.addWidget(self.cmbSinusoidType)
layHCmbStim.addWidget(self.cmbChirpType)
layHCmbStim.addWidget(self.cmbPeriodicType)
layHCmbStim.addWidget(self.cmbModulationType)
layHCmbStim.addWidget(self.but_stim_bl)
layHCmbStim.addWidget(self.lblStimPar1)
layHCmbStim.addWidget(self.ledStimPar1)
layHCmbStim.addWidget(self.chk_step_err)
self.lblDC = QLabel(to_html("DC =", frmt='bi'), self)
self.ledDC = QLineEdit(self)
self.ledDC.setText(str(self.DC))
self.ledDC.setToolTip("DC Level")
self.ledDC.setObjectName("stimDC")
layHStimDC = QHBoxLayout()
layHStimDC.addWidget(self.lblDC)
layHStimDC.addWidget(self.ledDC)
# ======================================================================
self.lblAmp1 = QLabel(to_html(" A_1", frmt='bi') + " =", self)
self.ledAmp1 = QLineEdit(self)
self.ledAmp1.setText(str(self.A1))
self.ledAmp1.setToolTip(
"Stimulus amplitude, complex values like 3j - 1 are allowed")
self.ledAmp1.setObjectName("stimAmp1")
self.lblAmp2 = QLabel(to_html(" A_2", frmt='bi') + " =", self)
self.ledAmp2 = QLineEdit(self)
self.ledAmp2.setText(str(self.A2))
self.ledAmp2.setToolTip(
"Stimulus amplitude 2, complex values like 3j - 1 are allowed")
self.ledAmp2.setObjectName("stimAmp2")
# ----------------------------------------------
self.lblPhi1 = QLabel(to_html(" φ_1", frmt='bi') + " =", self)
self.ledPhi1 = QLineEdit(self)
self.ledPhi1.setText(str(self.phi1))
self.ledPhi1.setToolTip("Stimulus phase")
self.ledPhi1.setObjectName("stimPhi1")
self.lblPhU1 = QLabel(to_html("°", frmt='b'), self)
self.lblPhi2 = QLabel(to_html(" φ_2", frmt='bi') + " =", self)
self.ledPhi2 = QLineEdit(self)
self.ledPhi2.setText(str(self.phi2))
self.ledPhi2.setToolTip("Stimulus phase 2")
self.ledPhi2.setObjectName("stimPhi2")
self.lblPhU2 = QLabel(to_html("°", frmt='b'), self)
# ----------------------------------------------
self.lbl_T1 = QLabel(to_html(" T_1", frmt='bi') + " =", self)
self.led_T1 = QLineEdit(self)
self.led_T1.setText(str(self.T1))
self.led_T1.setToolTip("Time shift")
self.led_T1.setObjectName("stimT1")
self.lbl_TU1 = QLabel(to_html("T_S", frmt='b'), self)
self.lbl_T2 = QLabel(to_html(" T_2", frmt='bi') + " =", self)
self.led_T2 = QLineEdit(self)
self.led_T2.setText(str(self.T2))
self.led_T2.setToolTip("Time shift 2")
self.led_T2.setObjectName("stimT2")
self.lbl_TU2 = QLabel(to_html("T_S", frmt='b'), self)
# ---------------------------------------------
self.lbl_TW1 = QLabel(
to_html(" ΔT_1", frmt='bi') + " =", self)
self.led_TW1 = QLineEdit(self)
self.led_TW1.setText(str(self.TW1))
self.led_TW1.setToolTip("Time width")
self.led_TW1.setObjectName("stimTW1")
self.lbl_TWU1 = QLabel(to_html("T_S", frmt='b'), self)
self.lbl_TW2 = QLabel(
to_html(" ΔT_2", frmt='bi') + " =", self)
self.led_TW2 = QLineEdit(self)
self.led_TW2.setText(str(self.TW2))
self.led_TW2.setToolTip("Time width 2")
self.led_TW2.setObjectName("stimTW2")
self.lbl_TWU2 = QLabel(to_html("T_S", frmt='b'), self)
# ----------------------------------------------
self.txtFreq1_f = to_html(" f_1", frmt='bi') + " ="
self.txtFreq1_k = to_html(" k_1", frmt='bi') + " ="
self.lblFreq1 = QLabel(self.txtFreq1_f, self)
self.ledFreq1 = QLineEdit(self)
self.ledFreq1.setText(str(self.f1))
self.ledFreq1.setToolTip("Stimulus frequency")
self.ledFreq1.setObjectName("stimFreq1")
self.lblFreqUnit1 = QLabel("f_S", self)
self.txtFreq2_f = to_html(" f_2", frmt='bi') + " ="
self.txtFreq2_k = to_html(" k_2", frmt='bi') + " ="
self.lblFreq2 = QLabel(self.txtFreq2_f, self)
self.ledFreq2 = QLineEdit(self)
self.ledFreq2.setText(str(self.f2))
self.ledFreq2.setToolTip("Stimulus frequency 2")
self.ledFreq2.setObjectName("stimFreq2")
self.lblFreqUnit2 = QLabel("f_S", self)
# ----------------------------------------------
self.lbl_BW1 = QLabel(
to_html(self.tr(" BW_1"), frmt='bi') + " =", self)
self.led_BW1 = QLineEdit(self)
self.led_BW1.setText(str(self.BW1))
self.led_BW1.setToolTip(self.tr("Relative bandwidth"))
self.led_BW1.setObjectName("stimBW1")
self.lbl_BW2 = QLabel(
to_html(self.tr(" BW_2"), frmt='bi') + " =", self)
self.led_BW2 = QLineEdit(self)
self.led_BW2.setText(str(self.BW2))
self.led_BW2.setToolTip(self.tr("Relative bandwidth 2"))
self.led_BW2.setObjectName("stimBW2")
# ----------------------------------------------
self.lblNoise = QLabel(to_html(" Noise", frmt='bi'), self)
self.cmbNoise = QComboBox(self)
qcmb_box_populate(self.cmbNoise, self.cmb_stim_noise_items, self.noise)
self.lblNoi = QLabel("not initialized", self)
self.ledNoi = QLineEdit(self)
self.ledNoi.setText(str(self.noi))
self.ledNoi.setToolTip("not initialized")
self.ledNoi.setObjectName("stimNoi")
layGStim = QGridLayout()
layGStim.addLayout(layHCmbStim, 0, 1)
layGStim.addLayout(layHStimDC, 1, 1)
layGStim.addWidget(self.lblAmp1, 0, 2)
layGStim.addWidget(self.lblAmp2, 1, 2)
layGStim.addWidget(self.ledAmp1, 0, 3)
layGStim.addWidget(self.ledAmp2, 1, 3)
layGStim.addWidget(self.lblPhi1, 0, 4)
layGStim.addWidget(self.lblPhi2, 1, 4)
layGStim.addWidget(self.ledPhi1, 0, 5)
layGStim.addWidget(self.ledPhi2, 1, 5)
layGStim.addWidget(self.lblPhU1, 0, 6)
layGStim.addWidget(self.lblPhU2, 1, 6)
layGStim.addWidget(self.lbl_T1, 0, 7)
layGStim.addWidget(self.lbl_T2, 1, 7)
layGStim.addWidget(self.led_T1, 0, 8)
layGStim.addWidget(self.led_T2, 1, 8)
layGStim.addWidget(self.lbl_TU1, 0, 9)
layGStim.addWidget(self.lbl_TU2, 1, 9)
layGStim.addWidget(self.lbl_TW1, 0, 10)
layGStim.addWidget(self.lbl_TW2, 1, 10)
layGStim.addWidget(self.led_TW1, 0, 11)
layGStim.addWidget(self.led_TW2, 1, 11)
layGStim.addWidget(self.lbl_TWU1, 0, 12)
layGStim.addWidget(self.lbl_TWU2, 1, 12)
layGStim.addWidget(self.lblFreq1, 0, 13)
layGStim.addWidget(self.lblFreq2, 1, 13)
layGStim.addWidget(self.ledFreq1, 0, 14)
layGStim.addWidget(self.ledFreq2, 1, 14)
layGStim.addWidget(self.lblFreqUnit1, 0, 15)
layGStim.addWidget(self.lblFreqUnit2, 1, 15)
layGStim.addWidget(self.lbl_BW1, 0, 16)
layGStim.addWidget(self.lbl_BW2, 1, 16)
layGStim.addWidget(self.led_BW1, 0, 17)
layGStim.addWidget(self.led_BW2, 1, 17)
layGStim.addWidget(self.lblNoise, 0, 18)
layGStim.addWidget(self.lblNoi, 1, 18)
layGStim.addWidget(self.cmbNoise, 0, 19)
layGStim.addWidget(self.ledNoi, 1, 19)
# ----------------------------------------------
self.lblStimFormula = QLabel(to_html("x =", frmt='bi'), self)
self.ledStimFormula = QLineEdit(self)
self.ledStimFormula.setText(str(self.stim_formula))
self.ledStimFormula.setToolTip(
"<span>Enter formula for stimulus in numexpr syntax.</span>")
self.ledStimFormula.setObjectName("stimFormula")
layH_stim_formula = QHBoxLayout()
layH_stim_formula.addWidget(self.lblStimFormula)
layH_stim_formula.addWidget(self.ledStimFormula, 10)
# ----------------------------------------------------------------------
# Main Widget
# ----------------------------------------------------------------------
layH_stim_par = QHBoxLayout()
layH_stim_par.addLayout(layGStim)
layV_stim = QVBoxLayout()
layV_stim.addLayout(layH_stim_par)
layV_stim.addLayout(layH_stim_formula)
layH_stim = QHBoxLayout()
layH_stim.addLayout(layV_stim)
layH_stim.addStretch(10)
self.wdg_stim = QWidget(self)
self.wdg_stim.setLayout(layH_stim)
self.wdg_stim.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# ----------------------------------------------------------------------
# Event Filter
# ----------------------------------------------------------------------
# frequency related widgets are scaled with f_s, requiring special handling
self.ledFreq1.installEventFilter(self)
self.ledFreq2.installEventFilter(self)
self.led_T1.installEventFilter(self)
self.led_T2.installEventFilter(self)
self.led_TW1.installEventFilter(self)
self.led_TW2.installEventFilter(self)
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
# --- stimulus control ---
self.but_stim_bl.clicked.connect(self._enable_stim_widgets)
self.chk_step_err.clicked.connect(self._enable_stim_widgets)
self.cmbStimulus.currentIndexChanged.connect(self._enable_stim_widgets)
self.cmbNoise.currentIndexChanged.connect(self._update_noi)
self.ledNoi.editingFinished.connect(self._update_noi)
self.ledAmp1.editingFinished.connect(self._update_amp1)
self.ledAmp2.editingFinished.connect(self._update_amp2)
self.ledPhi1.editingFinished.connect(self._update_phi1)
self.ledPhi2.editingFinished.connect(self._update_phi2)
self.led_BW1.editingFinished.connect(self._update_BW1)
self.led_BW2.editingFinished.connect(self._update_BW2)
self.cmbImpulseType.currentIndexChanged.connect(
self._update_impulse_type)
self.cmbSinusoidType.currentIndexChanged.connect(
self._update_sinusoid_type)
self.cmbChirpType.currentIndexChanged.connect(self._update_chirp_type)
self.cmbPeriodicType.currentIndexChanged.connect(
self._update_periodic_type)
self.cmbModulationType.currentIndexChanged.connect(
self._update_modulation_type)
self.ledDC.editingFinished.connect(self._update_DC)
self.ledStimFormula.editingFinished.connect(self._update_stim_formula)
self.ledStimPar1.editingFinished.connect(self._update_stim_par1)
def _construct_UI(self, **kwargs):
""" Construct widget """
dict_ui = {
'wdg_name': 'ui_q',
'label': '',
'label_q': 'Quant.',
'tip_q': 'Select the kind of quantization.',
'cmb_q': ['round', 'fix', 'floor'],
'cur_q': 'round',
'label_ov': 'Ovfl.',
'tip_ov': 'Select overflow behaviour.',
'cmb_ov': ['wrap', 'sat'],
'cur_ov': 'wrap',
'enabled': True,
'visible': True
} #: default widget settings
if 'quant' in self.q_dict and self.q_dict['quant'] in dict_ui['cmb_q']:
dict_ui['cur_q'] = self.q_dict['quant']
if 'ovfl' in self.q_dict and self.q_dict['ovfl'] in dict_ui['cmb_ov']:
dict_ui['cur_ov'] = self.q_dict['ovfl']
for key, val in kwargs.items():
dict_ui.update({key: val})
# dict_ui.update(map(kwargs)) # same as above?
self.wdg_name = dict_ui['wdg_name']
lblQuant = QLabel(dict_ui['label_q'], self)
self.cmbQuant = QComboBox(self)
self.cmbQuant.addItems(dict_ui['cmb_q'])
qset_cmb_box(self.cmbQuant, dict_ui['cur_q'])
self.cmbQuant.setToolTip(dict_ui['tip_q'])
self.cmbQuant.setObjectName('quant')
lblOvfl = QLabel(dict_ui['label_ov'], self)
self.cmbOvfl = QComboBox(self)
self.cmbOvfl.addItems(dict_ui['cmb_ov'])
qset_cmb_box(self.cmbOvfl, dict_ui['cur_ov'])
self.cmbOvfl.setToolTip(dict_ui['tip_ov'])
self.cmbOvfl.setObjectName('ovfl')
# ComboBox size is adjusted automatically to fit the longest element
self.cmbQuant.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmbOvfl.setSizeAdjustPolicy(QComboBox.AdjustToContents)
layH = QHBoxLayout()
if dict_ui['label'] != "":
lblW = QLabel(to_html(dict_ui['label'], frmt='bi'), self)
layH.addWidget(lblW)
layH.addStretch()
layH.addWidget(lblOvfl)
layH.addWidget(self.cmbOvfl)
# layH.addStretch(1)
layH.addWidget(lblQuant)
layH.addWidget(self.cmbQuant)
layH.setContentsMargins(0, 0, 0, 0)
frmMain = QFrame(self)
frmMain.setLayout(layH)
layVMain = QVBoxLayout() # Widget main layout
layVMain.addWidget(frmMain)
layVMain.setContentsMargins(0, 0, 0, 0) # *params['wdg_margins'])
self.setLayout(layVMain)
# ----------------------------------------------------------------------
# INITIAL SETTINGS
# ----------------------------------------------------------------------
self.ovfl = qget_cmb_box(self.cmbOvfl, data=False)
self.quant = qget_cmb_box(self.cmbQuant, data=False)
frmMain.setEnabled(dict_ui['enabled'])
frmMain.setVisible(dict_ui['visible'])
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.cmbOvfl.currentIndexChanged.connect(self.ui2dict)
self.cmbQuant.currentIndexChanged.connect(self.ui2dict)
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- Matplotlib widget with NavigationToolbar
- Frame with control elements
"""
self.lbl_overlay = QLabel(to_html("Overlay:", frmt='bi'), self)
self.cmb_overlay = QComboBox(self)
qcmb_box_populate(
self.cmb_overlay, self.cmb_overlay_items, self.cmb_overlay_default)
self.but_log = PushButton(" Log.", checked=True)
self.but_log.setObjectName("but_log")
self.but_log.setToolTip("<span>Log. scale for overlays.</span>")
self.diaRad_Hf = QDial(self)
self.diaRad_Hf.setRange(2, 10)
self.diaRad_Hf.setValue(2)
self.diaRad_Hf.setTracking(False) # produce less events when turning
self.diaRad_Hf.setFixedHeight(30)
self.diaRad_Hf.setFixedWidth(30)
self.diaRad_Hf.setWrapping(False)
self.diaRad_Hf.setToolTip("<span>Set max. radius for |H(f)| plot.</span>")
self.lblRad_Hf = QLabel("Radius", self)
self.lblBottom = QLabel(to_html("Bottom =", frmt='bi'), self)
self.ledBottom = QLineEdit(self)
self.ledBottom.setObjectName("ledBottom")
self.ledBottom.setText(str(self.zmin))
self.ledBottom.setMaximumWidth(qtext_width(N_x=8))
self.ledBottom.setToolTip("Minimum display value.")
self.lblBottomdB = QLabel("dB", self)
self.lblBottomdB.setVisible(self.but_log.isChecked())
self.lblTop = QLabel(to_html("Top =", frmt='bi'), self)
self.ledTop = QLineEdit(self)
self.ledTop.setObjectName("ledTop")
self.ledTop.setText(str(self.zmax))
self.ledTop.setToolTip("Maximum display value.")
self.ledTop.setMaximumWidth(qtext_width(N_x=8))
self.lblTopdB = QLabel("dB", self)
self.lblTopdB.setVisible(self.but_log.isChecked())
self.but_fir_poles = PushButton(" FIR Poles ", checked=True)
self.but_fir_poles.setToolTip("<span>Show FIR poles at the origin.</span>")
layHControls = QHBoxLayout()
layHControls.addWidget(self.lbl_overlay)
layHControls.addWidget(self.cmb_overlay)
layHControls.addWidget(self.but_log)
layHControls.addWidget(self.diaRad_Hf)
layHControls.addWidget(self.lblRad_Hf)
layHControls.addWidget(self.lblTop)
layHControls.addWidget(self.ledTop)
layHControls.addWidget(self.lblTopdB)
layHControls.addWidget(self.lblBottom)
layHControls.addWidget(self.ledBottom)
layHControls.addWidget(self.lblBottomdB)
layHControls.addStretch(10)
layHControls.addWidget(self.but_fir_poles)
# ----------------------------------------------------------------------
# ### frmControls ###
#
# This widget encompasses all control subwidgets
# ----------------------------------------------------------------------
self.frmControls = QFrame(self)
self.frmControls.setObjectName("frmControls")
self.frmControls.setLayout(layHControls)
# ----------------------------------------------------------------------
# ### mplwidget ###
#
# main widget, encompassing the other widgets
# ----------------------------------------------------------------------
self.mplwidget = MplWidget(self)
self.mplwidget.layVMainMpl.addWidget(self.frmControls)
self.mplwidget.layVMainMpl.setContentsMargins(*params['wdg_margins'])
self.mplwidget.mplToolbar.a_he.setEnabled(True)
self.mplwidget.mplToolbar.a_he.info = "manual/plot_pz.html"
self.setLayout(self.mplwidget.layVMainMpl)
self.init_axes()
self._log_clicked() # calculate and draw poles and zeros
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.mplwidget.mplToolbar.sig_tx.connect(self.process_sig_rx)
self.cmb_overlay.currentIndexChanged.connect(self.draw)
self.but_log.clicked.connect(self._log_clicked)
self.ledBottom.editingFinished.connect(self._log_clicked)
self.ledTop.editingFinished.connect(self._log_clicked)
self.diaRad_Hf.valueChanged.connect(self.draw)
self.but_fir_poles.clicked.connect(self.draw)
def _construct_ui(self):
"""
Define and construct the subwidgets
"""
modes = ['| H |', 're{H}', 'im{H}']
self.cmbShowH = QComboBox(self)
self.cmbShowH.addItems(modes)
self.cmbShowH.setObjectName("cmbUnitsH")
self.cmbShowH.setToolTip(
"Show magnitude, real / imag. part of H or H \n"
"without linear phase (acausal system).")
self.cmbShowH.setCurrentIndex(0)
self.lblIn = QLabel("in", self)
units = ['dB', 'V', 'W', 'Auto']
self.cmbUnitsA = QComboBox(self)
self.cmbUnitsA.addItems(units)
self.cmbUnitsA.setObjectName("cmbUnitsA")
self.cmbUnitsA.setToolTip(
"<span>Set unit for y-axis:\n"
"dB is attenuation (positive values), V and W are gain (less than 1).</span>"
)
self.cmbUnitsA.setCurrentIndex(0)
self.lbl_log_bottom = QLabel("Bottom", self)
self.led_log_bottom = QLineEdit(self)
self.led_log_bottom.setText(str(self.log_bottom))
self.led_log_bottom.setToolTip(
"<span>Minimum display value for dB. scale.</span>")
self.lbl_log_unit = QLabel("dB", self)
self.cmbShowH.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmbUnitsA.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.chkZerophase = QCheckBox("Zero phase", self)
self.chkZerophase.setToolTip(
"<span>Remove linear phase calculated from filter order.\n"
"Attention: This makes no sense for a non-linear phase system!</span>"
)
self.lblInset = QLabel("Inset", self)
self.cmbInset = QComboBox(self)
self.cmbInset.addItems(['off', 'edit', 'fixed'])
self.cmbInset.setObjectName("cmbInset")
self.cmbInset.setToolTip("Display/edit second inset plot")
self.cmbInset.setCurrentIndex(0)
self.inset_idx = 0 # store previous index for comparison
self.chkSpecs = QCheckBox("Specs", self)
self.chkSpecs.setChecked(False)
self.chkSpecs.setToolTip("Display filter specs as hatched regions")
self.chkPhase = QCheckBox("Phase", self)
self.chkPhase.setToolTip("Overlay phase")
self.chkPhase.setChecked(False)
self.chkAlign = QCheckBox("Align", self)
self.chkAlign.setToolTip(
"<span>Try to align grids for magnitude and phase "
"(doesn't work in all cases).</span>")
self.chkAlign.setChecked(True)
self.chkAlign.setVisible(self.chkPhase.isChecked())
#----------------------------------------------------------------------
# ### frmControls ###
#
# This widget encompasses all control subwidgets
#----------------------------------------------------------------------
layHControls = QHBoxLayout()
layHControls.addStretch(10)
layHControls.addWidget(self.cmbShowH)
layHControls.addWidget(self.lblIn)
layHControls.addWidget(self.cmbUnitsA)
layHControls.addStretch(1)
layHControls.addWidget(self.lbl_log_bottom)
layHControls.addWidget(self.led_log_bottom)
layHControls.addWidget(self.lbl_log_unit)
layHControls.addStretch(1)
layHControls.addWidget(self.chkZerophase)
layHControls.addStretch(1)
layHControls.addWidget(self.lblInset)
layHControls.addWidget(self.cmbInset)
layHControls.addStretch(1)
layHControls.addWidget(self.chkSpecs)
layHControls.addStretch(1)
layHControls.addWidget(self.chkPhase)
layHControls.addWidget(self.chkAlign)
layHControls.addStretch(10)
self.frmControls = QFrame(self)
self.frmControls.setObjectName("frmControls")
self.frmControls.setLayout(layHControls)
#----------------------------------------------------------------------
# ### mplwidget ###
#
# main widget, encompassing the other widgets
#----------------------------------------------------------------------
self.mplwidget = MplWidget(self)
self.mplwidget.layVMainMpl.addWidget(self.frmControls)
self.mplwidget.layVMainMpl.setContentsMargins(*params['wdg_margins'])
self.mplwidget.mplToolbar.a_he.setEnabled(True)
self.mplwidget.mplToolbar.a_he.info = "manual/plot_hf.html"
self.setLayout(self.mplwidget.layVMainMpl)
self.init_axes()
self.draw() # calculate and draw |H(f)|
#----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.cmbUnitsA.currentIndexChanged.connect(self.draw)
self.led_log_bottom.editingFinished.connect(self.update_view)
self.cmbShowH.currentIndexChanged.connect(self.draw)
self.chkZerophase.clicked.connect(self.draw)
self.cmbInset.currentIndexChanged.connect(self.draw_inset)
self.chkSpecs.clicked.connect(self.draw)
self.chkPhase.clicked.connect(self.draw)
self.chkAlign.clicked.connect(self.draw)
self.mplwidget.mplToolbar.sig_tx.connect(self.process_sig_rx)
class EllipZeroPhz(QWidget):
# Since we are also using poles/residues -> let's force zpk
FRMT = 'zpk'
info = """
**Elliptic filters with zero phase**
(also known as Cauer filters) have the steepest rate of transition between the
frequency response’s passband and stopband of all IIR filters. This comes
at the expense of a constant ripple (equiripple) :math:`A_PB` and :math:`A_SB`
in both pass and stop band. Ringing of the step response is increased in
comparison to Chebychev filters.
As the passband ripple :math:`A_PB` approaches 0, the elliptical filter becomes
a Chebyshev type II filter. As the stopband ripple :math:`A_SB` approaches 0,
it becomes a Chebyshev type I filter. As both approach 0, becomes a Butterworth
filter (butter).
For the filter design, the order :math:`N`, minimum stopband attenuation
:math:`A_SB` and the critical frequency / frequencies :math:`F_PB` where the
gain first drops below the maximum passband ripple :math:`-A_PB` have to be specified.
The ``ellipord()`` helper routine calculates the minimum order :math:`N` and
critical passband frequency :math:`F_C` from pass and stop band specifications.
The Zero Phase Elliptic Filter squares an elliptic filter designed in
a way to produce the required Amplitude specifications. So initially the
amplitude specs design an elliptic filter with the square root of the amp specs.
The filter is then squared to produce a zero phase filter.
The filter coefficients are applied to the signal data in a backward and forward
time fashion. This filter can only be applied to stored signal data (not
real-time streaming data that comes in a forward time order).
We are forcing the order N of the filter to be even. This simplifies the poles/zeros
to be complex (no real values).
**Design routines:**
``scipy.signal.ellip()``, ``scipy.signal.ellipord()``
"""
sig_tx = pyqtSignal(object)
def __init__(self):
QWidget.__init__(self)
self.ft = 'IIR'
c = Common()
self.rt_dict = c.rt_base_iir
self.rt_dict_add = {
'COM': {
'man': {
'msg':
('a',
"Enter the filter order <b><i>N</i></b>, the minimum stop "
"band attenuation <b><i>A<sub>SB</sub></i></b> and frequency or "
"frequencies <b><i>F<sub>C</sub></i></b> where gain first drops "
"below the max passband ripple <b><i>-A<sub>PB</sub></i></b> ."
)
}
},
'LP': {
'man': {},
'min': {}
},
'HP': {
'man': {},
'min': {}
},
'BS': {
'man': {},
'min': {}
},
'BP': {
'man': {},
'min': {}
},
}
self.info_doc = []
self.info_doc.append('ellip()\n========')
self.info_doc.append(sig.ellip.__doc__)
self.info_doc.append('ellipord()\n==========')
self.info_doc.append(ellipord.__doc__)
#--------------------------------------------------------------------------
def construct_UI(self):
"""
Create additional subwidget(s) needed for filter design:
These subwidgets are instantiated dynamically when needed in
select_filter.py using the handle to the filter instance, fb.fil_inst.
"""
# =============================================================================
# self.chkComplex = QCheckBox("ComplexFilter", self)
# self.chkComplex.setToolTip("Designs BP or BS Filter for complex data.")
# self.chkComplex.setObjectName('wdg_lbl_el')
# self.chkComplex.setChecked(False)
#
# =============================================================================
self.butSave = QPushButton(self)
self.butSave.setText("SAVE")
self.butSave.setToolTip("Save filter in proprietary format")
#--------------------------------------------------
# Layout for filter optional subwidgets
self.layHWin = QHBoxLayout()
self.layHWin.setObjectName('wdg_layGWin')
#self.layHWin.addWidget(self.chkComplex)
self.layHWin.addWidget(self.butSave)
self.layHWin.addStretch()
self.layHWin.setContentsMargins(0, 0, 0, 0)
# Widget containing all subwidgets
self.wdg_fil = QWidget(self)
self.wdg_fil.setObjectName('wdg_fil')
self.wdg_fil.setLayout(self.layHWin)
self.butSave.clicked.connect(self.save_filter)
def _get_params(self, fil_dict):
"""
Translate parameters from the passed dictionary to instance
parameters, scaling / transforming them if needed.
For zero phase filter, we take square root of amplitude specs
since we later square filter. Define design around smallest amp spec
"""
# Frequencies are normalized to f_Nyq = f_S/2, ripple specs are in dB
self.analog = False # set to True for analog filters
self.manual = False # default is normal design
self.N = int(fil_dict['N'])
# force N to be even
if (self.N % 2) == 1:
self.N += 1
self.F_PB = fil_dict['F_PB'] * 2
self.F_SB = fil_dict['F_SB'] * 2
self.F_PB2 = fil_dict['F_PB2'] * 2
self.F_SB2 = fil_dict['F_SB2'] * 2
self.F_PBC = None
# find smallest spec'd linear value and rewrite dictionary
ampPB = fil_dict['A_PB']
ampSB = fil_dict['A_SB']
# take square roots of amp specs so resulting squared
# filter will meet specifications
if (ampPB < ampSB):
ampSB = sqrt(ampPB)
ampPB = sqrt(1 + ampPB) - 1
else:
ampPB = sqrt(1 + ampSB) - 1
ampSB = sqrt(ampSB)
self.A_PB = lin2unit(ampPB, 'IIR', 'A_PB', unit='dB')
self.A_SB = lin2unit(ampSB, 'IIR', 'A_SB', unit='dB')
#logger.warning("design with "+str(self.A_PB)+","+str(self.A_SB))
# ellip filter routines support only one amplitude spec for
# pass- and stop band each
if str(fil_dict['rt']) == 'BS':
fil_dict['A_PB2'] = self.A_PB
elif str(fil_dict['rt']) == 'BP':
fil_dict['A_SB2'] = self.A_SB
# partial fraction expansion to define residue vector
def _partial(self, k, p, z, norder):
# create diff array
diff = p - z
# now compute residual vector
cone = complex(1., 0.)
residues = zeros(norder, complex)
for i in range(norder):
residues[i] = k * (diff[i] / p[i])
for j in range(norder):
if (j != i):
residues[i] = residues[i] * (cone + diff[j] /
(p[i] - p[j]))
# now compute DC term for new expansion
sumRes = 0.
for i in range(norder):
sumRes = sumRes + residues[i].real
dc = k - sumRes
return (dc, residues)
#
# Take a causal filter and square it. The result has the square
# of the amplitude response of the input, and zero phase. Filter
# is noncausal.
# Input:
# k - gain in pole/zero form
# p - numpy array of poles
# z - numpy array of zeros
# g - gain in pole/residue form
# r - numpy array of residues
# nn- order of filter
# Output:
# kn - new gain (pole/zero)
# pn - new poles
# zn - new zeros (numpy array)
# gn - new gain (pole/residue)
# rn - new residues
def _sqCausal(self, k, p, z, g, r, nn):
# Anticausal poles have conjugate-reciprocal symmetry
# Starting anticausal residues are conjugates (adjusted below)
pA = conj(1. / p) # antiCausal poles
zA = conj(z) # antiCausal zeros (store reciprocal)
rA = conj(r) # antiCausal residues (to start)
rC = zeros(nn, complex)
# Adjust residues. Causal part first.
for j in range(nn):
# Evaluate the anticausal filter at each causal pole
tmpx = rA / (1. - p[j] / pA)
ztmp = g + sum(tmpx)
# Adjust residue
rC[j] = r[j] * ztmp
# anticausal residues are just conjugates of causal residues
# r3 = np.conj(r2)
# Compute the constant term
dc2 = (g + sum(r)) * g - sum(rC)
# Populate output (2nn elements)
gn = dc2.real
# Drop complex poles/residues in LHP, keep only UHP
pA = conj(p) #store AntiCasual pole (reciprocal)
p0 = zeros(int(nn / 2), complex)
r0 = zeros(int(nn / 2), complex)
cnt = 0
for j in range(nn):
if (p[j].imag > 0.0):
p0[cnt] = p[j]
r0[cnt] = rC[j]
cnt = cnt + 1
# Let operator know we squared filter
# logger.info('After squaring filter, order: '+str(nn*2))
# For now and our case, only store causal residues
# Filters are symmetric and can generate antiCausal residues
return (pA, zA, gn, p0, r0)
def _test_N(self):
"""
Warn the user if the calculated order is too high for a reasonable filter
design.
"""
if self.N > 30:
return qfilter_warning(self, self.N, "Zero-phase Elliptic")
else:
return True
# custom save of filter dictionary
def _save(self, fil_dict, arg):
"""
First design initial elliptic filter meeting sqRoot Amp specs;
- Then create residue vector from poles/zeros;
- Then square filter (k,p,z and dc,p,r) to get zero phase filter;
- Then Convert results of filter design to all available formats (pz, pr, ba, sos)
and store them in the global filter dictionary.
Corner frequencies and order calculated for minimum filter order are
also stored to allow for an easy subsequent manual filter optimization.
"""
fil_save(fil_dict, arg, self.FRMT, __name__)
# For min. filter order algorithms, update filter dict with calculated
# new values for filter order N and corner frequency(s) F_PBC
fil_dict['N'] = self.N
if str(fil_dict['fo']) == 'min':
if str(fil_dict['rt']) == 'LP' or str(fil_dict['rt']) == 'HP':
# HP or LP - single corner frequency
fil_dict['F_PB'] = self.F_PBC / 2.
else: # BP or BS - two corner frequencies
fil_dict['F_PB'] = self.F_PBC[0] / 2.
fil_dict['F_PB2'] = self.F_PBC[1] / 2.
# Now generate poles/residues for custom file save of new parameters
if (not self.manual):
z = fil_dict['zpk'][0]
p = fil_dict['zpk'][1]
k = fil_dict['zpk'][2]
n = len(z)
gain, residues = self._partial(k, p, z, n)
pA, zA, gn, pC, rC = self._sqCausal(k, p, z, gain, residues, n)
fil_dict['rpk'] = [rC, pC, gn]
# save antiCausal b,a (nonReciprocal) also [easier to compute h(n)
try:
fil_dict['baA'] = sig.zpk2tf(zA, pA, k)
except Exception as e:
logger.error(e)
# 'rpk' is our signal that this is a non-Causal filter with zero phase
# inserted into fil dictionary after fil_save and convert
# sig_tx -> select_filter -> filter_specs
self.sig_tx.emit({'sender': __name__, 'filt_changed': 'ellip_zero'})
#------------------------------------------------------------------------------
def save_filter(self):
file_filters = ("Text file pole/residue (*.txt_rpk)")
dlg = QFD(self)
# return selected file name (with or without extension) and filter (Linux: full text)
file_name, file_type = dlg.getSaveFileName_(caption="Save filter as",
directory=dirs.save_dir,
filter=file_filters)
file_name = str(file_name) # QString -> str() needed for Python 2.x
# Qt5 has QFileDialog.mimeTypeFilters(), but under Qt4 the mime type cannot
# be extracted reproducibly across file systems, so it is done manually:
for t in extract_file_ext(
file_filters): # get a list of file extensions
if t in str(file_type):
file_type = t # return the last matching extension
if file_name != "": # cancelled file operation returns empty string
# strip extension from returned file name (if any) + append file type:
file_name = os.path.splitext(file_name)[0] + file_type
file_type_err = False
try:
# save as a custom residue/pole text output for apply with custom tool
# make sure we have the residues
if 'rpk' in fb.fil[0]:
with io.open(file_name, 'w', encoding="utf8") as f:
self.file_dump(f)
else:
file_type_err = True
logger.error(
'Filter has no residues/poles, cannot save as *.txt_rpk file'
)
if not file_type_err:
logger.info('Successfully saved filter as\n\t"{0}"'.format(
file_name))
dirs.save_dir = os.path.dirname(file_name) # save new dir
except IOError as e:
logger.error('Failed saving "{0}"!\n{1}'.format(file_name, e))
#------------------------------------------------------------------------------
def file_dump(self, fOut):
"""
Dump file out in custom text format that apply tool can read to know filter coef's
"""
# Fixed format widths for integers and doubles
intw = '10'
dblW = 27
frcW = 20
# Fill up character string with filter output
filtStr = '# IIR filter\n'
# parameters that made filter (choose smallest eps)
# Amp is stored in Volts (linear units)
# the second amp terms aren't really used (for ellip filters)
FA_PB = fb.fil[0]['A_PB']
FA_SB = fb.fil[0]['A_SB']
FAmp = min(FA_PB, FA_SB)
# Freq terms in radians so move from -1:1 to -pi:pi
f_lim = fb.fil[0]['freqSpecsRange']
f_unit = fb.fil[0]['freq_specs_unit']
F_S = fb.fil[0]['f_S']
if fb.fil[0]['freq_specs_unit'] == 'f_S':
F_S = F_S * 2
F_SB = fb.fil[0]['F_SB'] * F_S * np.pi
F_SB2 = fb.fil[0]['F_SB2'] * F_S * np.pi
F_PB = fb.fil[0]['F_PB'] * F_S * np.pi
F_PB2 = fb.fil[0]['F_PB2'] * F_S * np.pi
# Determine pass/stop bands depending on filter response type
passMin = []
passMax = []
stopMin = []
stopMax = []
if fb.fil[0]['rt'] == 'LP':
passMin = [-F_PB, 0, 0]
passMax = [F_PB, 0, 0]
stopMin = [-np.pi, F_SB, 0]
stopMax = [-F_SB, np.pi, 0]
f1 = F_PB
f2 = F_SB
f3 = f4 = 0
Ftype = 1
Fname = 'Low_Pass'
if fb.fil[0]['rt'] == 'HP':
passMin = [-np.pi, F_PB, 0]
passMax = [-F_PB, np.pi, 0]
stopMin = [-F_SB, 0, 0]
stopMax = [F_SB, 0, 0]
f1 = F_SB
f2 = F_PB
f3 = f4 = 0
Ftype = 2
Fname = 'Hi_Pass'
if fb.fil[0]['rt'] == 'BS':
passMin = [-np.pi, -F_PB, F_PB2]
passMax = [-F_PB2, F_PB, np.pi]
stopMin = [-F_SB2, F_SB, 0]
stopMax = [-F_SB, F_SB2, 0]
f1 = F_PB
f2 = F_SB
f3 = F_SB2
f4 = F_PB2
Ftype = 4
Fname = 'Band_Stop'
if fb.fil[0]['rt'] == 'BP':
passMin = [-F_PB2, F_PB, 0]
passMax = [-F_PB, F_PB2, 0]
stopMin = [-np.pi, -F_SB, F_SB2]
stopMax = [-F_SB2, F_SB, np.pi]
f1 = F_SB
f2 = F_PB
f3 = F_PB2
f4 = F_SB2
Ftype = 3
Fname = 'Band_Pass'
filtStr = filtStr + '{:{align}{width}}'.format(
'10', align='>', width=intw) + ' IIRFILT_4SYM\n'
filtStr = filtStr + '{:{align}{width}}'.format(
str(Ftype), align='>', width=intw) + ' ' + Fname + '\n'
filtStr = filtStr + '{:{d}.{p}f}'.format(FAmp, d=dblW, p=frcW) + '\n'
filtStr = filtStr + '{: {d}.{p}f}'.format(passMin[0], d=dblW, p=frcW)
filtStr = filtStr + '{: {d}.{p}f}'.format(passMax[0], d=dblW,
p=frcW) + '\n'
filtStr = filtStr + '{: {d}.{p}f}'.format(passMin[1], d=dblW, p=frcW)
filtStr = filtStr + '{: {d}.{p}f}'.format(passMax[1], d=dblW,
p=frcW) + '\n'
filtStr = filtStr + '{: {d}.{p}f}'.format(passMin[2], d=dblW, p=frcW)
filtStr = filtStr + '{: {d}.{p}f}'.format(passMax[2], d=dblW,
p=frcW) + '\n'
filtStr = filtStr + '{: {d}.{p}f}'.format(stopMin[0], d=dblW, p=frcW)
filtStr = filtStr + '{: {d}.{p}f}'.format(stopMax[0], d=dblW,
p=frcW) + '\n'
filtStr = filtStr + '{: {d}.{p}f}'.format(stopMin[1], d=dblW, p=frcW)
filtStr = filtStr + '{: {d}.{p}f}'.format(stopMax[1], d=dblW,
p=frcW) + '\n'
filtStr = filtStr + '{: {d}.{p}f}'.format(stopMin[2], d=dblW, p=frcW)
filtStr = filtStr + '{: {d}.{p}f}'.format(stopMax[2], d=dblW,
p=frcW) + '\n'
filtStr = filtStr + '{: {d}.{p}f}'.format(f1, d=dblW, p=frcW)
filtStr = filtStr + '{: {d}.{p}f}'.format(f2, d=dblW, p=frcW) + '\n'
filtStr = filtStr + '{: {d}.{p}f}'.format(f3, d=dblW, p=frcW)
filtStr = filtStr + '{: {d}.{p}f}'.format(f4, d=dblW, p=frcW) + '\n'
# move pol/res/gain into terms we need
Fdc = fb.fil[0]['rpk'][2]
rC = fb.fil[0]['rpk'][0]
pC = fb.fil[0]['rpk'][1]
Fnum = len(pC)
# Gain term
filtStr = filtStr + '{: {d}.{p}e}'.format(Fdc, d=dblW, p=frcW) + '\n'
# Real pole count inside the unit circle (none of these)
filtStr = filtStr + '{:{align}{width}}'.format(
str(0), align='>', width=intw) + '\n'
# Complex pole/res count inside the unit circle
filtStr = filtStr + '{:{i}d}'.format(Fnum, i=intw) + '\n'
# Now dump poles/residues
for j in range(Fnum):
filtStr = filtStr + '{:{i}d}'.format(j, i=intw) + ' '
filtStr = filtStr + '{: {d}.{p}e}'.format(
rC[j].real, d=dblW, p=frcW) + ' '
filtStr = filtStr + '{: {d}.{p}e}'.format(
rC[j].imag, d=dblW, p=frcW) + ' '
filtStr = filtStr + '{: {d}.{p}e}'.format(
pC[j].real, d=dblW, p=frcW) + ' '
filtStr = filtStr + '{: {d}.{p}e}'.format(
pC[j].imag, d=dblW, p=frcW) + '\n'
# Real pole count outside the unit circle (none of these)
filtStr = filtStr + '{:{align}{width}}'.format(
str(0), align='>', width=intw) + '\n'
# Complex pole count outside the unit circle (none of these)
filtStr = filtStr + '{:{align}{width}}'.format(
str(0), align='>', width=intw) + '\n'
# Now write huge text string to file
fOut.write(filtStr)
#------------------------------------------------------------------------------
#
# DESIGN ROUTINES
#
#------------------------------------------------------------------------------
# LP: F_PB < F_stop -------------------------------------------------------
def LPmin(self, fil_dict):
"""Elliptic LP filter, minimum order"""
self._get_params(fil_dict)
self.N, self.F_PBC = ellipord(self.F_PB,
self.F_SB,
self.A_PB,
self.A_SB,
analog=self.analog)
# force even N
if (self.N % 2) == 1:
self.N += 1
if not self._test_N():
return -1
#logger.warning("and "+str(self.F_PBC) + " " + str(self.N))
self._save(
fil_dict,
sig.ellip(self.N,
self.A_PB,
self.A_SB,
self.F_PBC,
btype='low',
analog=self.analog,
output=self.FRMT))
def LPman(self, fil_dict):
"""Elliptic LP filter, manual order"""
self._get_params(fil_dict)
if not self._test_N():
return -1
self._save(
fil_dict,
sig.ellip(self.N,
self.A_PB,
self.A_SB,
self.F_PB,
btype='low',
analog=self.analog,
output=self.FRMT))
# HP: F_stop < F_PB -------------------------------------------------------
def HPmin(self, fil_dict):
"""Elliptic HP filter, minimum order"""
self._get_params(fil_dict)
self.N, self.F_PBC = ellipord(self.F_PB,
self.F_SB,
self.A_PB,
self.A_SB,
analog=self.analog)
# force even N
if (self.N % 2) == 1:
self.N += 1
if not self._test_N():
return -1
self._save(
fil_dict,
sig.ellip(self.N,
self.A_PB,
self.A_SB,
self.F_PBC,
btype='highpass',
analog=self.analog,
output=self.FRMT))
def HPman(self, fil_dict):
"""Elliptic HP filter, manual order"""
self._get_params(fil_dict)
if not self._test_N():
return -1
self._save(
fil_dict,
sig.ellip(self.N,
self.A_PB,
self.A_SB,
self.F_PB,
btype='highpass',
analog=self.analog,
output=self.FRMT))
# For BP and BS, F_XX have two elements each, A_XX has only one
# BP: F_SB[0] < F_PB[0], F_SB[1] > F_PB[1] --------------------------------
def BPmin(self, fil_dict):
"""Elliptic BP filter, minimum order"""
self._get_params(fil_dict)
self.N, self.F_PBC = ellipord([self.F_PB, self.F_PB2],
[self.F_SB, self.F_SB2],
self.A_PB,
self.A_SB,
analog=self.analog)
#logger.warning(" "+str(self.F_PBC) + " " + str(self.N))
if (self.N % 2) == 1:
self.N += 1
if not self._test_N():
return -1
#logger.warning("-"+str(self.F_PBC) + " " + str(self.A_SB))
self._save(
fil_dict,
sig.ellip(self.N,
self.A_PB,
self.A_SB,
self.F_PBC,
btype='bandpass',
analog=self.analog,
output=self.FRMT))
def BPman(self, fil_dict):
"""Elliptic BP filter, manual order"""
self._get_params(fil_dict)
if not self._test_N():
return -1
self._save(
fil_dict,
sig.ellip(self.N,
self.A_PB,
self.A_SB, [self.F_PB, self.F_PB2],
btype='bandpass',
analog=self.analog,
output=self.FRMT))
# BS: F_SB[0] > F_PB[0], F_SB[1] < F_PB[1] --------------------------------
def BSmin(self, fil_dict):
"""Elliptic BP filter, minimum order"""
self._get_params(fil_dict)
self.N, self.F_PBC = ellipord([self.F_PB, self.F_PB2],
[self.F_SB, self.F_SB2],
self.A_PB,
self.A_SB,
analog=self.analog)
# force even N
if (self.N % 2) == 1:
self.N += 1
if not self._test_N():
return -1
self._save(
fil_dict,
sig.ellip(self.N,
self.A_PB,
self.A_SB,
self.F_PBC,
btype='bandstop',
analog=self.analog,
output=self.FRMT))
def BSman(self, fil_dict):
"""Elliptic BS filter, manual order"""
self._get_params(fil_dict)
if not self._test_N():
return -1
self._save(
fil_dict,
sig.ellip(self.N,
self.A_PB,
self.A_SB, [self.F_PB, self.F_PB2],
btype='bandstop',
analog=self.analog,
output=self.FRMT))