class FreqUnits(QWidget):
"""
Build and update widget for entering frequency unit, frequency range and
sampling frequency f_S
The following key-value pairs of the `fb.fil[0]` dict are modified:
- `'freq_specs_unit'` : The unit ('k', 'f_S', 'f_Ny', 'Hz' etc.) as a string
- `'freqSpecsRange'` : A list with two entries for minimum and maximum frequency
values for labelling the frequency axis
- `'f_S'` : The sampling frequency for referring frequency values to as a float
- `'f_max'` : maximum frequency for scaling frequency axis
- `'plt_fUnit'`: frequency unit as string
- `'plt_tUnit'`: time unit as string
- `'plt_fLabel'`: label for frequency axis
- `'plt_tLabel'`: label for time axis
"""
# class variables (shared between instances if more than one exists)
sig_tx = pyqtSignal(object) # outgoing
from pyfda.libs.pyfda_qt_lib import emit
def __init__(self, parent=None, title="Frequency Units"):
super(FreqUnits, self).__init__(parent)
self.title = title
self.spec_edited = False # flag whether QLineEdit field has been edited
self._construct_UI()
def _construct_UI(self):
"""
Construct the User Interface
"""
self.layVMain = QVBoxLayout() # Widget main layout
f_units = ['k', 'f_S', 'f_Ny', 'Hz', 'kHz', 'MHz', 'GHz']
self.t_units = ['', 'T_S', 'T_S', 's', 'ms', r'$\mu$s', 'ns']
bfont = QFont()
bfont.setBold(True)
self.lblUnits = QLabel(self)
self.lblUnits.setText("Freq. Unit")
self.lblUnits.setFont(bfont)
self.fs_old = fb.fil[0]['f_S'] # store current sampling frequency
self.lblF_S = QLabel(self)
self.lblF_S.setText(to_html("f_S =", frmt='bi'))
self.ledF_S = QLineEdit()
self.ledF_S.setText(str(fb.fil[0]["f_S"]))
self.ledF_S.setObjectName("f_S")
self.ledF_S.installEventFilter(self) # filter events
self.butLock = QToolButton(self)
self.butLock.setIcon(QIcon(':/lock-unlocked.svg'))
self.butLock.setCheckable(True)
self.butLock.setChecked(False)
self.butLock.setToolTip(
"<span><b>Unlocked:</b> When f_S is changed, all frequency related "
"widgets are updated, normalized frequencies stay the same.<br />"
"<b>Locked:</b> When f_S is changed, displayed absolute frequency "
"values don't change but normalized frequencies do.</span>")
# self.butLock.setStyleSheet("QToolButton:checked {font-weight:bold}")
layHF_S = QHBoxLayout()
layHF_S.addWidget(self.ledF_S)
layHF_S.addWidget(self.butLock)
self.cmbUnits = QComboBox(self)
self.cmbUnits.setObjectName("cmbUnits")
self.cmbUnits.addItems(f_units)
self.cmbUnits.setToolTip(
'Select whether frequencies are specified w.r.t. \n'
'the sampling frequency "f_S", to the Nyquist frequency \n'
'f_Ny = f_S/2 or as absolute values. "k" specifies frequencies w.r.t. f_S '
'but plots graphs over the frequency index k.')
self.cmbUnits.setCurrentIndex(1)
# self.cmbUnits.setItemData(0, (0,QColor("#FF333D"),Qt.BackgroundColorRole))#
# self.cmbUnits.setItemData(0, (QFont('Verdana', bold=True), Qt.FontRole)
fRanges = [("0...½", "half"), ("0...1", "whole"), ("-½...½", "sym")]
self.cmbFRange = QComboBox(self)
self.cmbFRange.setObjectName("cmbFRange")
for f in fRanges:
self.cmbFRange.addItem(f[0], f[1])
self.cmbFRange.setToolTip("Select frequency range (whole or half).")
self.cmbFRange.setCurrentIndex(0)
# Combobox resizes with longest entry
self.cmbUnits.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmbFRange.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.butSort = QToolButton(self)
self.butSort.setText("Sort")
self.butSort.setIcon(QIcon(':/sort-ascending.svg'))
#self.butDelCells.setIconSize(q_icon_size)
self.butSort.setCheckable(True)
self.butSort.setChecked(True)
self.butSort.setToolTip(
"Sort frequencies in ascending order when pushed.")
self.butSort.setStyleSheet("QToolButton:checked {font-weight:bold}")
self.layHUnits = QHBoxLayout()
self.layHUnits.addWidget(self.cmbUnits)
self.layHUnits.addWidget(self.cmbFRange)
self.layHUnits.addWidget(self.butSort)
# Create a gridLayout consisting of QLabel and QLineEdit fields
# for setting f_S, the units and the actual frequency specs:
self.layGSpecWdg = QGridLayout() # sublayout for spec fields
self.layGSpecWdg.addWidget(self.lblF_S, 1, 0)
# self.layGSpecWdg.addWidget(self.ledF_S,1,1)
self.layGSpecWdg.addLayout(layHF_S, 1, 1)
self.layGSpecWdg.addWidget(self.lblUnits, 0, 0)
self.layGSpecWdg.addLayout(self.layHUnits, 0, 1)
frmMain = QFrame(self)
frmMain.setLayout(self.layGSpecWdg)
self.layVMain.addWidget(frmMain)
self.layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(self.layVMain)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.cmbUnits.currentIndexChanged.connect(self.update_UI)
self.butLock.clicked.connect(self._lock_freqs)
self.cmbFRange.currentIndexChanged.connect(self._freq_range)
self.butSort.clicked.connect(self._store_sort_flag)
# ----------------------------------------------------------------------
self.update_UI() # first-time initialization
# -------------------------------------------------------------
def _lock_freqs(self):
"""
Lock / unlock frequency entries: The values of frequency related widgets
are stored in normalized form (w.r.t. sampling frequency)`fb.fil[0]['f_S']`.
When the sampling frequency changes, absolute frequencies displayed in the
widgets change their values. Most of the time, this is the desired behaviour,
the properties of discrete time systems or signals are usually defined
by the normalized frequencies.
When the effect of varying the sampling frequency is to be analyzed, the
displayed values in the widgets can be locked by pressing the Lock button.
After changing the sampling frequency, normalized frequencies have to be
rescaled like `f_a *= fb.fil[0]['f_S_prev'] / fb.fil[0]['f_S']` to maintain
the displayed value `f_a * f_S`.
This has to be accomplished by each frequency widget (currently, these are
freq_specs and freq_units).
The setting is stored as bool in the global dict entry `fb.fil[0]['freq_locked'`,
the signal 'view_changed':'f_S' is emitted.
"""
if self.butLock.isChecked():
# Lock has been activated, keep displayed frequencies locked
fb.fil[0]['freq_locked'] = True
self.butLock.setIcon(QIcon(':/lock-locked.svg'))
else:
# Lock has been unlocked, scale displayed frequencies with f_S
fb.fil[0]['freq_locked'] = False
self.butLock.setIcon(QIcon(':/lock-unlocked.svg'))
self.emit({'view_changed': 'f_S'})
# -------------------------------------------------------------
def update_UI(self):
"""
update_UI is called
- during init
- when the unit combobox is changed
Set various scale factors and labels depending on the setting of the unit
combobox.
Update the freqSpecsRange and finally, emit 'view_changed':'f_S' signal
"""
f_unit = str(self.cmbUnits.currentText()) # selected frequency unit
idx = self.cmbUnits.currentIndex() # and its index
is_normalized_freq = f_unit in {"f_S", "f_Ny", "k"}
self.ledF_S.setVisible(not is_normalized_freq) # only vis. when
self.lblF_S.setVisible(not is_normalized_freq) # not normalized
self.butLock.setVisible(not is_normalized_freq)
f_S_scale = 1 # default setting for f_S scale
if is_normalized_freq:
# store current sampling frequency to restore it when returning to
# unnormalized frequencies
self.fs_old = fb.fil[0]['f_S']
if f_unit == "f_S": # normalized to f_S
fb.fil[0]['f_S'] = fb.fil[0]['f_max'] = 1.
fb.fil[0]['T_S'] = 1.
f_label = r"$F = f\, /\, f_S = \Omega \, /\, 2 \mathrm{\pi} \; \rightarrow$"
t_label = r"$n = t\, /\, T_S \; \rightarrow$"
elif f_unit == "f_Ny": # normalized to f_nyq = f_S / 2
fb.fil[0]['f_S'] = fb.fil[0]['f_max'] = 2.
fb.fil[0]['T_S'] = 1.
f_label = r"$F = 2f \, / \, f_S = \Omega \, / \, \mathrm{\pi} \; \rightarrow$"
t_label = r"$n = t\, /\, T_S \; \rightarrow$"
else: # frequency index k,
fb.fil[0]['f_S'] = 1.
fb.fil[0]['T_S'] = 1.
fb.fil[0]['f_max'] = params['N_FFT']
f_label = r"$k \; \rightarrow$"
t_label = r"$n\; \rightarrow$"
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
else: # Hz, kHz, ...
# Restore sampling frequency when returning from f_S / f_Ny / k
if fb.fil[0]['freq_specs_unit'] in {
"f_S", "f_Ny", "k"
}: # previous setting normalized?
fb.fil[0]['f_S'] = fb.fil[0][
'f_max'] = self.fs_old # yes, restore prev.
fb.fil[0][
'T_S'] = 1. / self.fs_old # settings for sampling frequency
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
if f_unit == "Hz":
f_S_scale = 1.
elif f_unit == "kHz":
f_S_scale = 1.e3
elif f_unit == "MHz":
f_S_scale = 1.e6
elif f_unit == "GHz":
f_S_scale = 1.e9
else:
logger.warning("Unknown frequency unit {0}".format(f_unit))
f_label = r"$f$ in " + f_unit + r"$\; \rightarrow$"
t_label = r"$t$ in " + self.t_units[idx] + r"$\; \rightarrow$"
if f_unit == "k":
plt_f_unit = "f_S"
else:
plt_f_unit = f_unit
fb.fil[0].update({'f_S_scale':
f_S_scale}) # scale factor for f_S (Hz, kHz, ...)
fb.fil[0].update({'freq_specs_unit': f_unit}) # frequency unit
# time and frequency unit as string e.g. for plot axis labeling
fb.fil[0].update({"plt_fUnit": plt_f_unit})
fb.fil[0].update({"plt_tUnit": self.t_units[idx]})
# complete plot axis labels including unit and arrow
fb.fil[0].update({"plt_fLabel": f_label})
fb.fil[0].update({"plt_tLabel": t_label})
self._freq_range(
emit=False) # update f_lim setting without emitting signal
self.emit({'view_changed': 'f_S'})
# ------------------------------------------------------------------------------
def eventFilter(self, source, event):
"""
Filter all events generated by the QLineEdit `f_S` widget. Source and type
of all events generated by monitored objects are passed to this eventFilter,
evaluated and passed on to the next hierarchy level.
- When a QLineEdit widget gains input focus (QEvent.FocusIn`), display
the stored value from filter dict with full precision
- When a key is pressed inside the text field, set the `spec_edited` flag
to True.
- When a QLineEdit widget loses input focus (QEvent.FocusOut`), store
current value with full precision (only if `spec_edited`== True) and
display the stored value in selected format. Emit 'view_changed':'f_S'
"""
def _store_entry():
"""
Update filter dictionary, set line edit entry with reduced precision
again.
"""
if self.spec_edited:
fb.fil[0].update({'f_S_prev': fb.fil[0]['f_S']})
fb.fil[0].update({
'f_S':
safe_eval(source.text(), fb.fil[0]['f_S'], sign='pos')
})
fb.fil[0].update({'T_S': 1. / fb.fil[0]['f_S']})
fb.fil[0].update({'f_max': fb.fil[0]['f_S']})
self._freq_range(emit=False) # update plotting range
self.emit({'view_changed': 'f_S'})
self.spec_edited = False # reset flag, changed entry has been saved
if source.objectName() == 'f_S':
if event.type() == QEvent.FocusIn:
self.spec_edited = False
source.setText(str(fb.fil[0]['f_S'])) # full precision
elif event.type() == QEvent.KeyPress:
self.spec_edited = True # entry has been changed
key = event.key()
if key in {QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter}:
_store_entry()
elif key == QtCore.Qt.Key_Escape: # revert changes
self.spec_edited = False
source.setText(str(fb.fil[0]['f_S'])) # full precision
elif event.type() == QEvent.FocusOut:
_store_entry()
source.setText(params['FMT'].format(
fb.fil[0]['f_S'])) # reduced prec.
# Call base class method to continue normal event processing:
return super(FreqUnits, self).eventFilter(source, event)
# -------------------------------------------------------------
def _freq_range(self, emit=True):
"""
Set frequency plotting range for single-sided spectrum up to f_S/2 or f_S
or for double-sided spectrum between -f_S/2 and f_S/2
Emit 'view_changed':'f_range' when `emit=True`
"""
if type(emit) == int: # signal was emitted by combobox
emit = True
rangeType = qget_cmb_box(self.cmbFRange)
fb.fil[0].update({'freqSpecsRangeType': rangeType})
f_max = fb.fil[0]["f_max"]
if rangeType == 'whole':
f_lim = [0, f_max]
elif rangeType == 'sym':
f_lim = [-f_max / 2., f_max / 2.]
else:
f_lim = [0, f_max / 2.]
fb.fil[0]['freqSpecsRange'] = f_lim # store settings in dict
if emit:
self.emit({'view_changed': 'f_range'})
# -------------------------------------------------------------
def load_dict(self):
"""
Reload comboBox settings and textfields from filter dictionary
Block signals during update of combobox / lineedit widgets
"""
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
self.cmbUnits.blockSignals(True)
idx = self.cmbUnits.findText(
fb.fil[0]['freq_specs_unit']) # get and set
self.cmbUnits.setCurrentIndex(idx) # index for freq. unit combo box
self.cmbUnits.blockSignals(False)
self.cmbFRange.blockSignals(True)
idx = self.cmbFRange.findData(fb.fil[0]['freqSpecsRangeType'])
self.cmbFRange.setCurrentIndex(idx) # set frequency range
self.cmbFRange.blockSignals(False)
self.butSort.blockSignals(True)
self.butSort.setChecked(fb.fil[0]['freq_specs_sort'])
self.butSort.blockSignals(False)
# -------------------------------------------------------------
def _store_sort_flag(self):
"""
Store sort flag in filter dict and emit 'specs_changed':'f_sort'
when sort button is checked.
"""
fb.fil[0]['freq_specs_sort'] = self.butSort.isChecked()
if self.butSort.isChecked():
self.emit({'specs_changed': 'f_sort'})
class Plot_Phi(QWidget):
# incoming, connected in sender widget (locally connected to self.process_sig_rx() )
sig_rx = pyqtSignal(object)
# outgoing, distributed via plot_tab_widget
sig_tx = pyqtSignal(object)
def __init__(self, parent):
super(Plot_Phi, self).__init__(parent)
self.needs_calc = True # recalculation of filter function necessary
self.needs_draw = True # plotting neccessary (e.g. log instead of lin)
self.tool_tip = "Phase frequency response"
self.tab_label = "\u03C6(f)" # phi(f)
self._construct_UI()
#------------------------------------------------------------------------------
def process_sig_rx(self, dict_sig=None):
"""
Process signals coming from the navigation toolbar and from sig_rx
"""
logger.debug("Processing {0} | needs_calc = {1}, visible = {2}"\
.format(dict_sig, self.needs_calc, self.isVisible()))
if dict_sig['sender'] == __name__:
logger.debug("Stopped infinite loop\n{0}".format(
pprint_log(dict_sig)))
return
if self.isVisible():
if 'data_changed' in dict_sig or 'home' in dict_sig or self.needs_calc:
self.draw()
self.needs_calc = False
self.needs_draw = False
elif 'view_changed' in dict_sig or self.needs_draw:
self.update_view()
self.needs_draw = False
# elif ('ui_changed' in dict_sig and dict_sig['ui_changed'] == 'resized')\
# or self.needs_redraw:
# self.redraw()
else:
if 'data_changed' in dict_sig:
self.needs_calc = True
elif 'view_changed' in dict_sig:
self.needs_draw = True
# elif 'ui_changed' in dict_sig and dict_sig['ui_changed'] == 'resized':
# self.needs_redraw = True
#------------------------------------------------------------------------------
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 init_axes(self):
"""
Initialize and clear the axes - this is only called once
"""
if len(self.mplwidget.fig.get_axes()) == 0: # empty figure, no axes
self.ax = self.mplwidget.fig.subplots()
self.ax.get_xaxis().tick_bottom() # remove axis ticks on top
self.ax.get_yaxis().tick_left() # remove axis ticks right
#------------------------------------------------------------------------------
def unit_changed(self):
"""
Unit for phase display has been changed, emit a 'view_changed' signal
and continue with drawing.
"""
self.sig_tx.emit({'sender': __name__, 'view_changed': 'plot_phi'})
self.draw()
#------------------------------------------------------------------------------
def calc_resp(self):
"""
(Re-)Calculate the complex frequency response H(f)
"""
# calculate H_cplx(W) (complex) for W = 0 ... 2 pi:
self.W, self.H_cmplx = calc_Hcomplex(fb.fil[0],
params['N_FFT'],
wholeF=True)
# replace nan and inf by finite values, otherwise np.unwrap yields
# an array full of nans
self.H_cmplx = np.nan_to_num(self.H_cmplx)
#------------------------------------------------------------------------------
def draw(self):
"""
Main entry point:
Re-calculate \|H(f)\| and draw the figure
"""
self.calc_resp()
self.update_view()
#------------------------------------------------------------------------------
def update_view(self):
"""
Draw the figure with new limits, scale etc without recalculating H(f)
"""
self.unitPhi = qget_cmb_box(self.cmbUnitsPhi, data=False)
f_S2 = fb.fil[0]['f_S'] / 2.
#========= select frequency range to be displayed =====================
#=== shift, scale and select: W -> F, H_cplx -> H_c
F = self.W * f_S2 / np.pi
if fb.fil[0]['freqSpecsRangeType'] == 'sym':
# shift H and F by f_S/2
H = np.fft.fftshift(self.H_cmplx)
F -= f_S2
elif fb.fil[0]['freqSpecsRangeType'] == 'half':
# only use the first half of H and F
H = self.H_cmplx[0:params['N_FFT'] // 2]
F = F[0:params['N_FFT'] // 2]
else: # fb.fil[0]['freqSpecsRangeType'] == 'whole'
# use H and F as calculated
H = self.H_cmplx
y_str = r'$\angle H(\mathrm{e}^{\mathrm{j} \Omega})$ in '
if self.unitPhi == 'rad':
y_str += 'rad ' + r'$\rightarrow $'
scale = 1.
elif self.unitPhi == 'rad/pi':
y_str += 'rad' + r'$ / \pi \;\rightarrow $'
scale = 1. / np.pi
else:
y_str += 'deg ' + r'$\rightarrow $'
scale = 180. / np.pi
fb.fil[0]['plt_phiLabel'] = y_str
fb.fil[0]['plt_phiUnit'] = self.unitPhi
if self.chkWrap.isChecked():
phi_plt = np.angle(H) * scale
else:
phi_plt = np.unwrap(np.angle(H)) * scale
#---------------------------------------------------------
self.ax.clear() # need to clear, doesn't overwrite
line_phi, = self.ax.plot(F, phi_plt)
#---------------------------------------------------------
self.ax.set_title(r'Phase Frequency Response')
self.ax.set_xlabel(fb.fil[0]['plt_fLabel'])
self.ax.set_ylabel(y_str)
self.ax.set_xlim(fb.fil[0]['freqSpecsRange'])
self.redraw()
#------------------------------------------------------------------------------
def redraw(self):
"""
Redraw the canvas when e.g. the canvas size has changed
"""
self.mplwidget.redraw()
class Firwin(QWidget):
FRMT = 'ba' # output format(s) of filter design routines 'zpk' / 'ba' / 'sos'
# currently, only 'ba' is supported for firwin routines
sig_tx = pyqtSignal(object)
def __init__(self):
QWidget.__init__(self)
self.ft = 'FIR'
self.fft_window = None
# dictionary for firwin window settings
self.win_dict = fb.fil[0]['win_fir']
c = Common()
self.rt_dict = c.rt_base_iir
self.rt_dict_add = {
'COM': {
'min': {
'msg':
('a',
r"<br /><b>Note:</b> Filter order is only a rough approximation "
"and most likely far too low!")
},
'man': {
'msg':
('a', r"Enter desired filter order <b><i>N</i></b> and "
"<b>-6 dB</b> pass band corner "
"frequency(ies) <b><i>F<sub>C</sub></i></b> .")
},
},
'LP': {
'man': {},
'min': {}
},
'HP': {
'man': {
'msg': ('a', r"<br /><b>Note:</b> Order needs to be odd!")
},
'min': {}
},
'BS': {
'man': {
'msg': ('a', r"<br /><b>Note:</b> Order needs to be odd!")
},
'min': {}
},
'BP': {
'man': {},
'min': {}
},
}
self.info = """**Windowed FIR filters**
are designed by truncating the
infinite impulse response of an ideal filter with a window function.
The kind of used window has strong influence on ripple etc. of the
resulting filter.
**Design routines:**
``scipy.signal.firwin()``
"""
#self.info_doc = [] is set in self._update_UI()
#------------------- end of static info for filter tree ---------------
#----------------------------------------------------------------------
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 object, fb.filObj .
"""
# Combobox for selecting the algorithm to estimate minimum filter order
self.cmb_firwin_alg = QComboBox(self)
self.cmb_firwin_alg.setObjectName('wdg_cmb_firwin_alg')
self.cmb_firwin_alg.addItems(['ichige', 'kaiser', 'herrmann'])
# Minimum size, can be changed in the upper hierarchy levels using layouts:
self.cmb_firwin_alg.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmb_firwin_alg.hide()
# Combobox for selecting the window used for filter design
self.cmb_firwin_win = QComboBox(self)
self.cmb_firwin_win.addItems(get_window_names())
self.cmb_firwin_win.setObjectName('wdg_cmb_firwin_win')
# Minimum size, can be changed in the upper hierarchy levels using layouts:
self.cmb_firwin_win.setSizeAdjustPolicy(QComboBox.AdjustToContents)
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)
self.lblWinPar1 = QLabel("a", self)
self.lblWinPar1.setObjectName('wdg_lbl_firwin_1')
self.ledWinPar1 = QLineEdit(self)
self.ledWinPar1.setText("0.5")
self.ledWinPar1.setObjectName('wdg_led_firwin_1')
self.lblWinPar1.setVisible(False)
self.ledWinPar1.setVisible(False)
self.lblWinPar2 = QLabel("b", self)
self.lblWinPar2.setObjectName('wdg_lbl_firwin_2')
self.ledWinPar2 = QLineEdit(self)
self.ledWinPar2.setText("0.5")
self.ledWinPar2.setObjectName('wdg_led_firwin_2')
self.ledWinPar2.setVisible(False)
self.lblWinPar2.setVisible(False)
self.layHWin1 = QHBoxLayout()
self.layHWin1.addWidget(self.cmb_firwin_win)
self.layHWin1.addWidget(self.but_fft_win)
self.layHWin1.addWidget(self.cmb_firwin_alg)
self.layHWin2 = QHBoxLayout()
self.layHWin2.addWidget(self.lblWinPar1)
self.layHWin2.addWidget(self.ledWinPar1)
self.layHWin2.addWidget(self.lblWinPar2)
self.layHWin2.addWidget(self.ledWinPar2)
self.layVWin = QVBoxLayout()
self.layVWin.addLayout(self.layHWin1)
self.layVWin.addLayout(self.layHWin2)
self.layVWin.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.layVWin)
#----------------------------------------------------------------------
# SIGNALS & SLOTs
#----------------------------------------------------------------------
self.cmb_firwin_alg.activated.connect(self._update_win_fft)
self.cmb_firwin_win.activated.connect(self._update_win_fft)
self.ledWinPar1.editingFinished.connect(self._read_param1)
self.ledWinPar2.editingFinished.connect(self._read_param2)
self.but_fft_win.clicked.connect(self.show_fft_win)
#----------------------------------------------------------------------
self._load_dict() # get initial / last setting from dictionary
self._update_win_fft()
#=============================================================================
# Copied from impz()
#==============================================================================
def _read_param1(self):
"""Read out textbox when editing is finished and update dict and fft window"""
param = safe_eval(self.ledWinPar1.text(),
self.win_dict['par'][0]['val'],
sign='pos',
return_type='float')
if param < self.win_dict['par'][0]['min']:
param = self.win_dict['par'][0]['min']
elif param > self.win_dict['par'][0]['max']:
param = self.win_dict['par'][0]['max']
self.ledWinPar1.setText(str(param))
self.win_dict['par'][0]['val'] = param
self._update_win_fft()
def _read_param2(self):
"""Read out textbox when editing is finished and update dict and fft window"""
param = safe_eval(self.ledWinPar2.text(),
self.win_dict['par'][1]['val'],
return_type='float')
if param < self.win_dict['par'][1]['min']:
param = self.win_dict['par'][1]['min']
elif param > self.win_dict['par'][1]['max']:
param = self.win_dict['par'][1]['max']
self.ledWinPar2.setText(str(param))
self.win_dict['par'][1]['val'] = param
self._update_win_fft()
def _update_win_fft(self):
""" Update window type for FirWin """
self.alg = str(self.cmb_firwin_alg.currentText())
self.fir_window_name = qget_cmb_box(self.cmb_firwin_win, data=False)
self.win = calc_window_function(self.win_dict,
self.fir_window_name,
N=self.N,
sym=True)
n_par = self.win_dict['n_par']
self.lblWinPar1.setVisible(n_par > 0)
self.ledWinPar1.setVisible(n_par > 0)
self.lblWinPar2.setVisible(n_par > 1)
self.ledWinPar2.setVisible(n_par > 1)
if n_par > 0:
self.lblWinPar1.setText(
to_html(self.win_dict['par'][0]['name'] + " =", frmt='bi'))
self.ledWinPar1.setText(str(self.win_dict['par'][0]['val']))
self.ledWinPar1.setToolTip(self.win_dict['par'][0]['tooltip'])
if n_par > 1:
self.lblWinPar2.setText(
to_html(self.win_dict['par'][1]['name'] + " =", frmt='bi'))
self.ledWinPar2.setText(str(self.win_dict['par'][1]['val']))
self.ledWinPar2.setToolTip(self.win_dict['par'][1]['tooltip'])
# sig_tx -> select_filter -> filter_specs
self.sig_tx.emit({'sender': __name__, 'filt_changed': 'firwin'})
#=============================================================================
def _load_dict(self):
"""
Reload window selection and parameters from filter dictionary
and set UI elements accordingly. load_dict() is called upon
initialization and when the filter is loaded from disk.
"""
self.N = fb.fil[0]['N']
win_idx = 0
alg_idx = 0
if 'wdg_fil' in fb.fil[0] and 'firwin' in fb.fil[0]['wdg_fil']:
wdg_fil_par = fb.fil[0]['wdg_fil']['firwin']
if 'win' in wdg_fil_par:
if np.isscalar(
wdg_fil_par['win']): # true for strings (non-vectors)
window = wdg_fil_par['win']
else:
window = wdg_fil_par['win'][0]
self.ledWinPar1.setText(str(wdg_fil_par['win'][1]))
if len(wdg_fil_par['win']) > 2:
self.ledWinPar2.setText(str(wdg_fil_par['win'][2]))
# find index for window string
win_idx = self.cmb_firwin_win.findText(
window, Qt.MatchFixedString) # case insensitive flag
if win_idx == -1: # Key does not exist, use first entry instead
win_idx = 0
if 'alg' in wdg_fil_par:
alg_idx = self.cmb_firwin_alg.findText(wdg_fil_par['alg'],
Qt.MatchFixedString)
if alg_idx == -1: # Key does not exist, use first entry instead
alg_idx = 0
self.cmb_firwin_win.setCurrentIndex(
win_idx) # set index for window and
self.cmb_firwin_alg.setCurrentIndex(alg_idx) # and algorithm cmbBox
def _store_entries(self):
"""
Store window and alg. selection and parameter settings (part of
self.firWindow, if any) in filter dictionary.
"""
if not 'wdg_fil' in fb.fil[0]:
fb.fil[0].update({'wdg_fil': {}})
fb.fil[0]['wdg_fil'].update(
{'firwin': {
'win': self.firWindow,
'alg': self.alg
}})
def _get_params(self, fil_dict):
"""
Translate parameters from the passed dictionary to instance
parameters, scaling / transforming them if needed.
"""
self.N = fil_dict['N']
self.F_PB = fil_dict['F_PB']
self.F_SB = fil_dict['F_SB']
self.F_PB2 = fil_dict['F_PB2']
self.F_SB2 = fil_dict['F_SB2']
self.F_C = fil_dict['F_C']
self.F_C2 = fil_dict['F_C2']
# firwin amplitude specs are linear (not in dBs)
self.A_PB = fil_dict['A_PB']
self.A_PB2 = fil_dict['A_PB2']
self.A_SB = fil_dict['A_SB']
self.A_SB2 = fil_dict['A_SB2']
# self.alg = 'ichige' # algorithm for determining the minimum order
# self.alg = self.cmb_firwin_alg.currentText()
def _test_N(self):
"""
Warn the user if the calculated order is too high for a reasonable filter
design.
"""
if self.N > 1000:
return qfilter_warning(self, self.N, "FirWin")
else:
return True
def _save(self, fil_dict, arg):
"""
Convert between poles / zeros / gain, filter coefficients (polynomes)
and second-order sections and store all available formats in the passed
dictionary 'fil_dict'.
"""
fil_save(fil_dict, arg, self.FRMT, __name__)
try: # has the order been calculated by a "min" filter design?
fil_dict['N'] = self.N # yes, update filterbroker
except AttributeError:
pass
# self._store_entries()
#------------------------------------------------------------------------------
def firwin(self,
numtaps,
cutoff,
window=None,
pass_zero=True,
scale=True,
nyq=1.0,
fs=None):
"""
FIR filter design using the window method. This is more or less the
same as `scipy.signal.firwin` with the exception that an ndarray with
the window values can be passed as an alternative to the window name.
The parameters "width" (specifying a Kaiser window) and "fs" have been
omitted, they are not needed here.
This function computes the coefficients of a finite impulse response
filter. The filter will have linear phase; it will be Type I if
`numtaps` is odd and Type II if `numtaps` is even.
Type II filters always have zero response at the Nyquist rate, so a
ValueError exception is raised if firwin is called with `numtaps` even and
having a passband whose right end is at the Nyquist rate.
Parameters
----------
numtaps : int
Length of the filter (number of coefficients, i.e. the filter
order + 1). `numtaps` must be even if a passband includes the
Nyquist frequency.
cutoff : float or 1D array_like
Cutoff frequency of filter (expressed in the same units as `nyq`)
OR an array of cutoff frequencies (that is, band edges). In the
latter case, the frequencies in `cutoff` should be positive and
monotonically increasing between 0 and `nyq`. The values 0 and
`nyq` must not be included in `cutoff`.
window : ndarray or string
string: use the window with the passed name from scipy.signal.windows
ndarray: The window values - this is an addition to the original
firwin routine.
pass_zero : bool, optional
If True, the gain at the frequency 0 (i.e. the "DC gain") is 1.
Otherwise the DC gain is 0.
scale : bool, optional
Set to True to scale the coefficients so that the frequency
response is exactly unity at a certain frequency.
That frequency is either:
- 0 (DC) if the first passband starts at 0 (i.e. pass_zero
is True)
- `nyq` (the Nyquist rate) if the first passband ends at
`nyq` (i.e the filter is a single band highpass filter);
center of first passband otherwise
nyq : float, optional
Nyquist frequency. Each frequency in `cutoff` must be between 0
and `nyq`.
Returns
-------
h : (numtaps,) ndarray
Coefficients of length `numtaps` FIR filter.
Raises
------
ValueError
If any value in `cutoff` is less than or equal to 0 or greater
than or equal to `nyq`, if the values in `cutoff` are not strictly
monotonically increasing, or if `numtaps` is even but a passband
includes the Nyquist frequency.
See also
--------
scipy.firwin
"""
cutoff = np.atleast_1d(cutoff) / float(nyq)
# Check for invalid input.
if cutoff.ndim > 1:
raise ValueError("The cutoff argument must be at most "
"one-dimensional.")
if cutoff.size == 0:
raise ValueError("At least one cutoff frequency must be given.")
if cutoff.min() <= 0 or cutoff.max() >= 1:
raise ValueError(
"Invalid cutoff frequency {0}: frequencies must be "
"greater than 0 and less than nyq.".format(cutoff))
if np.any(np.diff(cutoff) <= 0):
raise ValueError("Invalid cutoff frequencies: the frequencies "
"must be strictly increasing.")
pass_nyquist = bool(cutoff.size & 1) ^ pass_zero
if pass_nyquist and numtaps % 2 == 0:
raise ValueError(
"A filter with an even number of coefficients must "
"have zero response at the Nyquist rate.")
# Insert 0 and/or 1 at the ends of cutoff so that the length of cutoff
# is even, and each pair in cutoff corresponds to passband.
cutoff = np.hstack(([0.0] * pass_zero, cutoff, [1.0] * pass_nyquist))
# `bands` is a 2D array; each row gives the left and right edges of
# a passband.
bands = cutoff.reshape(-1, 2)
# Build up the coefficients.
alpha = 0.5 * (numtaps - 1)
m = np.arange(0, numtaps) - alpha
h = 0
for left, right in bands:
h += right * sinc(right * m)
h -= left * sinc(left * m)
if type(window) == str:
# Get and apply the window function.
from scipy.signal.signaltools import get_window
win = get_window(window, numtaps, fftbins=False)
elif type(window) == np.ndarray:
win = window
else:
logger.error(
"The 'window' was neither a string nor a numpy array, it could not be evaluated."
)
return None
# apply the window function.
h *= win
# Now handle scaling if desired.
if scale:
# Get the first passband.
left, right = bands[0]
if left == 0:
scale_frequency = 0.0
elif right == 1:
scale_frequency = 1.0
else:
scale_frequency = 0.5 * (left + right)
c = np.cos(np.pi * m * scale_frequency)
s = np.sum(h * c)
h /= s
return h
def _firwin_ord(self, F, W, A, alg):
#http://www.mikroe.com/chapters/view/72/chapter-2-fir-filters/
delta_f = abs(F[1] - F[0]) * 2 # referred to f_Ny
delta_A = np.sqrt(A[0] * A[1])
if self.fir_window_name == 'kaiser':
N, beta = sig.kaiserord(20 * np.log10(np.abs(fb.fil[0]['A_SB'])),
delta_f)
self.ledWinPar1.setText(str(beta))
fb.fil[0]['wdg_fil'][1] = beta
self._update_UI()
else:
N = remezord(F, W, A, fs=1, alg=alg)[0]
return N
def LPmin(self, fil_dict):
self._get_params(fil_dict)
self.N = self._firwin_ord([self.F_PB, self.F_SB], [1, 0],
[self.A_PB, self.A_SB],
alg=self.alg)
if not self._test_N():
return -1
self.fir_window = calc_window_function(self.win_dict,
self.fir_window_name,
N=self.N,
sym=True)
fil_dict['F_C'] = (self.F_SB + self.F_PB
) / 2 # use average of calculated F_PB and F_SB
self._save(
fil_dict,
self.firwin(self.N,
fil_dict['F_C'],
window=self.fir_window,
nyq=0.5))
def LPman(self, fil_dict):
self._get_params(fil_dict)
if not self._test_N():
return -1
self.fir_window = calc_window_function(self.win_dict,
self.fir_window_name,
N=self.N,
sym=True)
self._save(
fil_dict,
self.firwin(self.N,
fil_dict['F_C'],
window=self.fir_window,
nyq=0.5))
def HPmin(self, fil_dict):
self._get_params(fil_dict)
N = self._firwin_ord([self.F_SB, self.F_PB], [0, 1],
[self.A_SB, self.A_PB],
alg=self.alg)
self.N = round_odd(N) # enforce odd order
if not self._test_N():
return -1
self.fir_window = calc_window_function(self.win_dict,
self.fir_window_name,
N=self.N,
sym=True)
fil_dict['F_C'] = (self.F_SB + self.F_PB
) / 2 # use average of calculated F_PB and F_SB
self._save(
fil_dict,
self.firwin(self.N,
fil_dict['F_C'],
window=self.fir_window,
pass_zero=False,
nyq=0.5))
def HPman(self, fil_dict):
self._get_params(fil_dict)
self.N = round_odd(self.N) # enforce odd order
if not self._test_N():
return -1
self.fir_window = calc_window_function(self.win_dict,
self.fir_window_name,
N=self.N,
sym=True)
self._save(
fil_dict,
self.firwin(self.N,
fil_dict['F_C'],
window=self.fir_window,
pass_zero=False,
nyq=0.5))
# For BP and BS, F_PB and F_SB have two elements each
def BPmin(self, fil_dict):
self._get_params(fil_dict)
self.N = remezord([self.F_SB, self.F_PB, self.F_PB2, self.F_SB2],
[0, 1, 0], [self.A_SB, self.A_PB, self.A_SB2],
fs=1,
alg=self.alg)[0]
if not self._test_N():
return -1
self.fir_window = calc_window_function(self.win_dict,
self.fir_window_name,
N=self.N,
sym=True)
fil_dict['F_C'] = (self.F_SB + self.F_PB
) / 2 # use average of calculated F_PB and F_SB
fil_dict['F_C2'] = (self.F_SB2 + self.F_PB2
) / 2 # use average of calculated F_PB and F_SB
self._save(
fil_dict,
self.firwin(self.N, [fil_dict['F_C'], fil_dict['F_C2']],
window=self.fir_window,
pass_zero=False,
nyq=0.5))
def BPman(self, fil_dict):
self._get_params(fil_dict)
if not self._test_N():
return -1
self.fir_window = calc_window_function(self.win_dict,
self.fir_window_name,
N=self.N,
sym=True)
self._save(
fil_dict,
self.firwin(self.N, [fil_dict['F_C'], fil_dict['F_C2']],
window=self.fir_window,
pass_zero=False,
nyq=0.5))
def BSmin(self, fil_dict):
self._get_params(fil_dict)
N = remezord([self.F_PB, self.F_SB, self.F_SB2, self.F_PB2], [1, 0, 1],
[self.A_PB, self.A_SB, self.A_PB2],
fs=1,
alg=self.alg)[0]
self.N = round_odd(N) # enforce odd order
if not self._test_N():
return -1
self.fir_window = calc_window_function(self.win_dict,
self.fir_window_name,
N=self.N,
sym=True)
fil_dict['F_C'] = (self.F_SB + self.F_PB
) / 2 # use average of calculated F_PB and F_SB
fil_dict['F_C2'] = (self.F_SB2 + self.F_PB2
) / 2 # use average of calculated F_PB and F_SB
self._save(
fil_dict,
self.firwin(self.N, [fil_dict['F_C'], fil_dict['F_C2']],
window=self.fir_window,
pass_zero=True,
nyq=0.5))
def BSman(self, fil_dict):
self._get_params(fil_dict)
self.N = round_odd(self.N) # enforce odd order
if not self._test_N():
return -1
self.fir_window = calc_window_function(self.win_dict,
self.fir_window_name,
N=self.N,
sym=True)
self._save(
fil_dict,
self.firwin(self.N, [fil_dict['F_C'], fil_dict['F_C2']],
window=self.fir_window,
pass_zero=True,
nyq=0.5))
#------------------------------------------------------------------------------
def show_fft_win(self):
"""
Pop-up FFT window
"""
if self.but_fft_win.isChecked():
qstyle_widget(self.but_fft_win, "changed")
else:
qstyle_widget(self.but_fft_win, "normal")
if self.fft_window is None: # no handle to the window? Create a new instance
if self.but_fft_win.isChecked():
# important: Handle to window must be class attribute
# pass the name of the dictionary where parameters are stored and
# whether a symmetric window or one that can be continued periodically
# will be constructed
self.fft_window = Plot_FFT_win(self,
win_dict=self.win_dict,
sym=True,
title="pyFDA FIR Window Viewer")
self.sig_tx.connect(self.fft_window.sig_rx)
self.fft_window.sig_tx.connect(self.close_fft_win)
self.fft_window.show(
) # modeless i.e. non-blocking popup window
else:
if not self.but_fft_win.isChecked():
if self.fft_window is None:
logger.warning("FFT window is already closed!")
else:
self.fft_window.close()
def close_fft_win(self):
self.fft_window = None
self.but_fft_win.setChecked(False)
qstyle_widget(self.but_fft_win, "normal")
class AmplitudeSpecs(QWidget):
"""
Build and update widget for entering the amplitude
specifications like A_SB, A_PB etc.
"""
sig_tx = pyqtSignal(
object) # emitted when amplitude unit or spec has been changed
def __init__(self, parent, title="Amplitude Specs"):
"""
Initialize
"""
super(AmplitudeSpecs, self).__init__(parent)
self.title = title
self.qlabels = [] # list with references to QLabel widgets
self.qlineedit = [] # list with references to QLineEdit widgets
self.spec_edited = False # flag whether QLineEdit field has been edited
self._construct_UI()
#------------------------------------------------------------------------------
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)
# ^ this also triggers the initial load_dict
# DYNAMIC EVENT MONITORING
# Every time a field is edited, call self._store_entry and
# self.load_dict. This is achieved by dynamically installing and
# removing event filters when creating / deleting subwidgets.
# The event filter monitors the focus of the input fields.
#------------------------------------------------------------------------------
def eventFilter(self, source, event):
"""
Filter all events generated by the QLineEdit widgets. Source and type
of all events generated by monitored objects are passed to this eventFilter,
evaluated and passed on to the next hierarchy level.
- When a QLineEdit widget gains input focus (QEvent.FocusIn`), display
the stored value from filter dict with full precision
- When a key is pressed inside the text field, set the `spec_edited` flag
to True.
- When a QLineEdit widget loses input focus (QEvent.FocusOut`), store
current value in linear format with full precision (only if
`spec_edited`== True) and display the stored value in selected format
"""
if isinstance(source,
QLineEdit): # could be extended for other widgets
if event.type() == QEvent.FocusIn:
self.spec_edited = False
self.load_dict()
# store current entry in case new value can't be evaluated:
fb.data_old = source.text()
elif event.type() == QEvent.KeyPress:
self.spec_edited = True # entry has been changed
key = event.key()
if key in {QtCore.Qt.Key_Return,
QtCore.Qt.Key_Enter}: # store entry
self._store_entry(source)
elif key == QtCore.Qt.Key_Escape: # revert changes
self.spec_edited = False
self.load_dict()
elif event.type() == QEvent.FocusOut:
self._store_entry(source)
# Call base class method to continue normal event processing:
return super(AmplitudeSpecs, self).eventFilter(source, event)
#-------------------------------------------------------------
def update_UI(self, new_labels=()):
"""
Called from filter_specs.update_UI() and target_specs.update_UI().
Set labels and get corresponding values from filter dictionary.
When number of entries has changed, the layout of subwidget is rebuilt,
using
- `self.qlabels`, a list with references to existing QLabel widgets,
- `new_labels`, a list of strings from the filter_dict for the current
filter design
- 'num_new_labels`, their number
- `self.n_cur_labels`, the number of currently visible labels / qlineedit
fields
"""
state = new_labels[0]
new_labels = new_labels[1:]
# W_lbl = max([self.qfm.width(l) for l in new_labels]) # max. label width in pixel
num_new_labels = len(new_labels)
if num_new_labels < self.n_cur_labels: # less new labels/qlineedit fields than before
self._hide_entries(num_new_labels)
elif num_new_labels > self.n_cur_labels: # more new labels, create / show new ones
self._show_entries(num_new_labels)
tool_tipp_sb = "Min. attenuation resp. maximum level in (this) stop band"
for i in range(num_new_labels):
# Update ALL labels and corresponding values
self.qlabels[i].setText(to_html(new_labels[i], frmt='bi'))
self.qlineedit[i].setText(str(fb.fil[0][new_labels[i]]))
self.qlineedit[i].setObjectName(new_labels[i]) # update ID
if "sb" in new_labels[i].lower():
self.qlineedit[i].setToolTip("<span>" + tool_tipp_sb +
" (> 0).</span>")
elif "pb" in new_labels[i].lower():
self.qlineedit[i].setToolTip(
"<span>Maximum ripple (> 0) in (this) pass band.<span/>"
)
qstyle_widget(self.qlineedit[i], state)
self.n_cur_labels = num_new_labels # update number of currently visible labels
self.load_dict(
) # display rounded filter dict entries in selected unit
#------------------------------------------------------------------------------
def load_dict(self):
"""
Reload and reformat the amplitude textfields from filter dict when a new filter
design algorithm is selected or when the user has changed the unit (V / W / dB):
- Reload amplitude entries from filter dictionary and convert to selected to reflect changed settings
unit.
- Update the lineedit fields, rounded to specified format.
"""
unit = fb.fil[0]['amp_specs_unit']
filt_type = fb.fil[0]['ft']
for i in range(len(self.qlineedit)):
amp_label = str(self.qlineedit[i].objectName())
amp_value = lin2unit(fb.fil[0][amp_label],
filt_type,
amp_label,
unit=unit)
if not self.qlineedit[i].hasFocus():
# widget has no focus, round the display
self.qlineedit[i].setText(params['FMT'].format(amp_value))
else:
# widget has focus, show full precision
self.qlineedit[i].setText(str(amp_value))
#------------------------------------------------------------------------------
def _set_amp_unit(self, source):
"""
Store unit for amplitude in filter dictionary, reload amplitude spec
entries via load_dict and fire a sigUnitChanged signal
"""
fb.fil[0]['amp_specs_unit'] = qget_cmb_box(self.cmbUnitsA, data=False)
self.load_dict()
self.sig_tx.emit({'sender': __name__, 'view_changed': 'a_unit'})
#------------------------------------------------------------------------------
def _store_entry(self, source):
"""
When the textfield of `source` has been edited (flag `self.spec_edited` = True),
transform the amplitude spec back to linear unit setting and store it
in filter dict.
This is triggered by `QEvent.focusOut`
Spec entries are *always* stored in linear units; only the
displayed values are adapted to the amplitude unit, not the dictionary!
"""
if self.spec_edited:
unit = str(self.cmbUnitsA.currentText())
filt_type = fb.fil[0]['ft']
amp_label = str(source.objectName())
amp_value = safe_eval(source.text(), fb.data_old, sign='pos')
fb.fil[0].update(
{amp_label: unit2lin(amp_value, filt_type, amp_label, unit)})
self.sig_tx.emit({'sender': __name__, 'specs_changed': 'a_specs'})
self.spec_edited = False # reset flag
self.load_dict()
#-------------------------------------------------------------
def _hide_entries(self, num_new_labels):
"""
Hide subwidgets so that only `num_new_labels` subwidgets are visible
"""
for i in range(num_new_labels, len(self.qlabels)):
self.qlabels[i].hide()
self.qlineedit[i].hide()
#------------------------------------------------------------------------
def _show_entries(self, num_new_labels):
"""
- check whether enough subwidgets (QLabel und QLineEdit) exist for the
the required number of `num_new_labels`:
- create new ones if required
- initialize them with dummy information
- install eventFilter for new QLineEdit widgets so that the filter
dict is updated automatically when a QLineEdit field has been
edited.
- if enough subwidgets exist already, make enough of them visible to
show all spec fields
"""
num_tot_labels = len(
self.qlabels) # number of existing labels (vis. + invis.)
if num_tot_labels < num_new_labels: # new widgets need to be generated
for i in range(num_tot_labels, num_new_labels):
self.qlabels.append(QLabel(self))
self.qlabels[i].setText(to_html("dummy", frmt='bi'))
self.qlineedit.append(QLineEdit(""))
self.qlineedit[i].setObjectName("dummy")
self.qlineedit[i].installEventFilter(self) # filter events
# first entry is title
self.layGSpecs.addWidget(self.qlabels[i], i + 1, 0)
self.layGSpecs.addWidget(self.qlineedit[i], i + 1, 1)
else: # make the right number of widgets visible
for i in range(self.n_cur_labels, num_new_labels):
self.qlabels[i].show()
self.qlineedit[i].show()
class Plot_3D(QWidget):
"""
Class for various 3D-plots:
- lin / log line plot of H(f)
- lin / log surf plot of H(z)
- optional display of poles / zeros
"""
# incoming, connected in sender widget (locally connected to self.process_sig_rx() )
sig_rx = pyqtSignal(object)
# sig_tx = pyqtSignal(object) # outgoing from process_signals
def __init__(self):
super().__init__()
self.zmin = 0
self.zmax = 4
self.zmin_dB = -80
self.cmap_default = 'RdYlBu'
self.data_changed = True # flag whether data has changed
self.tool_tip = "3D magnitude response |H(z)|"
self.tab_label = "3D"
self._construct_UI()
# ------------------------------------------------------------------------------
def process_sig_rx(self, dict_sig=None):
"""
Process signals coming from the navigation toolbar and from ``sig_rx``
"""
# logger.debug("Processing {0} | data_changed = {1}, visible = {2}"\
# .format(dict_sig, self.data_changed, self.isVisible()))
if self.isVisible():
if 'data_changed' in dict_sig or 'home' in dict_sig or self.data_changed:
self.draw()
self.data_changed = False
else:
if 'data_changed' in dict_sig:
self.data_changed = True
# ------------------------------------------------------------------------------
def _construct_UI(self):
self.but_log = PushButton("dB", checked=False)
self.but_log.setObjectName("but_log")
self.but_log.setToolTip("Logarithmic scale")
self.but_plot_in_UC = PushButton("|z| < 1 ", checked=False)
self.but_plot_in_UC.setObjectName("but_plot_in_UC")
self.but_plot_in_UC.setToolTip("Only plot H(z) within the unit circle")
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.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.lblTopdB = QLabel("dB", self)
self.lblTopdB.setVisible(self.but_log.isChecked())
self.plt_UC = PushButton("UC", checked=True)
self.plt_UC.setObjectName("plt_UC")
self.plt_UC.setToolTip("Plot unit circle")
self.but_PZ = PushButton("P/Z ", checked=True)
self.but_PZ.setObjectName("but_PZ")
self.but_PZ.setToolTip("Plot poles and zeros")
self.but_Hf = PushButton("H(f) ", checked=True)
self.but_Hf.setObjectName("but_Hf")
self.but_Hf.setToolTip("Plot H(f) along the unit circle")
modes = ['None', 'Mesh', 'Surf', 'Contour']
self.cmbMode3D = QComboBox(self)
self.cmbMode3D.addItems(modes)
self.cmbMode3D.setObjectName("cmbShow3D")
self.cmbMode3D.setToolTip("Select 3D-plot mode.")
self.cmbMode3D.setCurrentIndex(0)
self.cmbMode3D.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.but_colormap_r = PushButton("reverse", checked=True)
self.but_colormap_r.setObjectName("but_colormap_r")
self.but_colormap_r.setToolTip("reverse colormap")
self.cmbColormap = QComboBox(self)
self._init_cmb_colormap(cmap_init=self.cmap_default)
self.cmbColormap.setToolTip("Select colormap")
self.but_colbar = PushButton("Colorbar ", checked=False)
self.but_colbar.setObjectName("chkColBar")
self.but_colbar.setToolTip("Show colorbar")
self.but_lighting = PushButton("Lighting", checked=False)
self.but_lighting.setObjectName("but_lighting")
self.but_lighting.setToolTip("Enable light source")
self.lblAlpha = QLabel(to_html("Alpha", frmt='bi'), self)
self.diaAlpha = QDial(self)
self.diaAlpha.setRange(0, 10)
self.diaAlpha.setValue(10)
self.diaAlpha.setTracking(False) # produce less events when turning
self.diaAlpha.setFixedHeight(30)
self.diaAlpha.setFixedWidth(30)
self.diaAlpha.setWrapping(False)
self.diaAlpha.setToolTip(
"<span>Set transparency for surf and contour plots.</span>")
self.lblHatch = QLabel(to_html("Stride", frmt='bi'), self)
self.diaHatch = QDial(self)
self.diaHatch.setRange(0, 9)
self.diaHatch.setValue(5)
self.diaHatch.setTracking(False) # produce less events when turning
self.diaHatch.setFixedHeight(30)
self.diaHatch.setFixedWidth(30)
self.diaHatch.setWrapping(False)
self.diaHatch.setToolTip("Set line density for various plots.")
self.but_contour_2d = PushButton("Contour2D ", checked=False)
self.but_contour_2d.setObjectName("chkContour2D")
self.but_contour_2d.setToolTip("Plot 2D-contours at z =0")
# ----------------------------------------------------------------------
# LAYOUT for UI widgets
# ----------------------------------------------------------------------
layGControls = QGridLayout()
layGControls.addWidget(self.but_log, 0, 0)
layGControls.addWidget(self.but_plot_in_UC, 1, 0)
layGControls.addWidget(self.lblTop, 0, 2)
layGControls.addWidget(self.ledTop, 0, 4)
layGControls.addWidget(self.lblTopdB, 0, 5)
layGControls.addWidget(self.lblBottom, 1, 2)
layGControls.addWidget(self.ledBottom, 1, 4)
layGControls.addWidget(self.lblBottomdB, 1, 5)
layGControls.setColumnStretch(5, 1)
layGControls.addWidget(self.plt_UC, 0, 6)
layGControls.addWidget(self.but_Hf, 1, 6)
layGControls.addWidget(self.but_PZ, 0, 8)
layGControls.addWidget(self.cmbMode3D, 0, 10)
layGControls.addWidget(self.but_contour_2d, 1, 10)
layGControls.addWidget(self.cmbColormap, 0, 12, 1, 1)
layGControls.addWidget(self.but_colormap_r, 1, 12)
layGControls.addWidget(self.but_lighting, 0, 14)
layGControls.addWidget(self.but_colbar, 1, 14)
layGControls.addWidget(self.lblAlpha, 0, 15)
layGControls.addWidget(self.diaAlpha, 0, 16)
layGControls.addWidget(self.lblHatch, 1, 15)
layGControls.addWidget(self.diaHatch, 1, 16)
# This widget encompasses all control subwidgets
self.frmControls = QFrame(self)
self.frmControls.setObjectName("frmControls")
self.frmControls.setLayout(layGControls)
# ----------------------------------------------------------------------
# mplwidget
# ----------------------------------------------------------------------
# This is the plot pane 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_3d.html"
self.setLayout(self.mplwidget.layVMainMpl)
self._init_grid() # initialize grid and do initial plot
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.but_log.clicked.connect(self._log_clicked)
self.ledBottom.editingFinished.connect(self._log_clicked)
self.ledTop.editingFinished.connect(self._log_clicked)
self.but_plot_in_UC.clicked.connect(self._init_grid)
self.plt_UC.clicked.connect(self.draw)
self.but_Hf.clicked.connect(self.draw)
self.but_PZ.clicked.connect(self.draw)
self.cmbMode3D.currentIndexChanged.connect(self.draw)
self.but_colbar.clicked.connect(self.draw)
self.cmbColormap.currentIndexChanged.connect(self.draw)
self.but_colormap_r.clicked.connect(self.draw)
self.but_lighting.clicked.connect(self.draw)
self.diaAlpha.valueChanged.connect(self.draw)
self.diaHatch.valueChanged.connect(self.draw)
self.but_contour_2d.clicked.connect(self.draw)
self.mplwidget.mplToolbar.sig_tx.connect(self.process_sig_rx)
# self.mplwidget.mplToolbar.enable_plot(state = False) # disable initially
# ------------------------------------------------------------------------------
def _init_cmb_colormap(self, cmap_init):
"""
Initialize combobox with available colormaps and try to set it to `cmap_init`
Since matplotlib 3.2 the reversed "*_r" colormaps are no longer contained in
`cm.datad`. They are now obtained by using the `reversed()` method (much simpler!)
`cm.datad` doesn't return the "new" colormaps like viridis, instead the
`colormaps()` method is used.
"""
self.cmbColormap.addItems(
[m for m in colormaps() if not m.endswith("_r")])
idx = self.cmbColormap.findText(cmap_init)
if idx == -1:
idx = 0
self.cmbColormap.setCurrentIndex(idx)
# ------------------------------------------------------------------------------
def _init_grid(self):
""" Initialize (x,y,z) coordinate grid + (re)draw plot."""
phi_UC = np.linspace(0, 2 * pi, 400,
endpoint=True) # angles for unit circle
self.xy_UC = np.exp(1j * phi_UC) # x,y coordinates of unity circle
steps = 100 # number of steps for x, y, r, phi
# cartesian range limits
self.xmin = -1.5
self.xmax = 1.5
self.ymin = -1.5
self.ymax = 1.5
# Polar range limits
rmin = 0
rmax = 1
# Calculate grids for 3D-Plots
dr = rmax / steps * 2 # grid size for polar range
dx = (self.xmax - self.xmin) / steps
dy = (self.ymax - self.ymin) / steps # grid size cartesian range
if self.but_plot_in_UC.isChecked(): # Plot circular range in 3D-Plot
[r,
phi] = np.meshgrid(np.arange(rmin, rmax, dr),
np.linspace(0, 2 * pi, steps, endpoint=True))
self.x = r * cos(phi)
self.y = r * sin(phi)
else: # cartesian grid
[self.x, self.y] = np.meshgrid(np.arange(self.xmin, self.xmax, dx),
np.arange(self.ymin, self.ymax, dy))
self.z = self.x + 1j * self.y # create coordinate grid for complex plane
self.draw() # initial plot
# ------------------------------------------------------------------------------
def init_axes(self):
"""
Initialize and clear the axes to get rid of colorbar
The azimuth / elevation / distance settings of the camera are restored
after clearing the axes. See
http://stackoverflow.com/questions/4575588/matplotlib-3d-plot-with-pyqt4-in-qtabwidget-mplwidget
"""
self._save_axes()
self.mplwidget.fig.clf() # needed to get rid of colorbar
self.ax3d = self.mplwidget.fig.add_subplot(111, projection='3d')
# self.ax3d = self.mplwidget.fig.subplots(nrows=1, ncols=1, projection='3d')
self._restore_axes()
# ------------------------------------------------------------------------------
def _save_axes(self):
"""
Store x/y/z - limits and camera position
"""
try:
self.azim = self.ax3d.azim
self.elev = self.ax3d.elev
self.dist = self.ax3d.dist
self.xlim = self.ax3d.get_xlim3d()
self.ylim = self.ax3d.get_ylim3d()
self.zlim = self.ax3d.get_zlim3d()
except AttributeError: # not yet initialized, set standard values
self.azim = -65
self.elev = 30
self.dist = 10
self.xlim = (self.xmin, self.xmax)
self.ylim = (self.ymin, self.ymax)
self.zlim = (self.zmin, self.zmax)
# ------------------------------------------------------------------------------
def _restore_axes(self):
"""
Restore x/y/z - limits and camera position
"""
if self.mplwidget.mplToolbar.a_lk.isChecked():
self.ax3d.set_xlim3d(self.xlim)
self.ax3d.set_ylim3d(self.ylim)
self.ax3d.set_zlim3d(self.zlim)
self.ax3d.azim = self.azim
self.ax3d.elev = self.elev
self.ax3d.dist = self.dist
# ------------------------------------------------------------------------------
def _log_clicked(self):
"""
Change scale and settings to log / lin when log setting is changed
Update min / max settings when lineEdits have been edited
"""
if self.sender().objectName(
) == 'but_log': # clicking but_log triggered the slot
if self.but_log.isChecked():
self.ledBottom.setText(str(self.zmin_dB))
self.zmax_dB = np.round(20 * log10(self.zmax), 2)
self.ledTop.setText(str(self.zmax_dB))
self.lblTopdB.setVisible(True)
self.lblBottomdB.setVisible(True)
else:
self.ledBottom.setText(str(self.zmin))
self.zmax = np.round(10**(self.zmax_dB / 20), 2)
self.ledTop.setText(str(self.zmax))
self.lblTopdB.setVisible(False)
self.lblBottomdB.setVisible(False)
else: # finishing a lineEdit field triggered the slot
if self.but_log.isChecked():
self.zmin_dB = safe_eval(self.ledBottom.text(),
self.zmin_dB,
return_type='float')
self.ledBottom.setText(str(self.zmin_dB))
self.zmax_dB = safe_eval(self.ledTop.text(),
self.zmax_dB,
return_type='float')
self.ledTop.setText(str(self.zmax_dB))
else:
self.zmin = safe_eval(self.ledBottom.text(),
self.zmin,
return_type='float')
self.ledBottom.setText(str(self.zmin))
self.zmax = safe_eval(self.ledTop.text(),
self.zmax,
return_type='float')
self.ledTop.setText(str(self.zmax))
self.draw()
# ------------------------------------------------------------------------------
def draw(self):
"""
Main drawing entry point: perform the actual plot
"""
self.draw_3d()
# ------------------------------------------------------------------------------
def draw_3d(self):
"""
Draw various 3D plots
"""
self.init_axes()
bb = fb.fil[0]['ba'][0]
aa = fb.fil[0]['ba'][1]
zz = np.array(fb.fil[0]['zpk'][0])
pp = np.array(fb.fil[0]['zpk'][1])
wholeF = fb.fil[0]['freqSpecsRangeType'] != 'half' # not used
f_S = fb.fil[0]['f_S']
N_FFT = params['N_FFT']
alpha = self.diaAlpha.value() / 10.
cmap = cm.get_cmap(str(self.cmbColormap.currentText()))
if self.but_colormap_r.isChecked():
cmap = cmap.reversed() # use reversed colormap
# Number of Lines /step size for H(f) stride, mesh, contour3d:
stride = 10 - self.diaHatch.value()
NL = 3 * self.diaHatch.value() + 5
surf_enabled = qget_cmb_box(self.cmbMode3D, data=False) in {'Surf', 'Contour'}\
or self.but_contour_2d.isChecked()
self.cmbColormap.setEnabled(surf_enabled)
self.but_colormap_r.setEnabled(surf_enabled)
self.but_lighting.setEnabled(surf_enabled)
self.but_colbar.setEnabled(surf_enabled)
self.diaAlpha.setEnabled(surf_enabled
or self.but_contour_2d.isChecked())
# cNorm = colors.Normalize(vmin=0, vmax=values[-1])
# scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet)
# -----------------------------------------------------------------------------
# Calculate H(w) along the upper half of unity circle
# -----------------------------------------------------------------------------
[w, H] = sig.freqz(bb, aa, worN=N_FFT, whole=True)
H = np.nan_to_num(H) # replace nans and inf by finite numbers
H_abs = abs(H)
H_max = max(H_abs)
H_min = min(H_abs)
# f = w / (2 * pi) * f_S # translate w to absolute frequencies
# F_min = f[np.argmin(H_abs)]
plevel_rel = 1.05 # height of plotted pole position relative to zmax
zlevel_rel = 0.1 # height of plotted zero position relative to zmax
if self.but_log.isChecked(): # logarithmic scale
# suppress "divide by zero in log10" warnings
old_settings_seterr = np.seterr()
np.seterr(divide='ignore')
bottom = np.floor(max(self.zmin_dB, 20 * log10(H_min)) / 10) * 10
top = self.zmax_dB
top_bottom = top - bottom
zlevel = bottom - top_bottom * zlevel_rel
if self.cmbMode3D.currentText(
) == 'None': # "Poleposition": H(f) plot only
plevel_top = 2 * bottom - zlevel # height of displayed pole position
plevel_btm = bottom
else:
plevel_top = top + top_bottom * (plevel_rel - 1)
plevel_btm = top
np.seterr(**old_settings_seterr)
else: # linear scale
bottom = max(self.zmin, H_min) # min. display value
top = self.zmax # max. display value
top_bottom = top - bottom
# top = zmax_rel * H_max # calculate display top from max. of H(f)
zlevel = bottom + top_bottom * zlevel_rel # height of displayed zero position
if self.cmbMode3D.currentText(
) == 'None': # "Poleposition": H(f) plot only
#H_max = np.clip(max(H_abs), 0, self.zmax)
# make height of displayed poles same to zeros
plevel_top = bottom + top_bottom * zlevel_rel
plevel_btm = bottom
else:
plevel_top = plevel_rel * top
plevel_btm = top
# calculate H(jw)| along the unity circle and |H(z)|, each clipped
# between bottom and top
H_UC = H_mag(bb,
aa,
self.xy_UC,
top,
H_min=bottom,
log=self.but_log.isChecked())
Hmag = H_mag(bb,
aa,
self.z,
top,
H_min=bottom,
log=self.but_log.isChecked())
# ===============================================================
# Plot Unit Circle (UC)
# ===============================================================
if self.plt_UC.isChecked():
# Plot unit circle and marker at (1,0):
self.ax3d.plot(self.xy_UC.real,
self.xy_UC.imag,
ones(len(self.xy_UC)) * bottom,
lw=2,
color='k')
self.ax3d.plot([0.97, 1.03], [0, 0], [bottom, bottom],
lw=2,
color='k')
# ===============================================================
# Plot ||H(f)| along unit circle as 3D-lineplot
# ===============================================================
if self.but_Hf.isChecked():
self.ax3d.plot(self.xy_UC.real,
self.xy_UC.imag,
H_UC,
alpha=0.8,
lw=4)
# draw once more as dashed white line to improve visibility
self.ax3d.plot(self.xy_UC.real, self.xy_UC.imag, H_UC, 'w--', lw=4)
if stride < 10: # plot thin vertical line every stride points on the UC
for k in range(len(self.xy_UC[::stride])):
self.ax3d.plot([
self.xy_UC.real[::stride][k],
self.xy_UC.real[::stride][k]
], [
self.xy_UC.imag[::stride][k],
self.xy_UC.imag[::stride][k]
], [
np.ones(len(self.xy_UC[::stride]))[k] * bottom,
H_UC[::stride][k]
],
linewidth=1,
color=(0.5, 0.5, 0.5))
# ===============================================================
# Plot Poles and Zeros
# ===============================================================
if self.but_PZ.isChecked():
PN_SIZE = 8 # size of P/N symbols
# Plot zero markers at |H(z_i)| = zlevel with "stems":
self.ax3d.plot(zz.real,
zz.imag,
ones(len(zz)) * zlevel,
'o',
markersize=PN_SIZE,
markeredgecolor='blue',
markeredgewidth=2.0,
markerfacecolor='none')
for k in range(len(zz)): # plot zero "stems"
self.ax3d.plot([zz[k].real, zz[k].real],
[zz[k].imag, zz[k].imag], [bottom, zlevel],
linewidth=1,
color='b')
# Plot the poles at |H(z_p)| = plevel with "stems":
self.ax3d.plot(np.real(pp),
np.imag(pp),
plevel_top,
'x',
markersize=PN_SIZE,
markeredgewidth=2.0,
markeredgecolor='red')
for k in range(len(pp)): # plot pole "stems"
self.ax3d.plot([pp[k].real, pp[k].real],
[pp[k].imag, pp[k].imag],
[plevel_btm, plevel_top],
linewidth=1,
color='r')
# ===============================================================
# 3D-Plots of |H(z)| clipped between |H(z)| = top
# ===============================================================
m_cb = cm.ScalarMappable(
cmap=cmap) # normalized proxy object that is mappable
m_cb.set_array(Hmag) # for colorbar
# ---------------------------------------------------------------
# 3D-mesh plot
# ---------------------------------------------------------------
if self.cmbMode3D.currentText() == 'Mesh':
# fig_mlab = mlab.figure(fgcolor=(0., 0., 0.), bgcolor=(1, 1, 1))
# self.ax3d.set_zlim(0,2)
self.ax3d.plot_wireframe(self.x,
self.y,
Hmag,
rstride=5,
cstride=stride,
linewidth=1,
color='gray')
# ---------------------------------------------------------------
# 3D-surface plot
# ---------------------------------------------------------------
# http://stackoverflow.com/questions/28232879/phong-shading-for-shiny-python-3d-surface-plots
elif self.cmbMode3D.currentText() == 'Surf':
if MLAB:
# Mayavi
surf = mlab.surf(self.x,
self.y,
H_mag,
colormap='RdYlBu',
warp_scale='auto')
# Change the visualization parameters.
surf.actor.property.interpolation = 'phong'
surf.actor.property.specular = 0.1
surf.actor.property.specular_power = 5
# s = mlab.contour_surf(self.x, self.y, Hmag, contour_z=0)
mlab.show()
else:
if self.but_lighting.isChecked():
ls = LightSource(azdeg=0,
altdeg=65) # Create light source object
rgb = ls.shade(
Hmag, cmap=cmap) # Shade data, creating an rgb array
cmap_surf = None
else:
rgb = None
cmap_surf = cmap
# s = self.ax3d.plot_surface(self.x, self.y, Hmag,
# alpha=OPT_3D_ALPHA, rstride=1, cstride=1, cmap=cmap,
# linewidth=0, antialiased=False, shade=True, facecolors = rgb)
# s.set_edgecolor('gray')
s = self.ax3d.plot_surface(self.x,
self.y,
Hmag,
alpha=alpha,
rstride=1,
cstride=1,
linewidth=0,
antialiased=False,
facecolors=rgb,
cmap=cmap_surf,
shade=True)
s.set_edgecolor(None)
# ---------------------------------------------------------------
# 3D-Contour plot
# ---------------------------------------------------------------
elif self.cmbMode3D.currentText() == 'Contour':
s = self.ax3d.contourf3D(self.x,
self.y,
Hmag,
NL,
alpha=alpha,
cmap=cmap)
# ---------------------------------------------------------------
# 2D-Contour plot
# TODO: 2D contour plots do not plot correctly together with 3D plots in
# current matplotlib 1.4.3 -> disable them for now
# TODO: zdir = x / y delivers unexpected results -> rather plot max(H)
# along the other axis?
# TODO: colormap is created depending on the zdir = 'z' contour plot
# -> set limits of (all) other plots manually?
if self.but_contour_2d.isChecked():
# self.ax3d.contourf(x, y, Hmag, 20, zdir='x', offset=xmin,
# cmap=cmap, alpha = alpha)#, vmin = bottom)#, vmax = top, vmin = bottom)
# self.ax3d.contourf(x, y, Hmag, 20, zdir='y', offset=ymax,
# cmap=cmap, alpha = alpha)#, vmin = bottom)#, vmax = top, vmin = bottom)
s = self.ax3d.contourf(self.x,
self.y,
Hmag,
NL,
zdir='z',
offset=bottom - (top - bottom) * 0.05,
cmap=cmap,
alpha=alpha)
# plot colorbar for suitable plot modes
if self.but_colbar.isChecked() and (
self.but_contour_2d.isChecked()
or str(self.cmbMode3D.currentText()) in {'Contour', 'Surf'}):
self.colb = self.mplwidget.fig.colorbar(m_cb,
ax=self.ax3d,
shrink=0.8,
aspect=20,
pad=0.02,
fraction=0.08)
# ----------------------------------------------------------------------
# Set view limits and labels
# ----------------------------------------------------------------------
if not self.mplwidget.mplToolbar.a_lk.isChecked():
self.ax3d.set_xlim3d(self.xmin, self.xmax)
self.ax3d.set_ylim3d(self.ymin, self.ymax)
self.ax3d.set_zlim3d(bottom, top)
else:
self._restore_axes()
self.ax3d.set_xlabel('Re') #(fb.fil[0]['plt_fLabel'])
self.ax3d.set_ylabel(
'Im'
) #(r'$ \tau_g(\mathrm{e}^{\mathrm{j} \Omega}) / T_S \; \rightarrow $')
# self.ax3d.set_zlabel(r'$|H(z)|\; \rightarrow $')
self.ax3d.set_title(
r'3D-Plot of $|H(\mathrm{e}^{\mathrm{j} \Omega})|$ and $|H(z)|$')
self.redraw()
# ------------------------------------------------------------------------------
def redraw(self):
"""
Redraw the canvas when e.g. the canvas size has changed
"""
self.mplwidget.redraw()
class Plot_Hf(QWidget):
"""
Widget for plotting \|H(f)\|, frequency specs and the phase
"""
# incoming, connected in sender widget (locally connected to self.process_sig_rx() )
sig_rx = pyqtSignal(object)
def __init__(self, parent):
super(Plot_Hf, self).__init__(parent)
self.needs_calc = True # flag whether plot needs to be updated
self.needs_draw = True # flag whether plot needs to be redrawn
self.tool_tip = "Magnitude and phase frequency response"
self.tab_label = "|H(f)|"
self.log_bottom = -80
self.lin_neg_bottom = -10
self._construct_ui()
#------------------------------------------------------------------------------
def process_sig_rx(self, dict_sig=None):
"""
Process signals coming from the navigation toolbar and from sig_rx
"""
logger.debug("SIG_RX - needs_calc = {0}, vis = {1}\n{2}"\
.format(self.needs_calc, self.isVisible(), pprint_log(dict_sig)))
if self.isVisible():
if 'data_changed' in dict_sig or 'specs_changed' in dict_sig\
or 'home' in dict_sig or self.needs_calc:
self.draw()
self.needs_calc = False
self.needs_draw = False
if 'view_changed' in dict_sig or self.needs_draw:
self.update_view()
self.needs_draw = False
else:
if 'data_changed' in dict_sig or 'specs_changed' in dict_sig:
self.needs_calc = True
if 'view_changed' in dict_sig:
self.needs_draw = True
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)
#------------------------------------------------------------------------------
def init_axes(self):
"""
Initialize and clear the axes (this is run only once)
"""
if len(self.mplwidget.fig.get_axes()) == 0: # empty figure, no axes
self.ax = self.mplwidget.fig.subplots()
self.ax.xaxis.tick_bottom() # remove axis ticks on top
self.ax.yaxis.tick_left() # remove axis ticks right
#------------------------------------------------------------------------------
def align_y_axes(self, ax1, ax2):
""" Sets tick marks of twinx axes to line up with total number of
ax1 tick marks
"""
ax1_ylims = ax1.get_ybound()
# collect only visible ticks
ax1_yticks = [
t for t in ax1.get_yticks()
if t >= ax1_ylims[0] and t <= ax1_ylims[1]
]
ax1_nticks = len(ax1_yticks)
ax1_ydelta_lim = ax1_ylims[1] - ax1_ylims[0] # span of limits
ax1_ydelta_vis = ax1_yticks[-1] - ax1_yticks[
0] # delta of max. and min tick
ax1_yoffset = ax1_yticks[0] - ax1_ylims[
0] # offset between lower limit and first tick
# calculate scale of Delta Limits / Delta Ticks
ax1_scale = ax1_ydelta_lim / ax1_ydelta_vis
ax2_ylims = ax2.get_ybound()
ax2_yticks = ax2.get_yticks()
ax2_nticks = len(ax2_yticks)
#ax2_ydelta_lim = ax2_ylims[1] - ax2_ylims[0]
ax2_ydelta_vis = ax2_yticks[-1] - ax2_yticks[0]
ax2_ydelta_lim = ax2_ydelta_vis * ax1_scale
ax2_scale = ax2_ydelta_lim / ax2_ydelta_vis
# calculate new offset between lower limit and first tick
ax2_yoffset = ax1_yoffset * ax2_ydelta_lim / ax1_ydelta_lim
logger.warning("ax2: delta_vis: {0}, scale: {1}, offset: {2}".format(
ax2_ydelta_vis, ax2_scale, ax2_yoffset))
logger.warning("Ticks: {0} # {1}".format(ax1_nticks, ax2_nticks))
ax2.set_yticks(
np.linspace(ax2_yticks[0], (ax2_yticks[1] - ax2_yticks[0]),
ax1_nticks))
logger.warning("ax2[0]={0} | ax2[1]={1} ax2[-1]={2}".format(
ax2_yticks[0], ax2_yticks[1], ax2_yticks[-1]))
ax2_lim0 = ax2_yticks[0] - ax2_yoffset
ax2.set_ybound(ax2_lim0, ax2_lim0 + ax2_ydelta_lim)
# =============================================================================
# # https://stackoverflow.com/questions/26752464/how-do-i-align-gridlines-for-two-y-axis-scales-using-matplotlib
# # works, but both axes have ugly numbers
# nticks = 11
# ax.yaxis.set_major_locator(ticker.LinearLocator(nticks))
# self.ax_p.yaxis.set_major_locator(ticker.LinearLocator(nticks))
# # =============================================================================
# =============================================================================
# # https://stackoverflow.com/questions/45037386/trouble-aligning-ticks-for-matplotlib-twinx-axes
# # works, but second axis has ugly numbering
# l_H = ax.get_ylim()
# l_p = self.ax_p.get_ylim()
# f = lambda x : l_p[0]+(x-l_H[0])/(l_H[1]-l_H[0])*(l_p[1]-l_p[0])
# ticks = f(ax.get_yticks())
# self.ax_p.yaxis.set_major_locator(ticker.FixedLocator(ticks))
#
# =============================================================================
# http://stackoverflow.com/questions/28692608/align-grid-lines-on-two-plots
# http://stackoverflow.com/questions/3654619/matplotlib-multiple-y-axes-grid-lines-applied-to-both
# http://stackoverflow.com/questions/20243683/matplotlib-align-twinx-tick-marks
# manual setting:
#self.ax_p.set_yticks( np.linspace(self.ax_p.get_ylim()[0],self.ax_p.get_ylim()[1],nbins) )
#ax1.set_yticks(np.linspace(ax1.get_ybound()[0], ax1.get_ybound()[1], 5))
#ax2.set_yticks(np.linspace(ax2.get_ybound()[0], ax2.get_ybound()[1], 5))
#http://stackoverflow.com/questions/3654619/matplotlib-multiple-y-axes-grid-lines-applied-to-both
# use helper functions from matplotlib.ticker:
# MaxNLocator: set no more than nbins + 1 ticks
#self.ax_p.yaxis.set_major_locator( matplotlib.ticker.MaxNLocator(nbins = nbins) )
# further options: integer = False,
# prune = [‘lower’ | ‘upper’ | ‘both’ | None] Remove edge ticks
# AutoLocator:
#self.ax_p.yaxis.set_major_locator( matplotlib.ticker.AutoLocator() )
# LinearLocator:
#self.ax_p.yaxis.set_major_locator( matplotlib.ticker.LinearLocator(numticks = nbins -1 ) )
# self.ax_p.locator_params(axis = 'y', nbins = nbins)
#
# self.ax_p.set_yticks(np.linspace(self.ax_p.get_ybound()[0],
# self.ax_p.get_ybound()[1],
# len(self.ax.get_yticks())-1))
#N = source_ax.xaxis.get_major_ticks()
#target_ax.xaxis.set_major_locator(LinearLocator(N))
#------------------------------------------------------------------------------
def plot_spec_limits(self, ax):
"""
Plot the specifications limits (F_SB, A_SB, ...) as hatched areas with borders.
"""
hatch = params['mpl_hatch']
hatch_borders = params['mpl_hatch_border']
def dB(lin):
return 20 * np.log10(lin)
def _plot_specs():
# upper limits:
ax.plot(F_lim_upl, A_lim_upl, F_lim_upc, A_lim_upc, F_lim_upr,
A_lim_upr, **hatch_borders)
if A_lim_upl:
ax.fill_between(F_lim_upl, max(A_lim_upl), A_lim_upl, **hatch)
if A_lim_upc:
ax.fill_between(F_lim_upc, max(A_lim_upc), A_lim_upc, **hatch)
if A_lim_upr:
ax.fill_between(F_lim_upr, max(A_lim_upr), A_lim_upr, **hatch)
# lower limits:
ax.plot(F_lim_lol, A_lim_lol, F_lim_loc, A_lim_loc, F_lim_lor,
A_lim_lor, **hatch_borders)
if A_lim_lol:
ax.fill_between(F_lim_lol, min(A_lim_lol), A_lim_lol, **hatch)
if A_lim_loc:
ax.fill_between(F_lim_loc, min(A_lim_loc), A_lim_loc, **hatch)
if A_lim_lor:
ax.fill_between(F_lim_lor, min(A_lim_lor), A_lim_lor, **hatch)
if self.unitA == 'V':
exp = 1.
elif self.unitA == 'W':
exp = 2.
if self.unitA == 'dB':
if fb.fil[0]['ft'] == "FIR":
A_PB_max = dB(1 + self.A_PB)
A_PB2_max = dB(1 + self.A_PB2)
else: # IIR dB
A_PB_max = A_PB2_max = 0
A_PB_min = dB(1 - self.A_PB)
A_PB2_min = dB(1 - self.A_PB2)
A_PB_minx = min(A_PB_min, A_PB2_min) - 5
A_PB_maxx = max(A_PB_max, A_PB2_max) + 5
A_SB = dB(self.A_SB)
A_SB2 = dB(self.A_SB2)
A_SB_maxx = max(A_SB, A_SB2) + 10
else: # 'V' or 'W'
if fb.fil[0]['ft'] == "FIR":
A_PB_max = (1 + self.A_PB)**exp
A_PB2_max = (1 + self.A_PB2)**exp
else: # IIR lin
A_PB_max = A_PB2_max = 1
A_PB_min = (1 - self.A_PB)**exp
A_PB2_min = (1 - self.A_PB2)**exp
A_PB_minx = min(A_PB_min, A_PB2_min) / 1.05
A_PB_maxx = max(A_PB_max, A_PB2_max) * 1.05
A_SB = self.A_SB**exp
A_SB2 = self.A_SB2**exp
A_SB_maxx = A_PB_min / 10.
F_max = self.f_max / 2
F_PB = self.F_PB
F_SB = fb.fil[0]['F_SB'] * self.f_max
F_SB2 = fb.fil[0]['F_SB2'] * self.f_max
F_PB2 = fb.fil[0]['F_PB2'] * self.f_max
F_lim_upl = F_lim_lol = [] # left side limits, lower and upper
A_lim_upl = A_lim_lol = []
F_lim_upc = F_lim_loc = [] # center limits, lower and upper
A_lim_upc = A_lim_loc = []
F_lim_upr = F_lim_lor = [] # right side limits, lower and upper
A_lim_upr = A_lim_lor = []
if fb.fil[0]['rt'] == 'LP':
F_lim_upl = [0, F_PB, F_PB]
A_lim_upl = [A_PB_max, A_PB_max, A_PB_maxx]
F_lim_lol = F_lim_upl
A_lim_lol = [A_PB_min, A_PB_min, A_PB_minx]
F_lim_upr = [F_SB, F_SB, F_max]
A_lim_upr = [A_SB_maxx, A_SB, A_SB]
if fb.fil[0]['rt'] == 'HP':
F_lim_upl = [0, F_SB, F_SB]
A_lim_upl = [A_SB, A_SB, A_SB_maxx]
F_lim_upr = [F_PB, F_PB, F_max]
A_lim_upr = [A_PB_maxx, A_PB_max, A_PB_max]
F_lim_lor = F_lim_upr
A_lim_lor = [A_PB_minx, A_PB_min, A_PB_min]
if fb.fil[0]['rt'] == 'BS':
F_lim_upl = [0, F_PB, F_PB]
A_lim_upl = [A_PB_max, A_PB_max, A_PB_maxx]
F_lim_lol = F_lim_upl
A_lim_lol = [A_PB_min, A_PB_min, A_PB_minx]
F_lim_upc = [F_SB, F_SB, F_SB2, F_SB2]
A_lim_upc = [A_SB_maxx, A_SB, A_SB, A_SB_maxx]
F_lim_upr = [F_PB2, F_PB2, F_max]
A_lim_upr = [A_PB_maxx, A_PB2_max, A_PB2_max]
F_lim_lor = F_lim_upr
A_lim_lor = [A_PB_minx, A_PB2_min, A_PB2_min]
if fb.fil[0]['rt'] == 'BP':
F_lim_upl = [0, F_SB, F_SB]
A_lim_upl = [A_SB, A_SB, A_SB_maxx]
F_lim_upc = [F_PB, F_PB, F_PB2, F_PB2]
A_lim_upc = [A_PB_maxx, A_PB_max, A_PB_max, A_PB_maxx]
F_lim_loc = F_lim_upc
A_lim_loc = [A_PB_minx, A_PB_min, A_PB_min, A_PB_minx]
F_lim_upr = [F_SB2, F_SB2, F_max]
A_lim_upr = [A_SB_maxx, A_SB2, A_SB2]
if fb.fil[0]['rt'] == 'HIL':
F_lim_upc = [F_PB, F_PB, F_PB2, F_PB2]
A_lim_upc = [A_PB_maxx, A_PB_max, A_PB_max, A_PB_maxx]
F_lim_loc = F_lim_upc
A_lim_loc = [A_PB_minx, A_PB_min, A_PB_min, A_PB_minx]
F_lim_upr = np.array(F_lim_upr)
F_lim_lor = np.array(F_lim_lor)
F_lim_upl = np.array(F_lim_upl)
F_lim_lol = np.array(F_lim_lol)
F_lim_upc = np.array(F_lim_upc)
F_lim_loc = np.array(F_lim_loc)
_plot_specs() # plot specs in the range 0 ... f_S/2
if fb.fil[0]['freqSpecsRangeType'] != 'half':
# add plot limits for other half of the spectrum
if fb.fil[0][
'freqSpecsRangeType'] == 'sym': # frequency axis +/- f_S/2
F_lim_upl = -F_lim_upl
F_lim_lol = -F_lim_lol
F_lim_upc = -F_lim_upc
F_lim_loc = -F_lim_loc
F_lim_upr = -F_lim_upr
F_lim_lor = -F_lim_lor
else: # -> 'whole'
F_lim_upl = self.f_max - F_lim_upl
F_lim_lol = self.f_max - F_lim_lol
F_lim_upc = self.f_max - F_lim_upc
F_lim_loc = self.f_max - F_lim_loc
F_lim_upr = self.f_max - F_lim_upr
F_lim_lor = self.f_max - F_lim_lor
_plot_specs()
#------------------------------------------------------------------------------
def draw_inset(self):
"""
Construct / destruct second axes for an inset second plot
"""
# TODO: try ax1 = zoomed_inset_axes(ax, 6, loc=1) # zoom = 6
# TODO: choose size & position of inset, maybe dependent on filter type
# or specs (i.e. where is passband etc.)
# DEBUG
# print(self.cmbInset.currentIndex(), self.mplwidget.fig.axes) # list of axes in Figure
# for ax in self.mplwidget.fig.axes:
# print(ax)
# print("cmbInset, inset_idx:",self.cmbInset.currentIndex(), self.inset_idx)
if self.cmbInset.currentIndex() > 0:
if self.inset_idx == 0:
# Inset was turned off before, create a new one
# Add an axes at position rect [left, bottom, width, height]:
self.ax_i = self.mplwidget.fig.add_axes([0.65, 0.61, .3, .3])
self.ax_i.clear() # clear old plot and specs
# draw an opaque background with the extent of the inset plot:
# self.ax_i.patch.set_facecolor('green') # without label area
# self.mplwidget.fig.patch.set_facecolor('green') # whole figure
extent = self.mplwidget.get_full_extent(self.ax_i, pad=0.0)
# Transform this back to figure coordinates - otherwise, it
# won't behave correctly when the size of the plot is changed:
extent = extent.transformed(
self.mplwidget.fig.transFigure.inverted())
rect = Rectangle((extent.xmin, extent.ymin),
extent.width,
extent.height,
facecolor=rcParams['figure.facecolor'],
edgecolor='none',
transform=self.mplwidget.fig.transFigure,
zorder=-1)
self.ax_i.patches.append(rect)
self.ax_i.set_xlim(fb.fil[0]['freqSpecsRange'])
self.ax_i.plot(self.F, self.H_plt)
if self.cmbInset.currentIndex() == 1: # edit / navigate inset
self.ax_i.set_navigate(True)
self.ax.set_navigate(False)
if self.chkSpecs.isChecked():
self.plot_spec_limits(self.ax_i)
else: # edit / navigate main plot
self.ax_i.set_navigate(False)
self.ax.set_navigate(True)
else: # inset has been turned off, delete it
self.ax.set_navigate(True)
try:
#remove ax_i from the figure
self.mplwidget.fig.delaxes(self.ax_i)
except AttributeError:
pass
self.inset_idx = self.cmbInset.currentIndex() # update index
self.draw()
#------------------------------------------------------------------------------
def draw_phase(self, ax):
"""
Draw phase on second y-axis in the axes system passed as the argument
"""
if hasattr(self, 'ax_p'):
self.mplwidget.fig.delaxes(self.ax_p)
del self.ax_p
# try:
# self.mplwidget.fig.delaxes(self.ax_p)
# except (KeyError, AttributeError):
# pass
if self.chkPhase.isChecked():
self.ax_p = ax.twinx(
) # second axes system with same x-axis for phase
self.ax_p.is_twin = True # mark this as 'twin' to suppress second grid in mpl_widget
#
phi_str = r'$\angle H(\mathrm{e}^{\mathrm{j} \Omega})$'
if fb.fil[0]['plt_phiUnit'] == 'rad':
phi_str += ' in rad ' + r'$\rightarrow $'
scale = 1.
elif fb.fil[0]['plt_phiUnit'] == 'rad/pi':
phi_str += ' in rad' + r'$ / \pi \;\rightarrow $'
scale = 1. / np.pi
else:
phi_str += ' in deg ' + r'$\rightarrow $'
scale = 180. / np.pi
# replace nan and inf by finite values, otherwise np.unwrap yields
# an array full of nans
phi = np.angle(np.nan_to_num(self.H_c))
#-----------------------------------------------------------
self.ax_p.plot(self.F,
np.unwrap(phi) * scale,
'g-.',
label="Phase")
#-----------------------------------------------------------
self.ax_p.set_ylabel(phi_str)
#------------------------------------------------------------------------------
def calc_hf(self):
"""
(Re-)Calculate the complex frequency response H(f)
"""
# calculate H_cmplx(W) (complex) for W = 0 ... 2 pi:
self.W, self.H_cmplx = calc_Hcomplex(fb.fil[0], params['N_FFT'], True)
#------------------------------------------------------------------------------
def draw(self):
"""
Re-calculate \|H(f)\| and draw the figure
"""
self.chkAlign.setVisible(self.chkPhase.isChecked())
self.calc_hf()
self.update_view()
#------------------------------------------------------------------------------
def update_view(self):
"""
Draw the figure with new limits, scale etc without recalculating H(f)
"""
# suppress "divide by zero in log10" warnings
old_settings_seterr = np.seterr()
np.seterr(divide='ignore')
# Get corners for spec display from the parameters of the target specs subwidget
try:
param_list = fb.fil_tree[fb.fil[0]['rt']][fb.fil[0]['ft']]\
[fb.fil[0]['fc']][fb.fil[0]['fo']]['tspecs'][1]['amp']
except KeyError:
param_list = []
SB = [l for l in param_list if 'A_SB' in l]
PB = [l for l in param_list if 'A_PB' in l]
if SB:
A_min = min([fb.fil[0][l] for l in SB])
else:
A_min = 5e-4
if PB:
A_max = max([fb.fil[0][l] for l in PB])
else:
A_max = 1
if np.all(self.W) is None: # H(f) has not been calculated yet
self.calc_hf()
if self.cmbUnitsA.currentText() == 'Auto':
self.unitA = fb.fil[0]['amp_specs_unit']
else:
self.unitA = self.cmbUnitsA.currentText()
# only display log bottom widget for unit dB
self.lbl_log_bottom.setVisible(self.unitA == 'dB')
self.led_log_bottom.setVisible(self.unitA == 'dB')
self.lbl_log_unit.setVisible(self.unitA == 'dB')
# Linphase settings only makes sense for amplitude plot and
# for plottin real/imag. part of H, not its magnitude
self.chkZerophase.setCheckable(self.unitA == 'V')
self.chkZerophase.setEnabled(self.unitA == 'V')
self.specs = self.chkSpecs.isChecked()
self.f_max = fb.fil[0]['f_max']
self.F_PB = fb.fil[0]['F_PB'] * self.f_max
self.f_maxB = fb.fil[0]['F_SB'] * self.f_max
self.A_PB = fb.fil[0]['A_PB']
self.A_PB2 = fb.fil[0]['A_PB2']
self.A_SB = fb.fil[0]['A_SB']
self.A_SB2 = fb.fil[0]['A_SB2']
f_lim = fb.fil[0]['freqSpecsRange']
#========= select frequency range to be displayed =====================
#=== shift, scale and select: W -> F, H_cplx -> H_c
self.F = self.W / (2 * np.pi) * self.f_max
if fb.fil[0]['freqSpecsRangeType'] == 'sym':
# shift H and F by f_S/2
self.H_c = np.fft.fftshift(self.H_cmplx)
self.F -= self.f_max / 2.
elif fb.fil[0]['freqSpecsRangeType'] == 'half':
# only use the first half of H and F
self.H_c = self.H_cmplx[0:params['N_FFT'] // 2]
self.F = self.F[0:params['N_FFT'] // 2]
else: # fb.fil[0]['freqSpecsRangeType'] == 'whole'
# use H and F as calculated
self.H_c = self.H_cmplx
# now calculate mag / real / imaginary part of H_c:
if self.chkZerophase.isChecked(): # remove the linear phase
self.H_c = self.H_c * np.exp(
1j * self.W[0:len(self.F)] * fb.fil[0]["N"] / 2.)
if self.cmbShowH.currentIndex() == 0: # show magnitude of H
H = abs(self.H_c)
H_str = r'$|H(\mathrm{e}^{\mathrm{j} \Omega})|$'
elif self.cmbShowH.currentIndex() == 1: # show real part of H
H = self.H_c.real
H_str = r'$\Re \{H(\mathrm{e}^{\mathrm{j} \Omega})\}$'
else: # show imag. part of H
H = self.H_c.imag
H_str = r'$\Im \{H(\mathrm{e}^{\mathrm{j} \Omega})\}$'
#================ Main Plotting Routine =========================
#=== clear the axes and (re)draw the plot (if selectable)
if self.ax.get_navigate():
if self.unitA == 'dB':
self.log_bottom = safe_eval(self.led_log_bottom.text(),
self.log_bottom,
return_type='float',
sign='neg')
self.led_log_bottom.setText(str(self.log_bottom))
self.H_plt = np.maximum(20 * np.log10(abs(H)), self.log_bottom)
A_lim = [self.log_bottom, 2]
H_str += ' in dB ' + r'$\rightarrow$'
elif self.unitA == 'V': # 'lin'
self.H_plt = H
if self.cmbShowH.currentIndex(
) != 0: # H can be less than zero
A_min = max(self.lin_neg_bottom,
np.nanmin(self.H_plt[np.isfinite(self.H_plt)]))
else:
A_min = 0
A_lim = [A_min, (1.05 + A_max)]
H_str += ' in V ' + r'$\rightarrow $'
self.ax.axhline(linewidth=1, color='k') # horizontal line at 0
else: # unit is W
A_lim = [0, (1.03 + A_max)**2.]
self.H_plt = H * H.conj()
H_str += ' in W ' + r'$\rightarrow $'
#logger.debug("lim: {0}, min: {1}, max: {2} - {3}".format(A_lim, A_min, A_max, self.H_plt[0]))
#-----------------------------------------------------------
self.ax.clear()
self.ax.plot(self.F, self.H_plt, label='H(f)')
# TODO: self.draw_inset() # this gives an infinite recursion
self.draw_phase(self.ax)
#-----------------------------------------------------------
#============= Set Limits and draw specs =========================
if self.chkSpecs.isChecked():
self.plot_spec_limits(self.ax)
# self.ax_bounds = [self.ax.get_ybound()[0], self.ax.get_ybound()[1]]#, self.ax.get]
self.ax.set_xlim(f_lim)
self.ax.set_ylim(A_lim)
# logger.warning("set limits")
self.ax.set_xlabel(fb.fil[0]['plt_fLabel'])
self.ax.set_ylabel(H_str)
if self.chkPhase.isChecked():
self.ax.set_title(r'Magnitude and Phase Frequency Response')
else:
self.ax.set_title(r'Magnitude Frequency Response')
self.ax.xaxis.set_minor_locator(
AutoMinorLocator()) # enable minor ticks
self.ax.yaxis.set_minor_locator(
AutoMinorLocator()) # enable minor ticks
np.seterr(**old_settings_seterr)
self.redraw()
#------------------------------------------------------------------------------
def redraw(self):
"""
Redraw the canvas when e.g. the canvas size has changed
"""
if hasattr(self, 'ax_p') and self.chkAlign.isChecked():
# Align gridlines between H(f) and phi nicely
self.align_y_axes(self.ax, self.ax_p)
self.mplwidget.redraw()
class Input_Fixpoint_Specs(QWidget):
"""
Create the widget that holds the dynamically loaded fixpoint filter ui
"""
# sig_resize = pyqtSignal() # emit a signal when the image has been resized
sig_rx_local = pyqtSignal(object) # incoming from subwidgets -> process_sig_rx_local
sig_rx = pyqtSignal(object) # incoming, connected to input_tab_widget.sig_rx
sig_tx = pyqtSignal(object) # outcgoing
from pyfda.libs.pyfda_qt_lib import emit
def __init__(self, parent=None):
super(Input_Fixpoint_Specs, self).__init__(parent)
self.tab_label = 'Fixpoint'
self.tool_tip = ("<span>Select a fixpoint implementation for the filter,"
" simulate it or generate a Verilog netlist.</span>")
self.parent = parent
self.fx_path = os.path.realpath(
os.path.join(dirs.INSTALL_DIR, 'fixpoint_widgets'))
self.no_fx_filter_img = os.path.join(self.fx_path, "no_fx_filter.png")
if not os.path.isfile(self.no_fx_filter_img):
logger.error("Image {0:s} not found!".format(self.no_fx_filter_img))
self.default_fx_img = os.path.join(self.fx_path, "default_fx_img.png")
if not os.path.isfile(self.default_fx_img):
logger.error("Image {0:s} not found!".format(self.default_fx_img))
self._construct_UI()
inst_wdg_list = self._update_filter_cmb()
if len(inst_wdg_list) == 0:
logger.warning("No fixpoint filter found for this type of filter!")
else:
logger.debug("Imported {0:d} fixpoint filters:\n{1}"
.format(len(inst_wdg_list.split("\n"))-1, inst_wdg_list))
self._update_fixp_widget()
# ------------------------------------------------------------------------------
def process_sig_rx_local(self, dict_sig: dict = None) -> None:
"""
Process signals coming in from input and output quantizer subwidget and the
dynamically instantiated subwidget and emit {'fx_sim': 'specs_changed'} in
the end.
"""
if dict_sig['id'] == id(self):
logger.warning(f'RX_LOCAL - Stopped infinite loop: "{first_item(dict_sig)}"')
return
elif 'fx_sim' in dict_sig and dict_sig['fx_sim'] == 'specs_changed':
self.wdg_dict2ui() # update wordlengths in UI and set RUN button to 'changed'
dict_sig.update({'id': id(self)}) # propagate 'specs_changed' with self 'id'
self.emit(dict_sig)
return
# ---- Process input and output quantizer settings ('ui' in dict_sig) --
elif 'ui' in dict_sig:
if 'wdg_name' not in dict_sig:
logger.warning(f"No key 'wdg_name' in dict_sig:\n{pprint_log(dict_sig)}")
return
elif dict_sig['wdg_name'] == 'w_input':
"""
Input fixpoint format has been changed or butLock has been clicked.
When I/O lock is active, copy input fixpoint word format to output
word format.
"""
if dict_sig['ui'] == 'butLock'\
and not self.wdg_w_input.butLock.isChecked():
# butLock was deactivitated, don't do anything
return
elif self.wdg_w_input.butLock.isChecked():
# but lock was activated or wordlength setting have been changed
fb.fil[0]['fxqc']['QO']['WI'] = fb.fil[0]['fxqc']['QI']['WI']
fb.fil[0]['fxqc']['QO']['WF'] = fb.fil[0]['fxqc']['QI']['WF']
fb.fil[0]['fxqc']['QO']['W'] = fb.fil[0]['fxqc']['QI']['W']
elif dict_sig['wdg_name'] == 'w_output':
"""
Output fixpoint format has been changed. When I/O lock is active, copy
output fixpoint word format to input word format.
"""
if self.wdg_w_input.butLock.isChecked():
fb.fil[0]['fxqc']['QI']['WI'] = fb.fil[0]['fxqc']['QO']['WI']
fb.fil[0]['fxqc']['QI']['WF'] = fb.fil[0]['fxqc']['QO']['WF']
fb.fil[0]['fxqc']['QI']['W'] = fb.fil[0]['fxqc']['QO']['W']
elif dict_sig['wdg_name'] in {'q_output', 'q_input'}:
pass
else:
logger.error("Unknown wdg_name '{0}' in dict_sig:\n{1}"
.format(dict_sig['wdg_name'], pprint_log(dict_sig)))
return
if dict_sig['ui'] not in {'WI', 'WF', 'ovfl', 'quant', 'cmbW', 'butLock'}:
logger.warning("Unknown value '{0}' for key 'ui'".format(dict_sig['ui']))
self.wdg_dict2ui() # update wordlengths in UI and set RUN button to 'changed'
self.emit({'fx_sim': 'specs_changed'}) # propagate 'specs_changed'
else:
logger.error(f"Unknown key/value in 'dict_sig':\n{pprint_log(dict_sig)}")
# ------------------------------------------------------------------------------
def process_sig_rx(self, dict_sig: dict = None) -> None:
"""
Process signals coming in via `sig_rx` from other widgets.
Trigger fx simulation:
1. ``fx_sim': 'init'``: Start fixpoint simulation by sending
'fx_sim':'start_fx_response_calculation'
2. ``fx_sim_calc_response()``: Receive stimulus from widget in
'fx_sim':'calc_frame_fx_response' and pass it to fixpoint simulation method
3. Store fixpoint response in `fb.fx_result` and return to initiating routine
"""
# logger.info(
# "SIG_RX(): vis={0}\n{1}".format(self.isVisible(), pprint_log(dict_sig)))
# logger.debug(f'SIG_RX(): "{first_item(dict_sig)}"')
if dict_sig['id'] == id(self):
# logger.warning(f'Stopped infinite loop: "{first_item(dict_sig)}"')
return
elif 'data_changed' in dict_sig and dict_sig['data_changed'] == "filter_designed":
# New filter has been designed, update list of available filter topologies
self._update_filter_cmb()
return
elif 'data_changed' in dict_sig or\
('view_changed' in dict_sig and dict_sig['view_changed'] == 'q_coeff'):
# Filter data has changed (but not the filter type) or the coefficient
# format / wordlength have been changed in `input_coeffs`. The latter means
# the view / display has been changed (wordlength) but not the actual
# coefficients in the `input_coeffs` widget. However, the wordlength setting
# is copied to the fxqc dict and from there to the fixpoint widget.
# - update fields in the fixpoint filter widget - wordlength may have
# been changed.
# - Set RUN button to "changed" in wdg_dict2ui()
self.wdg_dict2ui()
# --------------- FX Simulation -------------------------------------------
elif 'fx_sim' in dict_sig:
if dict_sig['fx_sim'] == 'init':
# fixpoint simulation has been started externally, e.g. by
# `impz.impz_init()`, return a handle to the fixpoint filter function
# via signal-slot connection
if not self.fx_wdg_found:
logger.error("No fixpoint widget found!")
qstyle_widget(self.butSimFx, "error")
self.emit({'fx_sim': 'error'})
elif self.fx_sim_init() != 0: # returned an error
qstyle_widget(self.butSimFx, "error")
self.emit({'fx_sim': 'error'})
else:
self.emit({'fx_sim': 'start_fx_response_calculation',
'fxfilter_func': self.fx_filt_ui.fxfilter})
elif dict_sig['fx_sim'] == 'calc_frame_fx_response':
self.fx_sim_calc_response(dict_sig)
# return to the routine collecting the response frame by frame
return
elif dict_sig['fx_sim'] == 'specs_changed':
# fixpoint specification have been changed somewhere, update ui
# and set run button to "changed" in wdg_dict2ui()
self.wdg_dict2ui()
elif dict_sig['fx_sim'] == 'finish':
qstyle_widget(self.butSimFx, "normal")
else:
logger.error('Unknown "fx_sim" command option "{0}"\n'
'\treceived from "{1}".'
.format(dict_sig['fx_sim'], dict_sig['class']))
# ---- resize image when "Fixpoint" tab is selected or widget size is changed:
elif 'ui_changed' in dict_sig and dict_sig['ui_changed'] in {'resized', 'tab'}\
and self.isVisible():
self.resize_img()
# ------------------------------------------------------------------------------
def _construct_UI(self) -> None:
"""
Intitialize the main GUI, consisting of:
- A combo box to select the filter topology and an image of the topology
- The input quantizer
- The UI of the fixpoint filter widget
- Simulation and export buttons
"""
# ------------------------------------------------------------------------------
# Define frame and layout for the dynamically updated filter widget
# The actual filter widget is instantiated in self.set_fixp_widget() later on
self.layH_fx_wdg = QHBoxLayout()
# self.layH_fx_wdg.setContentsMargins(*params['wdg_margins'])
frmHDL_wdg = QFrame(self)
frmHDL_wdg.setLayout(self.layH_fx_wdg)
# frmHDL_wdg.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
# ------------------------------------------------------------------------------
# Initialize fixpoint filter combobox, title and description
# ------------------------------------------------------------------------------
self.cmb_fx_wdg = QComboBox(self)
self.cmb_fx_wdg.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.lblTitle = QLabel("not set", self)
self.lblTitle.setWordWrap(True)
self.lblTitle.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
layHTitle = QHBoxLayout()
layHTitle.addWidget(self.cmb_fx_wdg)
layHTitle.addWidget(self.lblTitle)
self.frmTitle = QFrame(self)
self.frmTitle.setLayout(layHTitle)
self.frmTitle.setContentsMargins(*params['wdg_margins'])
# ------------------------------------------------------------------------------
# Input and Output Quantizer
# ------------------------------------------------------------------------------
# - instantiate widgets for input and output quantizer
# - pass the quantization (sub-?) dictionary to the constructor
# ------------------------------------------------------------------------------
self.wdg_w_input = UI_W(self, q_dict=fb.fil[0]['fxqc']['QI'],
wdg_name='w_input', label='', lock_visible=True)
self.wdg_w_input.sig_tx.connect(self.process_sig_rx_local)
cmb_q = ['round', 'floor', 'fix']
self.wdg_w_output = UI_W(self, q_dict=fb.fil[0]['fxqc']['QO'],
wdg_name='w_output', label='')
self.wdg_w_output.sig_tx.connect(self.process_sig_rx_local)
self.wdg_q_output = UI_Q(self, q_dict=fb.fil[0]['fxqc']['QO'],
wdg_name='q_output',
label='Output Format <i>Q<sub>Y </sub></i>:',
cmb_q=cmb_q, cmb_ov=['wrap', 'sat'])
self.wdg_q_output.sig_tx.connect(self.sig_rx_local)
if HAS_DS:
cmb_q.append('dsm')
self.wdg_q_input = UI_Q(self, q_dict=fb.fil[0]['fxqc']['QI'],
wdg_name='q_input',
label='Input Format <i>Q<sub>X </sub></i>:',
cmb_q=cmb_q)
self.wdg_q_input.sig_tx.connect(self.sig_rx_local)
# Layout and frame for input quantization
layVQiWdg = QVBoxLayout()
layVQiWdg.addWidget(self.wdg_q_input)
layVQiWdg.addWidget(self.wdg_w_input)
frmQiWdg = QFrame(self)
# frmBtns.setFrameStyle(QFrame.StyledPanel|QFrame.Sunken)
frmQiWdg.setLayout(layVQiWdg)
frmQiWdg.setContentsMargins(*params['wdg_margins'])
# Layout and frame for output quantization
layVQoWdg = QVBoxLayout()
layVQoWdg.addWidget(self.wdg_q_output)
layVQoWdg.addWidget(self.wdg_w_output)
frmQoWdg = QFrame(self)
# frmBtns.setFrameStyle(QFrame.StyledPanel|QFrame.Sunken)
frmQoWdg.setLayout(layVQoWdg)
frmQoWdg.setContentsMargins(*params['wdg_margins'])
# ------------------------------------------------------------------------------
# Dynamically updated image of filter topology (label as placeholder)
# ------------------------------------------------------------------------------
# allow setting background color
# lbl_fixp_img_palette = QPalette()
# lbl_fixp_img_palette.setColor(QPalette(window, Qt: white))
# lbl_fixp_img_palette.setBrush(self.backgroundRole(), QColor(150, 0, 0))
# lbl_fixp_img_palette.setColor(QPalette: WindowText, Qt: blue)
self.lbl_fixp_img = QLabel("img not set", self)
self.lbl_fixp_img.setAutoFillBackground(True)
# self.lbl_fixp_img.setPalette(lbl_fixp_img_palette)
# self.lbl_fixp_img.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.embed_fixp_img(self.no_fx_filter_img)
layHImg = QHBoxLayout()
layHImg.setContentsMargins(0, 0, 0, 0)
layHImg.addWidget(self.lbl_fixp_img) # , Qt.AlignCenter)
self.frmImg = QFrame(self)
self.frmImg.setLayout(layHImg)
self.frmImg.setContentsMargins(*params['wdg_margins'])
# ------------------------------------------------------------------------------
# Simulation and export Buttons
# ------------------------------------------------------------------------------
self.butExportHDL = QPushButton(self)
self.butExportHDL.setToolTip(
"Create Verilog or VHDL netlist for fixpoint filter.")
self.butExportHDL.setText("Create HDL")
self.butSimFx = QPushButton(self)
self.butSimFx.setToolTip("Start fixpoint simulation.")
self.butSimFx.setText("Sim. FX")
self.layHHdlBtns = QHBoxLayout()
self.layHHdlBtns.addWidget(self.butSimFx)
self.layHHdlBtns.addWidget(self.butExportHDL)
# This frame encompasses the HDL buttons sim and convert
frmHdlBtns = QFrame(self)
# frmBtns.setFrameStyle(QFrame.StyledPanel|QFrame.Sunken)
frmHdlBtns.setLayout(self.layHHdlBtns)
frmHdlBtns.setContentsMargins(*params['wdg_margins'])
# -------------------------------------------------------------------
# Top level layout
# -------------------------------------------------------------------
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
splitter.addWidget(frmHDL_wdg)
splitter.addWidget(frmQoWdg)
splitter.addWidget(self.frmImg)
# 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, 3000, 5000])
layVMain = QVBoxLayout()
layVMain.addWidget(self.frmTitle)
layVMain.addWidget(frmHdlBtns)
layVMain.addWidget(frmQiWdg)
layVMain.addWidget(splitter)
layVMain.addStretch()
layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(layVMain)
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
self.sig_rx_local.connect(self.process_sig_rx_local)
# dynamic connection in `self._update_fixp_widget()`:
# -----
# if hasattr(self.fx_filt_ui, "sig_rx"):
# self.sig_rx.connect(self.fx_filt_ui.sig_rx)
# if hasattr(self.fx_filt_ui, "sig_tx"):
# self.fx_filt_ui.sig_tx.connect(self.sig_rx_local)
# ----
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.cmb_fx_wdg.currentIndexChanged.connect(self._update_fixp_widget)
self.butExportHDL.clicked.connect(self.exportHDL)
self.butSimFx.clicked.connect(lambda x: self.emit({'fx_sim': 'start'}))
# ----------------------------------------------------------------------
# EVENT FILTER
# ----------------------------------------------------------------------
# # monitor events and generate sig_resize event when resized
# self.lbl_fixp_img.installEventFilter(self)
# # ... then redraw image when resized
# self.sig_resize.connect(self.resize_img)
# ------------------------------------------------------------------------------
def _update_filter_cmb(self) -> str:
"""
(Re-)Read list of available fixpoint filters for a given filter design
every time a new filter design is selected.
Then try to import the fixpoint designs in the list and populate the
fixpoint implementation combo box `self.cmb_fx_wdg` when successfull.
Returns
-------
inst_wdg_str: str
string with all fixpoint widgets that could be instantiated successfully
"""
inst_wdg_str = "" # full names of successfully instantiated widgets for logging
# remember last fx widget setting:
last_fx_wdg = qget_cmb_box(self.cmb_fx_wdg, data=False)
self.cmb_fx_wdg.clear()
fc = fb.fil[0]['fc']
if 'fix' in fb.filter_classes[fc]:
self.cmb_fx_wdg.blockSignals(True)
for class_name in fb.filter_classes[fc]['fix']: # get class name
try: # construct module + class name ...
mod_class_name = fb.fixpoint_classes[class_name]['mod'] + '.'\
+ class_name
# ... and display name
disp_name = fb.fixpoint_classes[class_name]['name']
self.cmb_fx_wdg.addItem(disp_name, mod_class_name)
inst_wdg_str += '\t' + class_name + ' : ' + mod_class_name + '\n'
except AttributeError as e:
logger.warning('Widget "{0}":\n{1}'.format(class_name, e))
self.embed_fixp_img(self.no_fx_filter_img)
continue # with next `class_name` of for loop
except KeyError as e:
logger.warning("No fixpoint filter for filter type {0} available."
.format(e))
self.embed_fixp_img(self.no_fx_filter_img)
continue # with next `class_name` of for loop
# restore last fx widget if possible
idx = self.cmb_fx_wdg.findText(last_fx_wdg)
# set to idx 0 if not found (returned -1)
self.cmb_fx_wdg.setCurrentIndex(max(idx, 0))
self.cmb_fx_wdg.blockSignals(False)
else: # no fixpoint widget
self.embed_fixp_img(self.no_fx_filter_img)
self._update_fixp_widget()
return inst_wdg_str
# # ------------------------------------------------------------------------------
# def eventFilter(self, source, event):
# """
# Filter all events generated by monitored QLabel, only resize events are
# processed here, generating a `sig_resize` signal. All other events
# are passed on to the next hierarchy level.
# """
# if event.type() == QEvent.Resize:
# logger.warning("resize event!")
# self.sig_resize.emit()
# # Call base class method to continue normal event processing:
# return super(Input_Fixpoint_Specs, self).eventFilter(source, event)
# ------------------------------------------------------------------------------
def embed_fixp_img(self, img_file: str) -> QPixmap:
"""
Embed `img_file` in png format as `self.img_fixp`
Parameters
----------
img_file: str
path and file name to image file
Returns
-------
self.img_fixp: QPixmap object
pixmap containing the passed img_file
"""
if not os.path.isfile(img_file):
logger.warning("Image file {0} doesn't exist.".format(img_file))
img_file = self.default_fx_img
_, file_extension = os.path.splitext(img_file)
if file_extension != '.png':
logger.error('Unknown file extension "{0}"!'.format(file_extension))
img_file = self.default_fx_img
self.img_fixp = QPixmap(img_file)
# logger.warning(f"img_fixp = {img_file}")
# logger.warning(f"_embed_fixp_img(): {self.img_fixp.__class__.__name__}")
return self.img_fixp
# ------------------------------------------------------------------------------
def resize_img(self) -> None:
"""
Triggered when `self` (the widget) is selected or resized. The method resizes
the image inside QLabel to completely fill the label while keeping
the aspect ratio. An offset of some pixels is needed, otherwise the image
is clipped.
"""
# logger.warning(f"resize_img(): img_fixp = {self.img_fixp.__class__.__name__}")
if self.parent is None: # parent is QApplication, has no width or height
par_w, par_h = 300, 700 # fixed size for module level test
else: # widget parent is InputTabWidget()
par_w, par_h = self.parent.width(), self.parent.height()
img_w, img_h = self.img_fixp.width(), self.img_fixp.height()
if img_w > 10:
max_h = int(max(np.floor(img_h * par_w/img_w) - 5, 20))
else:
max_h = 200
logger.debug("img size: {0},{1}, frm size: {2},{3}, max_h: {4}"
.format(img_w, img_h, par_w, par_h, max_h))
# The following doesn't work because the width of the parent widget can grow
# with the image size
# img_scaled = self.img_fixp.scaled(self.lbl_fixp_img.size(),
# Qt.KeepAspectRatio, Qt.SmoothTransformation)
img_scaled = self.img_fixp.scaledToHeight(max_h, Qt.SmoothTransformation)
self.lbl_fixp_img.setPixmap(img_scaled)
# ------------------------------------------------------------------------------
def _update_fixp_widget(self):
"""
This method is called at the initialization of the widget and when
a new fixpoint filter implementation is selected from the combo box:
- Destruct old instance of fixpoint filter widget `self.fx_filt_ui`
- Import and instantiate new fixpoint filter widget e.g. after changing the
filter topology as
- Try to load image for filter topology
- Update the UI of the widget
- Try to instantiate HDL filter as `self.fx_filt_ui.fixp_filter` with
dummy data
- emit {'fx_sim': 'specs_changed'} when successful
"""
def _disable_fx_wdg(self) -> None:
if hasattr(self, "fx_filt_ui") and self.fx_filt_ui is not None:
# is a fixpoint widget loaded?
try:
# try to remove widget from layout
self.layH_fx_wdg.removeWidget(self.fx_filt_ui)
# delete QWidget when scope has been left
self.fx_filt_ui.deleteLater()
except AttributeError as e:
logger.error("Destructing UI failed!\n{0}".format(e))
self.fx_wdg_found = False
self.butSimFx.setEnabled(False)
self.butExportHDL.setVisible(False)
# self.layH_fx_wdg.setVisible(False)
self.img_fixp = self.embed_fixp_img(self.no_fx_filter_img)
self.resize_img()
self.lblTitle.setText("")
self.fx_filt_ui = None
# -----------------------------------------------------------
_disable_fx_wdg(self) # destruct old fixpoint widget instance:
# instantiate new fixpoint widget class as self.fx_filt_ui
cmb_wdg_fx_cur = qget_cmb_box(self.cmb_fx_wdg, data=False)
if cmb_wdg_fx_cur: # at least one valid fixpoint widget found
self.fx_wdg_found = True
# get list [module name and path, class name]
fx_mod_class_name = qget_cmb_box(self.cmb_fx_wdg, data=True).rsplit('.', 1)
fx_mod = importlib.import_module(fx_mod_class_name[0]) # get module
fx_filt_ui_class = getattr(fx_mod, fx_mod_class_name[1]) # get class
logger.info("Instantiating new FX widget\n\t"
f"{fx_mod.__name__}.{fx_filt_ui_class.__name__}")
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
self.fx_filt_ui = fx_filt_ui_class() # instantiate the fixpoint widget
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# and add it to layout:
self.layH_fx_wdg.addWidget(self.fx_filt_ui, stretch=1)
self.fx_filt_ui.setVisible(True)
self.wdg_dict2ui() # initialize the fixpoint subwidgets from the fxqc_dict
# ---- connect signals to fx_filt_ui ----
if hasattr(self.fx_filt_ui, "sig_rx"):
self.sig_rx.connect(self.fx_filt_ui.sig_rx)
if hasattr(self.fx_filt_ui, "sig_tx"):
self.fx_filt_ui.sig_tx.connect(self.sig_rx_local)
# ---- get name of new fixpoint filter image ----
if not (hasattr(self.fx_filt_ui, "img_name") and self.fx_filt_ui.img_name):
# no image name defined, use default image
img_file = self.default_fx_img
else:
# get path of imported fixpoint widget ...
file_path = os.path.dirname(fx_mod.__file__)
# ... and construct full image name from it
img_file = os.path.join(file_path, self.fx_filt_ui.img_name)
# ---- instantiate and scale graphic of filter topology ----
self.embed_fixp_img(img_file)
self.resize_img()
# ---- set title and description for filter
self.lblTitle.setText(self.fx_filt_ui.title)
# Check which methods the fixpoint widget provides and enable
# corresponding buttons:
self.butExportHDL.setVisible(hasattr(self.fx_filt_ui, "to_hdl"))
self.butSimFx.setEnabled(hasattr(self.fx_filt_ui, "fxfilter"))
self.update_fxqc_dict()
self.emit({'fx_sim': 'specs_changed'})
# ------------------------------------------------------------------------------
def wdg_dict2ui(self):
"""
Trigger an update of the fixpoint widget UI when view (i.e. fixpoint
coefficient format) or data have been changed outside this class. Additionally,
pass the fixpoint quantization widget to update / restore other subwidget
settings.
Set the RUN button to "changed".
"""
# fb.fil[0]['fxqc']['QCB'].update({'scale':(1 << fb.fil[0]['fxqc']['QCB']['W'])})
self.wdg_q_input.dict2ui(fb.fil[0]['fxqc']['QI'])
self.wdg_q_output.dict2ui(fb.fil[0]['fxqc']['QO'])
self.wdg_w_input.dict2ui(fb.fil[0]['fxqc']['QI'])
self.wdg_w_output.dict2ui(fb.fil[0]['fxqc']['QO'])
if self.fx_wdg_found and hasattr(self.fx_filt_ui, "dict2ui"):
self.fx_filt_ui.dict2ui()
# dict_sig = {'fx_sim':'specs_changed'}
# self.emit(dict_sig)
qstyle_widget(self.butSimFx, "changed")
# ------------------------------------------------------------------------------
def update_fxqc_dict(self):
"""
Update the fxqc dictionary before simulation / HDL generation starts.
"""
if self.fx_wdg_found:
# get a dict with the coefficients and fixpoint settings from fixpoint widget
if hasattr(self.fx_filt_ui, "ui2dict"):
fb.fil[0]['fxqc'].update(self.fx_filt_ui.ui2dict())
logger.debug("update fxqc: \n{0}".format(pprint_log(fb.fil[0]['fxqc'])))
else:
logger.error("No fixpoint widget found!")
# ------------------------------------------------------------------------------
def exportHDL(self):
"""
Synthesize HDL description of filter
"""
dlg = QFD(self) # instantiate file dialog object
file_types = "Verilog (*.v)"
# needed for overwrite confirmation when name is entered without suffix:
dlg.setDefaultSuffix('v')
dlg.setWindowTitle('Export Verilog')
dlg.setNameFilter(file_types)
dlg.setDirectory(dirs.save_dir)
# set mode "save file" instead "open file":
dlg.setAcceptMode(QFD.AcceptSave)
dlg.setOption(QFD.DontConfirmOverwrite, False)
if dlg.exec_() == QFD.Accepted:
hdl_file = qstr(dlg.selectedFiles()[0])
# hdl_type = extract_file_ext(qstr(dlg.selectedNameFilter()))[0]
# =============================================================================
# # static method getSaveFileName_() is simple but unflexible
# hdl_file, hdl_filter = dlg.getSaveFileName_(
# caption="Save Verilog netlist as (this also defines the module name)",
# directory=dirs.save_dir, filter=file_types)
# hdl_file = qstr(hdl_file)
# if hdl_file != "": # "operation cancelled" returns an empty string
# # return '.v' or '.vhd' depending on filetype selection:
# # hdl_type = extract_file_ext(qstr(hdl_filter))[0]
# # sanitized dir + filename + suffix. The filename suffix is replaced
# # by `v` later.
# hdl_file = os.path.normpath(hdl_file) # complete path + file name
# =============================================================================
hdl_dir_name = os.path.dirname(hdl_file) # extract the directory path
if not os.path.isdir(hdl_dir_name): # create directory if it doesn't exist
os.mkdir(hdl_dir_name)
dirs.save_dir = hdl_dir_name # make this directory the new default / base dir
hdl_file_name = os.path.splitext(os.path.basename(hdl_file))[0]
hdl_full_name = os.path.join(hdl_dir_name, hdl_file_name + ".v")
# remove all non-alphanumeric chars:
vlog_mod_name = re.sub(r'\W+', '', hdl_file_name).lower()
logger.info('Creating hdl_file "{0}"\n\twith top level module "{1}"'
.format(hdl_full_name, vlog_mod_name))
try:
self.update_fxqc_dict()
self.fx_filt_ui.construct_fixp_filter()
code = self.fx_filt_ui.to_hdl(name=vlog_mod_name)
# logger.info(str(code)) # print verilog code to console
with io.open(hdl_full_name, 'w', encoding="utf8") as f:
f.write(str(code))
logger.info("HDL conversion finished!")
except (IOError, TypeError) as e:
logger.warning(e)
# --------------------------------------------------------------------------
def fx_sim_init(self):
"""
Initialize fix-point simulation:
- Update the `fxqc_dict` containing all quantization information
- Setup a filter instance for fixpoint simulation
- Request a stimulus signal
Returns
-------
error: int
0 for sucessful fx widget construction, -1 for error
"""
try:
self.update_fxqc_dict()
self.fx_filt_ui.init_filter() # setup filter instance
return 0
except ValueError as e:
logger.error('Fixpoint stimulus generation failed during "init"'
'\nwith "{0} "'.format(e))
return -1
# ------------------------------------------------------------------------------
def fx_sim_calc_response(self, dict_sig) -> None:
"""
- Read fixpoint stimulus from `dict_sig` in integer format
- Pass it to the fixpoint filter which calculates the fixpoint response
- Store the result in `fb.fx_results` and return. In case of an error,
`fb.fx_results == None`
Returns
-------
None
"""
try:
# logger.info(
# 'Simulate fixpoint frame with "{0}" stimulus:\n\t{1}'.format(
# dict_sig['class'],
# pprint_log(dict_sig['fx_stimulus'], tab=" "),
# ))
# Run fixpoint simulation and store the results as integer values:
fb.fx_results = self.fx_filt_ui.fxfilter(dict_sig['fx_stimulus'])
if len(fb.fx_results) == 0:
logger.error("Fixpoint simulation returned empty results!")
# else:
# # logger.debug("fx_results: {0}"\
# # .format(pprint_log(fb.fx_results, tab= " ")))
# logger.info(
# f'Fixpoint simulation successful for dict\n{pprint_log(dict_sig)}'
# f'\tStimuli: Shape {np.shape(dict_sig["fx_stimulus"])}'
# f' of type "{dict_sig["fx_stimulus"].dtype}"'
# f'\n\tResponse: Shape {np.shape(fb.fx_results)}'
# f' of type "{type(fb.fx_results).__name__} "'
# f' ("{type(fb.fx_results[0]).__name__}")'
# )
except ValueError as e:
logger.error("Simulator error {0}".format(e))
fb.fx_results = None
except AssertionError as e:
logger.error('Fixpoint simulation failed for dict\n{0}'
'\twith msg. "{1}"\n\tStimuli: Shape {2} of type "{3}"'
'\n\tResponse: Shape {4} of type "{5}"'.format(
pprint_log(dict_sig), e,
np.shape(dict_sig['fx_stimulus']),
dict_sig['fx_stimulus'].dtype,
np.shape(fb.fx_results),
type(fb.fx_results)
))
fb.fx_results = None
if fb.fx_results is None:
qstyle_widget(self.butSimFx, "error")
else:
pass # everything ok, return
# logger.debug("Sending fixpoint results")
return
class FreqUnits(QWidget):
"""
Build and update widget for entering the frequency units
The following key-value pairs of the `fb.fil[0]` dict are modified:
- `'freq_specs_unit'` : The unit ('k', 'f_S', 'f_Ny', 'Hz' etc.) as a string
- `'freqSpecsRange'` : A list with two entries for minimum and maximum frequency
values for labelling the frequency axis
- `'f_S'` : The sampling frequency for referring frequency values to as a float
- `'f_max'` : maximum frequency for scaling frequency axis
- `'plt_fUnit'`: frequency unit as string
- `'plt_tUnit'`: time unit as string
- `'plt_fLabel'`: label for frequency axis
- `'plt_tLabel'`: label for time axis
"""
# class variables (shared between instances if more than one exists)
sig_tx = pyqtSignal(object) # outgoing
def __init__(self, parent, title="Frequency Units"):
super(FreqUnits, self).__init__(parent)
self.title = title
self.spec_edited = False # flag whether QLineEdit field has been edited
self._construct_UI()
def _construct_UI(self):
"""
Construct the User Interface
"""
self.layVMain = QVBoxLayout() # Widget main layout
f_units = ['k', 'f_S', 'f_Ny', 'Hz', 'kHz', 'MHz', 'GHz']
self.t_units = ['', '', '', 's', 'ms', r'$\mu$s', 'ns']
bfont = QFont()
bfont.setBold(True)
self.lblUnits = QLabel(self)
self.lblUnits.setText("Freq. Unit:")
self.lblUnits.setFont(bfont)
self.fs_old = fb.fil[0]['f_S'] # store current sampling frequency
self.ledF_S = QLineEdit()
self.ledF_S.setText(str(fb.fil[0]["f_S"]))
self.ledF_S.setObjectName("f_S")
self.ledF_S.installEventFilter(self) # filter events
self.lblF_S = QLabel(self)
self.lblF_S.setText(to_html("f_S", frmt='bi'))
self.cmbUnits = QComboBox(self)
self.cmbUnits.setObjectName("cmbUnits")
self.cmbUnits.addItems(f_units)
self.cmbUnits.setToolTip(
'Select whether frequencies are specified w.r.t. \n'
'the sampling frequency "f_S", to the Nyquist frequency \n'
'f_Ny = f_S/2 or as absolute values. "k" specifies frequencies w.r.t. f_S '
'but plots graphs over the frequency index k.')
self.cmbUnits.setCurrentIndex(1)
# self.cmbUnits.setItemData(0, (0,QColor("#FF333D"),Qt.BackgroundColorRole))#
# self.cmbUnits.setItemData(0, (QFont('Verdana', bold=True), Qt.FontRole)
fRanges = [("0...½", "half"), ("0...1", "whole"), ("-½...½", "sym")]
self.cmbFRange = QComboBox(self)
self.cmbFRange.setObjectName("cmbFRange")
for f in fRanges:
self.cmbFRange.addItem(f[0], f[1])
self.cmbFRange.setToolTip("Select frequency range (whole or half).")
self.cmbFRange.setCurrentIndex(0)
# Combobox resizes with longest entry
self.cmbUnits.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmbFRange.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.butSort = QToolButton(self)
self.butSort.setText("Sort")
self.butSort.setCheckable(True)
self.butSort.setChecked(True)
self.butSort.setToolTip(
"Sort frequencies in ascending order when pushed.")
self.butSort.setStyleSheet("QToolButton:checked {font-weight:bold}")
self.layHUnits = QHBoxLayout()
self.layHUnits.addWidget(self.cmbUnits)
self.layHUnits.addWidget(self.cmbFRange)
self.layHUnits.addWidget(self.butSort)
# Create a gridLayout consisting of QLabel and QLineEdit fields
# for setting f_S, the units and the actual frequency specs:
self.layGSpecWdg = QGridLayout() # sublayout for spec fields
self.layGSpecWdg.addWidget(self.lblF_S, 1, 0)
self.layGSpecWdg.addWidget(self.ledF_S, 1, 1)
self.layGSpecWdg.addWidget(self.lblUnits, 0, 0)
self.layGSpecWdg.addLayout(self.layHUnits, 0, 1)
frmMain = QFrame(self)
frmMain.setLayout(self.layGSpecWdg)
self.layVMain.addWidget(frmMain)
self.layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(self.layVMain)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.cmbUnits.currentIndexChanged.connect(self.update_UI)
self.cmbFRange.currentIndexChanged.connect(self._freq_range)
self.butSort.clicked.connect(self._store_sort_flag)
#----------------------------------------------------------------------
self.update_UI() # first-time initialization
#-------------------------------------------------------------
def update_UI(self):
"""
Transform the displayed frequency spec input fields according to the units
setting. Spec entries are always stored normalized w.r.t. f_S in the
dictionary; when f_S or the unit are changed, only the displayed values
of the frequency entries are updated, not the dictionary!
Signals are blocked before changing the value for f_S programmatically
update_UI is called
- during init
- when the unit combobox is changed
Finally, store freqSpecsRange and emit 'view_changed' signal via _freq_range
"""
idx = self.cmbUnits.currentIndex() # read index of units combobox
f_unit = str(self.cmbUnits.currentText()) # and the label
self.ledF_S.setVisible(f_unit not in {"f_S", "f_Ny",
"k"}) # only vis. when
self.lblF_S.setVisible(f_unit not in {"f_S", "f_Ny",
"k"}) # not normalized
f_S_scale = 1 # default setting for f_S scale
if f_unit in {"f_S", "f_Ny", "k"}: # normalized frequency
self.fs_old = fb.fil[0]['f_S'] # store current sampling frequency
if f_unit == "f_S": # normalized to f_S
fb.fil[0]['f_S'] = fb.fil[0]['f_max'] = 1.
f_label = r"$F = f\, /\, f_S = \Omega \, /\, 2 \mathrm{\pi} \; \rightarrow$"
elif f_unit == "f_Ny": # idx == 1: normalized to f_nyq = f_S / 2
fb.fil[0]['f_S'] = fb.fil[0]['f_max'] = 2.
f_label = r"$F = 2f \, / \, f_S = \Omega \, / \, \mathrm{\pi} \; \rightarrow$"
else:
fb.fil[0]['f_S'] = 1
fb.fil[0]['f_max'] = params['N_FFT']
f_label = r"$k \; \rightarrow$"
t_label = r"$n \; \rightarrow$"
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
else: # Hz, kHz, ...
if fb.fil[0]['freq_specs_unit'] in {"f_S", "f_Ny",
"k"}: # previous setting
fb.fil[0]['f_S'] = fb.fil[0][
'f_max'] = self.fs_old # restore prev. sampling frequency
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
if f_unit == "Hz":
f_S_scale = 1.
elif f_unit == "kHz":
f_S_scale = 1.e3
elif f_unit == "MHz":
f_S_scale = 1.e6
elif f_unit == "GHz":
f_S_scale = 1.e9
else:
logger.warning("Unknown frequency unit {0}".format(f_unit))
f_label = r"$f$ in " + f_unit + r"$\; \rightarrow$"
t_label = r"$t$ in " + self.t_units[idx] + r"$\; \rightarrow$"
if f_unit == "k":
plt_f_unit = "f_S"
else:
plt_f_unit = f_unit
fb.fil[0].update({'f_S_scale': f_S_scale}) # scale factor for f_S
fb.fil[0].update({'freq_specs_unit': f_unit}) # frequency unit
fb.fil[0].update({"plt_fLabel": f_label}) # label for freq. axis
fb.fil[0].update({"plt_tLabel": t_label}) # label for time axis
fb.fil[0].update({"plt_fUnit": plt_f_unit}) # frequency unit as string
fb.fil[0].update({"plt_tUnit":
self.t_units[idx]}) # time unit as string
self._freq_range(
) # update f_lim setting and emit sigUnitChanged signal
#------------------------------------------------------------------------------
def eventFilter(self, source, event):
"""
Filter all events generated by the QLineEdit widgets. Source and type
of all events generated by monitored objects are passed to this eventFilter,
evaluated and passed on to the next hierarchy level.
- When a QLineEdit widget gains input focus (QEvent.FocusIn`), display
the stored value from filter dict with full precision
- When a key is pressed inside the text field, set the `spec_edited` flag
to True.
- When a QLineEdit widget loses input focus (QEvent.FocusOut`), store
current value with full precision (only if `spec_edited`== True) and
display the stored value in selected format. Emit 'view_changed':'f_S'
"""
def _store_entry():
"""
Update filter dictionary, set line edit entry with reduced precision
again.
"""
if self.spec_edited:
fb.fil[0].update({
'f_S':
safe_eval(source.text(), fb.fil[0]['f_S'], sign='pos')
})
# TODO: ?!
self._freq_range(emit_sig_range=False) # update plotting range
self.sig_tx.emit({'sender': __name__, 'view_changed': 'f_S'})
self.spec_edited = False # reset flag, changed entry has been saved
if source.objectName() == 'f_S':
if event.type() == QEvent.FocusIn:
self.spec_edited = False
source.setText(str(fb.fil[0]['f_S'])) # full precision
elif event.type() == QEvent.KeyPress:
self.spec_edited = True # entry has been changed
key = event.key()
if key in {QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter}:
_store_entry()
elif key == QtCore.Qt.Key_Escape: # revert changes
self.spec_edited = False
source.setText(str(fb.fil[0]['f_S'])) # full precision
elif event.type() == QEvent.FocusOut:
_store_entry()
source.setText(params['FMT'].format(
fb.fil[0]['f_S'])) # reduced precision
# Call base class method to continue normal event processing:
return super(FreqUnits, self).eventFilter(source, event)
#-------------------------------------------------------------
def _freq_range(self, emit_sig_range=True):
"""
Set frequency plotting range for single-sided spectrum up to f_S/2 or f_S
or for double-sided spectrum between -f_S/2 and f_S/2 and emit
'view_changed':'f_range'.
"""
rangeType = qget_cmb_box(self.cmbFRange)
fb.fil[0].update({'freqSpecsRangeType': rangeType})
f_max = fb.fil[0]["f_max"]
if rangeType == 'whole':
f_lim = [0, f_max]
elif rangeType == 'sym':
f_lim = [-f_max / 2., f_max / 2.]
else:
f_lim = [0, f_max / 2.]
fb.fil[0]['freqSpecsRange'] = f_lim # store settings in dict
self.sig_tx.emit({'sender': __name__, 'view_changed': 'f_range'})
#-------------------------------------------------------------
def load_dict(self):
"""
Reload comboBox settings and textfields from filter dictionary
Block signals during update of combobox / lineedit widgets
"""
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
self.cmbUnits.blockSignals(True)
idx = self.cmbUnits.findText(
fb.fil[0]['freq_specs_unit']) # get and set
self.cmbUnits.setCurrentIndex(idx) # index for freq. unit combo box
self.cmbUnits.blockSignals(False)
self.cmbFRange.blockSignals(True)
idx = self.cmbFRange.findData(fb.fil[0]['freqSpecsRangeType'])
self.cmbFRange.setCurrentIndex(idx) # set frequency range
self.cmbFRange.blockSignals(False)
self.butSort.blockSignals(True)
self.butSort.setChecked(fb.fil[0]['freq_specs_sort'])
self.butSort.blockSignals(False)
#-------------------------------------------------------------
def _store_sort_flag(self):
"""
Store sort flag in filter dict and emit 'specs_changed':'f_sort'
when sort button is checked.
"""
fb.fil[0]['freq_specs_sort'] = self.butSort.isChecked()
if self.butSort.isChecked():
self.sig_tx.emit({'sender': __name__, 'specs_changed': 'f_sort'})
class SelectFilter(QWidget):
"""
Construct and read combo boxes for selecting the filter, consisting of the
following hierarchy:
1. Response Type rt (LP, HP, Hilbert, ...)
2. Filter Type ft (IIR, FIR, CIC ...)
3. Filter Class (Butterworth, ...)
Every time a combo box is changed manually, the filter tree for the selected
response resp. filter type is read and the combo box(es) further down in
the hierarchy are populated according to the available combinations.
sig_tx({'filt_changed'}) is emitted and propagated to input_filter_specs.py
where it triggers the recreation of all subwidgets.
"""
sig_tx = pyqtSignal(object) # outgoing
from pyfda.libs.pyfda_qt_lib import emit
def __init__(self, parent=None):
super(SelectFilter, self).__init__(parent)
self.fc_last = '' # previous filter class
self._construct_UI()
self._set_response_type() # first time initialization
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 load_dict(self):
"""
Reload comboboxes from filter dictionary to update changed settings
after loading a filter design from disk.
`load_dict` uses the automatism of _set_response_type etc.
of checking whether the previously selected filter design method is
also available for the new combination.
"""
# find index for response type:
rt_idx = self.cmbResponseType.findData(fb.fil[0]['rt'])
self.cmbResponseType.setCurrentIndex(rt_idx)
self._set_response_type()
# ------------------------------------------------------------------------------
def _set_response_type(self, enb_signal=False):
"""
Triggered when cmbResponseType (LP, HP, ...) is changed:
Copy selection to self.rt and fb.fil[0] and reconstruct filter type combo
If previous filter type (FIR, IIR, ...) exists for new rt, set the
filter type combo box to the old setting
"""
# Read current setting of comboBox as string and store it in the filter dict
fb.fil[0]['rt'] = self.rt = qget_cmb_box(self.cmbResponseType)
# Get list of available filter types for new rt
ft_list = list(
fb.fil_tree[self.rt].keys()) # explicit list() needed for Py3
# ---------------------------------------------------------------
# Rebuild filter type combobox entries for new rt setting
self.cmbFilterType.blockSignals(
True) # don't fire when changed programmatically
self.cmbFilterType.clear()
for ft in fb.fil_tree[self.rt]:
self.cmbFilterType.addItem(rc.ft_names[ft], ft)
# Is current filter type (e.g. IIR) in list for new rt?
if fb.fil[0]['ft'] in ft_list:
ft_idx = self.cmbFilterType.findText(fb.fil[0]['ft'])
self.cmbFilterType.setCurrentIndex(
ft_idx) # yes, set same ft as before
else:
self.cmbFilterType.setCurrentIndex(0) # no, set index 0
self.cmbFilterType.blockSignals(False)
# ---------------------------------------------------------------
self._set_filter_type(enb_signal)
# ------------------------------------------------------------------------------
def _set_filter_type(self, enb_signal=False):
""""
Triggered when cmbFilterType (IIR, FIR, ...) is changed:
- read filter type ft and copy it to fb.fil[0]['ft'] and self.ft
- (re)construct design method combo, adding
displayed text (e.g. "Chebyshev 1") and hidden data (e.g. "cheby1")
"""
# Read out current setting of comboBox and convert to string
fb.fil[0]['ft'] = self.ft = qget_cmb_box(self.cmbFilterType)
#
logger.debug("InputFilter.set_filter_type triggered: {0}".format(
self.ft))
# ---------------------------------------------------------------
# Get all available design methods for new ft from fil_tree and
# - Collect them in fc_list
# - Rebuild design method combobox entries for new ft setting:
# The combobox is populated with the "long name",
# the internal name is stored in comboBox.itemData
self.cmbFilterClass.blockSignals(True)
self.cmbFilterClass.clear()
fc_list = []
for fc in sorted(fb.fil_tree[self.rt][self.ft]):
self.cmbFilterClass.addItem(fb.filter_classes[fc]['name'], fc)
fc_list.append(fc)
logger.debug("fc_list: {0}\n{1}".format(fc_list, fb.fil[0]['fc']))
# Does new ft also provide the previous design method (e.g. ellip)?
# Has filter been instantiated?
if fb.fil[0]['fc'] in fc_list and ff.fil_inst:
# yes, set same fc as before
fc_idx = self.cmbFilterClass.findText(
fb.filter_classes[fb.fil[0]['fc']]['name'])
logger.debug("fc_idx : %s", fc_idx)
self.cmbFilterClass.setCurrentIndex(fc_idx)
else:
self.cmbFilterClass.setCurrentIndex(0) # no, set index 0
self.cmbFilterClass.blockSignals(False)
self._set_design_method(enb_signal)
# ------------------------------------------------------------------------------
def _set_design_method(self, enb_signal=False):
"""
Triggered when cmbFilterClass (cheby1, ...) is changed:
- read design method fc and copy it to fb.fil[0]
- create / update global filter instance fb.fil_inst of fc class
- update dynamic widgets (if fc has changed and if there are any)
- call load filter order
"""
fb.fil[0]['fc'] = fc = qget_cmb_box(self.cmbFilterClass)
if fc != self.fc_last: # fc has changed:
# when filter has been changed, try to destroy dynamic widgets of last fc:
if self.fc_last:
self._destruct_dyn_widgets()
# ==================================================================
"""
Create new instance of the selected filter class, accessible via
its handle fb.fil_inst
"""
err = ff.fil_factory.create_fil_inst(fc)
logger.debug(f"InputFilter.set_design_method triggered: {fc}\n"
f"Returned error code {err}")
# ==================================================================
# Check whether new design method also provides the old filter order
# method. If yes, don't change it, else set first available
# filter order method
if fb.fil[0]['fo'] not in fb.fil_tree[self.rt][self.ft][fc].keys():
fb.fil[0].update({'fo': {}})
# explicit list(dict.keys()) needed for Python 3
fb.fil[0]['fo'] = list(
fb.fil_tree[self.rt][self.ft][fc].keys())[0]
# =============================================================================
# logger.debug("selFilter = %s"
# "filterTree[fc] = %s"
# "filterTree[fc].keys() = %s"
# %(fb.fil[0], fb.fil_tree[self.rt][self.ft][fc],\
# fb.fil_tree[self.rt][self.ft][fc].keys()
# ))
#
# =============================================================================
# construct dyn. subwidgets if available
if hasattr(ff.fil_inst, 'construct_UI'):
self._construct_dyn_widgets()
self.fc_last = fb.fil[0]['fc']
self.load_filter_order(enb_signal)
# ------------------------------------------------------------------------------
def load_filter_order(self, enb_signal=False):
"""
Called by set_design_method or from InputSpecs (with enb_signal = False),
load filter order setting from fb.fil[0] and update widgets
"""
# collect dict_keys of available filter order [fo] methods for selected
# design method [fc] from fil_tree (explicit list() needed for Python 3)
fo_dict = fb.fil_tree[fb.fil[0]['rt']][fb.fil[0]['ft']][fb.fil[0]
['fc']]
fo_list = list(fo_dict.keys())
# is currently selected fo setting available for (new) fc ?
if fb.fil[0]['fo'] in fo_list:
self.fo = fb.fil[0]['fo'] # keep current setting
else:
self.fo = fo_list[0] # use first list entry from filterTree
fb.fil[0]['fo'] = self.fo # and update fo method
# check whether fo widget is active, disabled or invisible
if 'fo' in fo_dict[self.fo] and len(fo_dict[self.fo]['fo']) > 1:
status = fo_dict[self.fo]['fo'][0]
else:
status = 'i'
# Determine which subwidgets are __visible__
self.chkMinOrder.setVisible('min' in fo_list)
self.ledOrderN.setVisible(status in {'a', 'd'})
self.lblOrderN.setVisible(status in {'a', 'd'})
# Determine which subwidgets are __enabled__
self.chkMinOrder.setChecked(fb.fil[0]['fo'] == 'min')
self.ledOrderN.setText(str(fb.fil[0]['N']))
self.ledOrderN.setEnabled(not self.chkMinOrder.isChecked()
and status == 'a')
self.lblOrderN.setEnabled(not self.chkMinOrder.isChecked()
and status == 'a')
if enb_signal:
logger.debug("Emit 'filt_changed'")
self.emit({'filt_changed': 'filter_type'})
# ------------------------------------------------------------------------------
def _set_filter_order(self, enb_signal=False):
"""
Triggered when either ledOrderN or chkMinOrder are edited:
- copy settings to fb.fil[0]
- emit 'filt_changed' if enb_signal is True
"""
# Determine which subwidgets are _enabled_
if self.chkMinOrder.isVisible():
self.ledOrderN.setEnabled(not self.chkMinOrder.isChecked())
self.lblOrderN.setEnabled(not self.chkMinOrder.isChecked())
if self.chkMinOrder.isChecked() is True:
# update in case N has been changed outside this class
self.ledOrderN.setText(str(fb.fil[0]['N']))
fb.fil[0].update({'fo': 'min'})
else:
fb.fil[0].update({'fo': 'man'})
else:
self.lblOrderN.setEnabled(self.fo == 'man')
self.ledOrderN.setEnabled(self.fo == 'man')
# read manual filter order, convert to positive integer and store it
# in filter dictionary.
ordn = safe_eval(self.ledOrderN.text(),
fb.fil[0]['N'],
return_type='int',
sign='pos')
ordn = ordn if ordn > 0 else 1
self.ledOrderN.setText(str(ordn))
fb.fil[0].update({'N': ordn})
if enb_signal:
logger.debug("Emit 'filt_changed'")
self.emit({'filt_changed': 'filter_order_widget'})
# ------------------------------------------------------------------------------
def _destruct_dyn_widgets(self):
"""
Delete the dynamically created filter design subwidget (if there is one)
see http://stackoverflow.com/questions/13827798/proper-way-to-cleanup-
widgets-in-pyqt
This does NOT work when the subwidgets to be deleted and created are
identical, as the deletion is only performed when the current scope has
been left (?)! Hence, it is necessary to skip this method when the new
design method is the same as the old one.
"""
if hasattr(ff.fil_inst, 'wdg_fil'):
# not needed, connection is destroyed automatically
# ff.fil_inst.sig_tx.disconnect()
try:
# remove widget from layout
self.layHDynWdg.removeWidget(self.dyn_wdg_fil)
# delete UI widget when scope has been left
self.dyn_wdg_fil.deleteLater()
except AttributeError as e:
logger.error("Could not destruct_UI!\n{0}".format(e))
ff.fil_inst.deleteLater(
) # delete QWidget when scope has been left
# ------------------------------------------------------------------------------
def _construct_dyn_widgets(self):
"""
Create filter widget UI dynamically (if the filter routine has one) and
connect its sig_tx signal to sig_tx in this scope.
"""
ff.fil_inst.construct_UI()
if hasattr(ff.fil_inst, 'wdg_fil'):
try:
self.dyn_wdg_fil = getattr(ff.fil_inst, 'wdg_fil')
self.layHDynWdg.addWidget(self.dyn_wdg_fil, stretch=1)
except AttributeError as e:
logger.warning(e)
if hasattr(ff.fil_inst, 'sig_tx'):
ff.fil_inst.sig_tx.connect(self.sig_tx)
class Input_Fixpoint_Specs(QWidget):
"""
Create the widget that holds the dynamically loaded fixpoint filter ui
"""
# emit a signal when the image has been resized
sig_resize = pyqtSignal()
# incoming from subwidgets -> process_sig_rx_local
sig_rx_local = pyqtSignal(object)
# incoming, connected to input_tab_widget.sig_rx
sig_rx = pyqtSignal(object)
# outcgoing
sig_tx = pyqtSignal(object)
def __init__(self, parent):
super(Input_Fixpoint_Specs, self).__init__(parent)
self.tab_label = 'Fixpoint'
self.tool_tip = (
"<span>Select a fixpoint implementation for the filter,"
" simulate it or generate a Verilog netlist.</span>")
self.parent = parent
self.fx_path = os.path.realpath(
os.path.join(dirs.INSTALL_DIR, 'fixpoint_widgets'))
self.no_fx_filter_img = os.path.join(self.fx_path, "no_fx_filter.png")
if not os.path.isfile(self.no_fx_filter_img):
logger.error("Image {0:s} not found!".format(
self.no_fx_filter_img))
self.default_fx_img = os.path.join(self.fx_path, "default_fx_img.png")
if not os.path.isfile(self.default_fx_img):
logger.error("Image {0:s} not found!".format(self.default_fx_img))
if HAS_MIGEN:
self._construct_UI()
else:
self.state = "deactivated" # "invisible", "disabled"
#------------------------------------------------------------------------------
def process_sig_rx(self, dict_sig=None):
"""
Process signals coming in via subwidgets and sig_rx
Play PingPong with a stimulus & plot widget:
2. ``fx_sim_init()``: Request stimulus by sending 'fx_sim':'get_stimulus'
3. ``fx_sim_set_stimulus()``: Receive stimulus from widget in 'fx_sim':'send_stimulus'
and pass it to HDL object for simulation
4. Send back HDL response to widget via 'fx_sim':'set_response'
"""
logger.debug("process_sig_rx(): vis={0}\n{1}"\
.format(self.isVisible(), pprint_log(dict_sig)))
if dict_sig['sender'] == __name__:
logger.debug("Stopped infinite loop\n{0}".format(
pprint_log(dict_sig)))
return
elif 'data_changed' in dict_sig and dict_sig[
'data_changed'] == "filter_designed":
# New filter has been designed, update list of available filter topologies here
self._update_filter_cmb()
return
elif 'data_changed' in dict_sig or\
('view_changed' in dict_sig and dict_sig['view_changed'] == 'q_coeff'):
# update fields in the filter topology widget - wordlength may have
# been changed. Also set RUN button to "changed" in wdg_dict2ui()
self.wdg_dict2ui()
#self.sig_tx.emit({'sender':__name__, 'fx_sim':'specs_changed'})
elif 'fx_sim' in dict_sig:
if dict_sig['fx_sim'] == 'init':
if self.fx_wdg_found:
self.fx_sim_init()
else:
logger.error("No fixpoint widget found!")
qstyle_widget(self.butSimHDL, "error")
self.sig_tx.emit({'sender': __name__, 'fx_sim': 'error'})
elif dict_sig['fx_sim'] == 'send_stimulus':
self.fx_sim_set_stimulus(dict_sig)
elif dict_sig['fx_sim'] == 'specs_changed':
# fixpoint specification have been changed somewhere, update ui
# and set run button to "changed" in wdg_dict2ui()
self.wdg_dict2ui()
elif dict_sig['fx_sim'] == 'finish':
qstyle_widget(self.butSimHDL, "normal")
logger.info('Fixpoint simulation [{0:5.3g} ms]: Plotting finished'\
.format((time.process_time() - self.t_resp)*1000))
else:
logger.error('Unknown "fx_sim" command option "{0}"\n'
'\treceived from "{1}".'.format(
dict_sig['fx_sim'], dict_sig['sender']))
# ---- Process local widget signals
elif 'ui' in dict_sig:
if 'id' in dict_sig and dict_sig['id'] == 'w_input':
"""
Input fixpoint format has been changed or butLock has been clicked.
When I/O lock is active, copy input fixpoint word format to output
word format.
"""
if dict_sig[
'ui'] == 'butLock' and not self.wdg_w_input.butLock.isChecked(
):
# butLock was deactivitated, don't do anything
return
elif self.wdg_w_input.butLock.isChecked():
# but lock was activated or wordlength setting have been changed
fb.fil[0]['fxqc']['QO']['WI'] = fb.fil[0]['fxqc']['QI'][
'WI']
fb.fil[0]['fxqc']['QO']['WF'] = fb.fil[0]['fxqc']['QI'][
'WF']
fb.fil[0]['fxqc']['QO']['W'] = fb.fil[0]['fxqc']['QI']['W']
elif 'id' in dict_sig and dict_sig['id'] == 'w_output':
"""
Output fixpoint format has been changed. When I/O lock is active, copy
output fixpoint word format to input word format.
"""
if self.wdg_w_input.butLock.isChecked():
fb.fil[0]['fxqc']['QI']['WI'] = fb.fil[0]['fxqc']['QO'][
'WI']
fb.fil[0]['fxqc']['QI']['WF'] = fb.fil[0]['fxqc']['QO'][
'WF']
fb.fil[0]['fxqc']['QI']['W'] = fb.fil[0]['fxqc']['QO']['W']
elif 'id' in dict_sig and dict_sig['id'] in \
{'w_coeff', 'q_input', 'q_output', 'w_accu', 'q_accu'}:
pass # nothing to do for now
else:
if not "id" in dict_sig:
logger.warning("No id in dict_sig:\n{0}".format(
pprint_log(dict_sig)))
else:
logger.warning('Unknown id "{0}" in dict_sig:\n{1}'\
.format(dict_sig['id'], pprint_log(dict_sig)))
if not dict_sig['ui'] in {
'WI', 'WF', 'ovfl', 'quant', 'cmbW', 'butLock'
}:
logger.warning("Unknown value '{0}' for key 'ui'".format(
dict_sig['ui']))
self.wdg_dict2ui(
) # update wordlengths in UI and set RUN button to 'changed'
self.sig_tx.emit({'sender': __name__, 'fx_sim': 'specs_changed'})
return
#------------------------------------------------------------------------------
def _construct_UI(self):
"""
Intitialize the main GUI, consisting of:
- A combo box to select the filter topology and an image of the topology
- The input quantizer
- The UI of the fixpoint filter widget
- Simulation and export buttons
"""
#------------------------------------------------------------------------------
# Define frame and layout for the dynamically updated filter widget
# The actual filter widget is instantiated in self.set_fixp_widget() later on
self.layH_fx_wdg = QHBoxLayout()
#self.layH_fx_wdg.setContentsMargins(*params['wdg_margins'])
frmHDL_wdg = QFrame(self)
frmHDL_wdg.setLayout(self.layH_fx_wdg)
#frmHDL_wdg.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
#------------------------------------------------------------------------------
# Initialize fixpoint filter combobox, title and description
#------------------------------------------------------------------------------
self.cmb_wdg_fixp = QComboBox(self)
self.cmb_wdg_fixp.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.lblTitle = QLabel("not set", self)
self.lblTitle.setWordWrap(True)
self.lblTitle.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
layHTitle = QHBoxLayout()
layHTitle.addWidget(self.cmb_wdg_fixp)
layHTitle.addWidget(self.lblTitle)
self.frmTitle = QFrame(self)
self.frmTitle.setLayout(layHTitle)
self.frmTitle.setContentsMargins(*params['wdg_margins'])
#------------------------------------------------------------------------------
# Input and Output Quantizer
#------------------------------------------------------------------------------
# - instantiate widgets for input and output quantizer
# - pass the quantization (sub-?) dictionary to the constructor
#------------------------------------------------------------------------------
self.wdg_w_input = UI_W(self,
q_dict=fb.fil[0]['fxqc']['QI'],
id='w_input',
label='',
lock_visible=True)
self.wdg_w_input.sig_tx.connect(self.process_sig_rx)
cmb_q = ['round', 'floor', 'fix']
self.wdg_w_output = UI_W(self,
q_dict=fb.fil[0]['fxqc']['QO'],
id='w_output',
label='')
self.wdg_w_output.sig_tx.connect(self.process_sig_rx)
self.wdg_q_output = UI_Q(
self,
q_dict=fb.fil[0]['fxqc']['QO'],
id='q_output',
label='Output Format <i>Q<sub>Y </sub></i>:',
cmb_q=cmb_q,
cmb_ov=['wrap', 'sat'])
self.wdg_q_output.sig_tx.connect(self.sig_rx)
if HAS_DS:
cmb_q.append('dsm')
self.wdg_q_input = UI_Q(
self,
q_dict=fb.fil[0]['fxqc']['QI'],
id='q_input',
label='Input Format <i>Q<sub>X </sub></i>:',
cmb_q=cmb_q)
self.wdg_q_input.sig_tx.connect(self.sig_rx)
# Layout and frame for input quantization
layVQiWdg = QVBoxLayout()
layVQiWdg.addWidget(self.wdg_q_input)
layVQiWdg.addWidget(self.wdg_w_input)
frmQiWdg = QFrame(self)
#frmBtns.setFrameStyle(QFrame.StyledPanel|QFrame.Sunken)
frmQiWdg.setLayout(layVQiWdg)
frmQiWdg.setContentsMargins(*params['wdg_margins'])
# Layout and frame for output quantization
layVQoWdg = QVBoxLayout()
layVQoWdg.addWidget(self.wdg_q_output)
layVQoWdg.addWidget(self.wdg_w_output)
frmQoWdg = QFrame(self)
#frmBtns.setFrameStyle(QFrame.StyledPanel|QFrame.Sunken)
frmQoWdg.setLayout(layVQoWdg)
frmQoWdg.setContentsMargins(*params['wdg_margins'])
#------------------------------------------------------------------------------
# Dynamically updated image of filter topology
#------------------------------------------------------------------------------
# label is a placeholder for image
self.lbl_fixp_img = QLabel("img not set", self)
#self.lbl_fixp_img.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.embed_fixp_img(self.no_fx_filter_img)
layHImg = QHBoxLayout()
layHImg.setContentsMargins(0, 0, 0, 0)
layHImg.addWidget(self.lbl_fixp_img) #, Qt.AlignCenter)
self.frmImg = QFrame(self)
self.frmImg.setLayout(layHImg)
self.frmImg.setContentsMargins(*params['wdg_margins'])
self.resize_img()
#------------------------------------------------------------------------------
# Simulation and export Buttons
#------------------------------------------------------------------------------
self.butExportHDL = QPushButton(self)
self.butExportHDL.setToolTip(
"Export fixpoint filter in Verilog format.")
self.butExportHDL.setText("Create HDL")
self.butSimHDL = QPushButton(self)
self.butSimHDL.setToolTip("Start migen fixpoint simulation.")
self.butSimHDL.setText("Sim. HDL")
self.butSimFxPy = QPushButton(self)
self.butSimFxPy.setToolTip("Simulate filter with fixpoint effects.")
self.butSimFxPy.setText("Sim. FixPy")
self.layHHdlBtns = QHBoxLayout()
self.layHHdlBtns.addWidget(self.butSimFxPy)
self.layHHdlBtns.addWidget(self.butSimHDL)
self.layHHdlBtns.addWidget(self.butExportHDL)
# This frame encompasses the HDL buttons sim and convert
frmHdlBtns = QFrame(self)
#frmBtns.setFrameStyle(QFrame.StyledPanel|QFrame.Sunken)
frmHdlBtns.setLayout(self.layHHdlBtns)
frmHdlBtns.setContentsMargins(*params['wdg_margins'])
# -------------------------------------------------------------------
# Top level layout
# -------------------------------------------------------------------
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
splitter.addWidget(frmHDL_wdg)
splitter.addWidget(frmQoWdg)
splitter.addWidget(self.frmImg)
# 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, 3000, 5000])
layVMain = QVBoxLayout()
layVMain.addWidget(self.frmTitle)
layVMain.addWidget(frmHdlBtns)
layVMain.addWidget(frmQiWdg)
layVMain.addWidget(splitter)
layVMain.addStretch()
layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(layVMain)
#----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs & EVENTFILTERS
#----------------------------------------------------------------------
# monitor events and generate sig_resize event when resized
self.lbl_fixp_img.installEventFilter(self)
# ... then redraw image when resized
self.sig_resize.connect(self.resize_img)
self.cmb_wdg_fixp.currentIndexChanged.connect(self._update_fixp_widget)
self.butExportHDL.clicked.connect(self.exportHDL)
self.butSimHDL.clicked.connect(self.fx_sim_init)
#----------------------------------------------------------------------
inst_wdg_list = self._update_filter_cmb()
if len(inst_wdg_list) == 0:
logger.warning("No fixpoint filters found!")
else:
logger.debug("Imported {0:d} fixpoint filters:\n{1}".format(
len(inst_wdg_list.split("\n")) - 1, inst_wdg_list))
self._update_fixp_widget()
#------------------------------------------------------------------------------
def _update_filter_cmb(self):
"""
(Re-)Read list of available fixpoint filters for a given filter design
every time a new filter design is selected.
Then try to import the fixpoint designs in the list and populate the
fixpoint implementation combo box `self.cmb_wdg_fixp` when successfull.
"""
inst_wdg_str = "" # full names of successfully instantiated widgets for logging
last_fx_wdg = qget_cmb_box(
self.cmb_wdg_fixp, data=False) # remember last fx widget setting
self.cmb_wdg_fixp.clear()
fc = fb.fil[0]['fc']
if 'fix' in fb.filter_classes[fc]:
for class_name in fb.filter_classes[fc]['fix']: # get class name
try:
# construct module + class name
mod_class_name = fb.fixpoint_classes[class_name][
'mod'] + '.' + class_name
disp_name = fb.fixpoint_classes[class_name][
'name'] # # and display name
self.cmb_wdg_fixp.addItem(disp_name, mod_class_name)
inst_wdg_str += '\t' + class_name + ' : ' + mod_class_name + '\n'
except AttributeError as e:
logger.warning('Widget "{0}":\n{1}'.format(class_name, e))
self.embed_fixp_img(self.no_fx_filter_img)
continue
except KeyError as e:
logger.warning(
"No fixpoint filter for filter type {0} available.".
format(e))
self.embed_fixp_img(self.no_fx_filter_img)
continue
# restore last fxp widget if possible
idx = self.cmb_wdg_fixp.findText(last_fx_wdg)
# set to idx 0 if not found (returned -1)
self.cmb_wdg_fixp.setCurrentIndex(max(idx, 0))
else: # no fixpoint widget
self.embed_fixp_img(self.no_fx_filter_img)
return inst_wdg_str
#------------------------------------------------------------------------------
def eventFilter(self, source, event):
"""
Filter all events generated by monitored QLabel, only resize events are
processed here, generating a `sig_resize` signal. All other events
are passed on to the next hierarchy level.
"""
if event.type() == QEvent.Resize:
self.sig_resize.emit()
# Call base class method to continue normal event processing:
return super(Input_Fixpoint_Specs, self).eventFilter(source, event)
#------------------------------------------------------------------------------
def embed_fixp_img(self, img_file):
"""
Embed image as self.img_fixp, either in png or svg format
Parameters:
img_file: str
path and file name to image file
"""
if not os.path.isfile(img_file):
logger.warning("Image file {0} doesn't exist.".format(img_file))
img_file = self.default_fx_img
# _, file_extension = os.path.splitext(self.fx_wdg_inst.img_name)
_, file_extension = os.path.splitext(img_file)
if file_extension == '.png':
self.img_fixp = QPixmap(img_file)
#self.lbl_fixp_img.setPixmap(QPixmap(self.img_fixp)) # fixed size
# elif file_extension == '.svg':
# self.img_fixp = QtSvg.QSvgWidget(img_file)
else:
logger.error(
'Unknown file extension "{0}"!'.format(file_extension))
self.resize_img()
#------------------------------------------------------------------------------
def resize_img(self):
"""
Triggered when self (the widget) is resized, consequently the image
inside QLabel is resized to completely fill the label while keeping
the aspect ratio.
This doesn't really work at the moment.
"""
if hasattr(self.parent, "width"): # needed for module test
par_w, par_h = self.parent.width(), self.parent.height()
else:
par_w, par_h = 300, 700 # fixed size for module testself.lbl_img_fixp
lbl_w, lbl_h = self.lbl_fixp_img.width(), self.lbl_fixp_img.height()
img_w, img_h = self.img_fixp.width(), self.img_fixp.height()
if img_w > 10:
max_h = int(max(np.floor(img_h * par_w / img_w) - 15, 20))
else:
max_h = 200
logger.debug("img size: {0},{1}, frm size: {2},{3}, max_h: {4}".format(
img_w, img_h, par_w, par_h, max_h))
# The following doesn't work because the width of the parent widget can grow
# with the image size
# img_scaled = self.img_fixp.scaled(self.lbl_fixp_img.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
img_scaled = self.img_fixp.scaledToHeight(max_h,
Qt.SmoothTransformation)
#img_scaled = self.img_fixp.scaledToHeight(max_h)
self.lbl_fixp_img.setPixmap(img_scaled)
#------------------------------------------------------------------------------
def _update_fixp_widget(self):
"""
This method is called at the initialization of the widget and when
a new fixpoint filter implementation is selected from the combo box:
- Destruct old instance of fixpoint filter widget `self.fx_wdg_inst`
- Import and instantiate new fixpoint filter widget e.g. after changing the
filter topology as
- Try to load image for filter topology
- Update the UI of the widget
- Try to instantiate HDL filter as `self.fx_wdg_inst.fixp_filter` with
dummy data
"""
def _disable_fx_wdg(self):
if hasattr(
self, "fx_wdg_inst"
) and self.fx_wdg_inst is not None: # is a fixpoint widget loaded?
try:
self.layH_fx_wdg.removeWidget(
self.fx_wdg_inst) # remove widget from layout
self.fx_wdg_inst.deleteLater(
) # delete QWidget when scope has been left
except AttributeError as e:
logger.error("Destructing UI failed!\n{0}".format(e))
self.fx_wdg_found = False
self.butSimFxPy.setVisible(False)
self.butSimHDL.setEnabled(False)
self.butExportHDL.setEnabled(False)
#self.layH_fx_wdg.setVisible(False)
self.img_fixp = self.embed_fixp_img(self.no_fx_filter_img)
self.lblTitle.setText("")
self.fx_wdg_inst = None
# destruct old fixpoint widget instance
_disable_fx_wdg(self)
# instantiate new fixpoint widget class as self.fx_wdg_inst
cmb_wdg_fx_cur = qget_cmb_box(self.cmb_wdg_fixp, data=False)
if cmb_wdg_fx_cur: # at least one valid fixpoint widget found
self.fx_wdg_found = True
# get list [module name and path, class name]
fx_mod_class_name = qget_cmb_box(self.cmb_wdg_fixp,
data=True).rsplit('.', 1)
fx_mod = importlib.import_module(
fx_mod_class_name[0]) # get module
fx_wdg_class = getattr(fx_mod, fx_mod_class_name[1]) # get class
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
self.fx_wdg_inst = fx_wdg_class(
self) # instantiate the fixpoint widget
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
self.layH_fx_wdg.addWidget(self.fx_wdg_inst,
stretch=1) # and add it to layout
self.fx_wdg_inst.setVisible(True)
# Doesn't work at the moment, combo box becomes inaccessible
# try:
# self.fx_wdg_inst = fx_wdg_class(self) # instantiate the widget
# self.layH_fx_wdg.addWidget(self.fx_wdg_inst, stretch=1) # and add it to layout
# except KeyError as e:
# logger.warning('Key Error {0} in fixpoint filter \n{1}'\
# .format(e, fx_mod_name + "." + cmb_wdg_fx_cur))
# _disable_fx_wdg(self)
# return
self.wdg_dict2ui(
) # initialize the fixpoint subwidgets from the fxqc_dict
#---- connect signals to fx_wdg_inst ----
if hasattr(self.fx_wdg_inst, "sig_rx"):
self.sig_rx.connect(self.fx_wdg_inst.sig_rx)
if hasattr(self.fx_wdg_inst, "sig_tx"):
self.fx_wdg_inst.sig_tx.connect(self.sig_rx)
#---- get name of new fixpoint filter image ----
if not (hasattr(self.fx_wdg_inst, "img_name") and
self.fx_wdg_inst.img_name): # is an image name defined?
img_file = self.default_fx_img
else:
file_path = os.path.dirname(
fx_mod.__file__
) # get path of imported fixpoint widget and
img_file = os.path.join(file_path, self.fx_wdg_inst.img_name
) # construct full image name from it
#---- instantiate and scale graphic of filter topology ----
self.embed_fixp_img(img_file)
#---- set title and description for filter
self.lblTitle.setText(self.fx_wdg_inst.title)
#--- try to reference Python fixpoint filter instance -----
# if hasattr(self.fx_wdg_inst,'fxpy_filter'):
# self.fxpy_filter_inst = self.fx_wdg_inst.fxpy_filter
# self.butSimFxPy.setEnabled(True)
# else:
# self.butSimFxPy.setVisible(False)
#--- Check whether fixpoint widget contains HDL filters -----
if hasattr(self.fx_wdg_inst, 'fixp_filter'):
self.butExportHDL.setEnabled(
hasattr(self.fx_wdg_inst, "to_verilog"))
self.butSimHDL.setEnabled(hasattr(self.fx_wdg_inst, "run_sim"))
self.update_fxqc_dict()
self.sig_tx.emit({
'sender': __name__,
'fx_sim': 'specs_changed'
})
else:
self.butSimHDL.setEnabled(False)
self.butExportHDL.setEnabled(False)
else:
_disable_fx_wdg(self)
#------------------------------------------------------------------------------
def wdg_dict2ui(self):
"""
Trigger an update of the fixpoint widget UI when view (i.e. fixpoint
coefficient format) or data have been changed outside this class. Additionally,
pass the fixpoint quantization widget to update / restore other subwidget
settings.
Set the RUN button to "changed".
"""
# fb.fil[0]['fxqc']['QCB'].update({'scale':(1 << fb.fil[0]['fxqc']['QCB']['W'])})
self.wdg_q_input.dict2ui(fb.fil[0]['fxqc']['QI'])
self.wdg_q_output.dict2ui(fb.fil[0]['fxqc']['QO'])
self.wdg_w_input.dict2ui(fb.fil[0]['fxqc']['QI'])
self.wdg_w_output.dict2ui(fb.fil[0]['fxqc']['QO'])
if self.fx_wdg_found and hasattr(self.fx_wdg_inst, "dict2ui"):
self.fx_wdg_inst.dict2ui()
# dict_sig = {'sender':__name__, 'fx_sim':'specs_changed'}
# self.sig_tx.emit(dict_sig)
qstyle_widget(self.butSimHDL, "changed")
#------------------------------------------------------------------------------
def update_fxqc_dict(self):
"""
Update the fxqc dictionary before simulation / HDL generation starts.
"""
if self.fx_wdg_found:
# get a dict with the coefficients and fixpoint settings from fixpoint widget
if hasattr(self.fx_wdg_inst, "ui2dict"):
fb.fil[0]['fxqc'].update(self.fx_wdg_inst.ui2dict())
logger.debug("update fxqc: \n{0}".format(
pprint_log(fb.fil[0]['fxqc'])))
else:
logger.error("No fixpoint widget found!")
#------------------------------------------------------------------------------
def exportHDL(self):
"""
Synthesize HDL description of filter
"""
if not hasattr(self.fx_wdg_inst, 'construct_fixp_filter'):
logger.warning(
'Fixpoint widget has no method "construct_fixp_filter", aborting.'
)
return
dlg = QFD(self) # instantiate file dialog object
file_types = "Verilog (*.v)"
dlg.setDefaultSuffix(
'v'
) # needed for overwrite confirmation when name is entered without suffix
dlg.setWindowTitle('Export Vlog')
dlg.setNameFilter(file_types)
dlg.setDirectory(dirs.save_dir)
dlg.setAcceptMode(
QFD.AcceptSave) # set mode "save file" instead "open file"
dlg.setOption(QFD.DontConfirmOverwrite, False)
if dlg.exec_() == QFD.Accepted:
hdl_file = qstr(dlg.selectedFiles()[0])
# hdl_type = extract_file_ext(qstr(dlg.selectedNameFilter()))[0]
# =============================================================================
# # static method getSaveFileName_() is simple but unflexible
# hdl_file, hdl_filter = dlg.getSaveFileName_(
# caption="Save Verilog netlist as (this also defines the module name)",
# directory=dirs.save_dir, filter=file_types)
# hdl_file = qstr(hdl_file)
# if hdl_file != "": # "operation cancelled" returns an empty string
# # return '.v' or '.vhd' depending on filetype selection:
# # hdl_type = extract_file_ext(qstr(hdl_filter))[0]
# # sanitized dir + filename + suffix. The filename suffix is replaced
# # by `v` later.
# hdl_file = os.path.normpath(hdl_file) # complete path + file name
# =============================================================================
hdl_dir_name = os.path.dirname(
hdl_file) # extract the directory path
if not os.path.isdir(
hdl_dir_name): # create directory if it doesn't exist
os.mkdir(hdl_dir_name)
dirs.save_dir = hdl_dir_name # make this directory the new default / base dir
hdl_file_name = os.path.splitext(os.path.basename(hdl_file))[0]
hdl_full_name = os.path.join(hdl_dir_name, hdl_file_name + ".v")
vlog_mod_name = re.sub(
r'\W+', '',
hdl_file_name).lower() # remove all non-alphanumeric chars
logger.info(
'Creating hdl_file "{0}"\n\twith top level module "{1}"'.
format(hdl_full_name, vlog_mod_name))
try:
self.update_fxqc_dict()
self.fx_wdg_inst.construct_fixp_filter()
code = self.fx_wdg_inst.to_verilog(name=vlog_mod_name)
#logger.info(str(code)) # print verilog code to console
with io.open(hdl_full_name, 'w', encoding="utf8") as f:
f.write(str(code))
logger.info("HDL conversion finished!")
except (IOError, TypeError) as e:
logger.warning(e)
##------------------------------------------------------------------------------
# def fx_sim_py(self):
# """
# Start fix-point simulation: Send the ``fxqc_dict``
# containing all quantization information and request a stimulus signal
# Not implemented yet
# """
# try:
# logger.info("Started python fixpoint simulation")
# self.update_fxqc_dict()
# self.fxpyfilter.setup(fb.fil[0]['fxqc']) # setup filter instance
# dict_sig = {'sender':__name__, 'fx_sim':'get_stimulus'}
# self.sig_tx.emit(dict_sig)
#
# except AttributeError as e:
# logger.warning("Fixpoint stimulus generation failed:\n{0}".format(e))
# return
#------------------------------------------------------------------------------
def fx_sim_init(self):
"""
Initialize fix-point simulation:
- Update the `fxqc_dict` containing all quantization information
- Setup a filter instance for migen simulation
- Request a stimulus signal
"""
if not hasattr(self.fx_wdg_inst, 'construct_fixp_filter'):
logger.error(
'Fixpoint widget has no method "construct_fixp_filter", aborting.'
)
self.sig_tx.emit({'sender': __name__, 'fx_sim': 'error'})
return
try:
logger.info("Fixpoint simulation started")
self.t_start = time.process_time()
self.update_fxqc_dict()
self.fx_wdg_inst.construct_fixp_filter() # setup filter instance
dict_sig = {'sender': __name__, 'fx_sim': 'get_stimulus'}
self.sig_tx.emit(dict_sig)
except ValueError as e: # exception
logger.error(
'Fixpoint stimulus generation failed during "init" for dict\n{0}'
'\nwith "{1} "'.format(pprint_log(dict_sig), e))
return
#------------------------------------------------------------------------------
def fx_sim_set_stimulus(self, dict_sig):
"""
- Get fixpoint stimulus from `dict_sig` in integer format
- Pass it to the fixpoint filter and calculate the fixpoint response
- Send the reponse to the plotting widget
"""
try:
logger.debug(
'Starting fixpoint simulation with stimulus from "{0}":\n\tfx_stimulus:{1}'
'\n\tStimuli: Shape {2} of type "{3}"'.format(
dict_sig['sender'],
pprint_log(dict_sig['fx_stimulus'], tab=" "),
np.shape(dict_sig['fx_stimulus']),
dict_sig['fx_stimulus'].dtype,
))
self.t_stim = time.process_time()
logger.info("Fixpoint simulation [{0:5.3g} ms]: Stimuli generated"\
.format((self.t_stim-self.t_start)*1000))
# Run fixpoint simulation and return the results as integer values:
self.fx_results = self.fx_wdg_inst.run_sim(
dict_sig['fx_stimulus']) # Run the simulation
self.t_resp = time.process_time()
if len(self.fx_results) == 0:
logger.warning("Fixpoint simulation returned empty results!")
else:
#logger.debug("fx_results: {0}"\
# .format(pprint_log(self.fx_results, tab= " ")))
logger.debug('Fixpoint simulation successful for dict\n{0}'
'\tStimuli: Shape {1} of type "{2}"'
'\n\tResponse: Shape {3} of type "{4}"'\
.format(pprint_log(dict_sig),
np.shape(dict_sig['fx_stimulus']),
dict_sig['fx_stimulus'].dtype,
np.shape(self.fx_results),
type(self.fx_results)
))
logger.info('Fixpoint simulation [{0:5.3g} ms]: Response calculated'\
.format((self.t_resp - self.t_stim)*1000))
#TODO: fixed point / integer to float conversion?
#TODO: color push-button to show state of simulation
#TODO: add QTimer single shot
# self.timer_id = QtCore.QTimer()
# self.timer_id.setSingleShot(True)
# # kill simulation after some idle time, also add a button for this
# self.timer_id.timeout.connect(self.kill_sim)
except ValueError as e:
logger.error("Simulator error {0}".format(e))
self.fx_results = None
qstyle_widget(self.butSimHDL, "error")
self.sig_tx.emit({'sender': __name__, 'fx_sim': 'error'})
return
except AssertionError as e:
logger.error('Fixpoint simulation failed for dict\n{0}'
'\twith msg. "{1}"\n\tStimuli: Shape {2} of type "{3}"'
'\n\tResponse: Shape {4} of type "{5}"'\
.format(pprint_log(dict_sig), e,
np.shape(dict_sig['fx_stimulus']),
dict_sig['fx_stimulus'].dtype,
np.shape(self.fx_results),
type(self.fx_results)
))
self.fx_results = None
qstyle_widget(self.butSimHDL, "error")
self.sig_tx.emit({'sender': __name__, 'fx_sim': 'error'})
return
logger.debug("Sending fixpoint results")
dict_sig = {
'sender': __name__,
'fx_sim': 'set_results',
'fx_results': self.fx_results
}
self.sig_tx.emit(dict_sig)
qstyle_widget(self.butSimHDL, "normal")
return