class PlotImpz_UI(QWidget):
"""
Create the UI for the PlotImpz class
"""
# incoming: not implemented at the moment, update_N is triggered directly
# by plot_impz
# sig_rx = pyqtSignal(object)
# outgoing: from various UI elements to PlotImpz ('ui_changed':'xxx')
sig_tx = pyqtSignal(object)
# outgoing: to fft related widgets (FFT window widget, qfft_win_select)
sig_tx_fft = pyqtSignal(object)
from pyfda.libs.pyfda_qt_lib import emit
# ------------------------------------------------------------------------------
def process_sig_rx(self, dict_sig=None):
"""
Process signals coming from
- FFT window widget
- qfft_win_select
"""
# logger.debug("PROCESS_SIG_RX - vis: {0}\n{1}"
# .format(self.isVisible(), pprint_log(dict_sig)))
if 'id' in dict_sig and dict_sig['id'] == id(self):
logger.warning("Stopped infinite loop:\n{0}".format(
pprint_log(dict_sig)))
return
# --- signals coming from the FFT window widget or the FFT window selector
if dict_sig['class'] in {'Plot_FFT_win', 'QFFTWinSelector'}:
if 'closeEvent' in dict_sig: # hide FFT window widget and return
self.hide_fft_wdg()
return
else:
# check for value 'fft_win*':
if 'view_changed' in dict_sig and 'fft_win' in dict_sig[
'view_changed']:
# local connection to FFT window widget and qfft_win_select
self.emit(dict_sig, sig_name='sig_tx_fft')
# global connection to e.g. plot_impz
self.emit(dict_sig)
# ------------------------------------------------------------------------------
def __init__(self):
super().__init__()
"""
Intitialize the widget, consisting of:
- top chkbox row
- coefficient table
- two bottom rows with action buttons
"""
# initial settings
self.N_start = 0
self.N_user = 0
self.N = 0
self.N_frame_user = 0
self.N_frame = 0
# time
self.plt_time_resp = "stem"
self.plt_time_stim = "line"
self.plt_time_stmq = "none"
self.plt_time_spgr = "none"
self.bottom_t = -80 # initial value for log. scale (time)
self.time_nfft_spgr = 256 # number of fft points per spectrogram segment
self.time_ovlp_spgr = 128 # number of overlap points between spectrogram segments
self.mode_spgr_time = "psd"
# frequency
self.cmb_freq_display_item = "mag"
self.plt_freq_resp = "line"
self.plt_freq_stim = "none"
self.plt_freq_stmq = "none"
self.bottom_f = -120 # initial value for log. scale
self.param = None
self.f_scale = fb.fil[0]['f_S']
self.t_scale = fb.fil[0]['T_S']
# list of windows that are available for FFT analysis
win_names_list = [
"Boxcar", "Rectangular", "Barthann", "Bartlett", "Blackman",
"Blackmanharris", "Bohman", "Cosine", "Dolph-Chebyshev", "Flattop",
"General Gaussian", "Gauss", "Hamming", "Hann", "Kaiser",
"Nuttall", "Parzen", "Slepian", "Triangular", "Tukey"
]
self.cur_win_name = "Rectangular" # set initial window type
# initialize windows dict with the list above
self.win_dict = get_windows_dict(win_names_list=win_names_list,
cur_win_name=self.cur_win_name)
# instantiate FFT window with default windows dict
self.fft_widget = Plot_FFT_win(self,
self.win_dict,
sym=False,
title="pyFDA Spectral Window Viewer")
# hide window initially, this is modeless i.e. a non-blocking popup window
self.fft_widget.hide()
# data / icon / tooltipp (none) for plotting styles
self.plot_styles_list = [
("Plot style"), ("none", QIcon(":/plot_style-none"), "off"),
("dots*", QIcon(":/plot_style-mkr"), "markers only"),
("line", QIcon(":/plot_style-line"), "line"),
("line*", QIcon(":/plot_style-line-mkr"), "line + markers"),
("stem", QIcon(":/plot_style-stem"), "stems"),
("stem*", QIcon(":/plot_style-stem-mkr"), "stems + markers"),
("steps", QIcon(":/plot_style-steps"), "steps"),
("steps*", QIcon(":/plot_style-steps-mkr"), "steps + markers")
]
self.cmb_time_spgr_items = [
"<span>Show Spectrogram for selected signal.</span>",
("none", "None", ""), ("xn", "x[n]", "input"),
("xqn", "x_q[n]", "quantized input"), ("yn", "y[n]", "output")
]
self.cmb_mode_spgr_time_items = [
"<span>Spectrogram display mode.</span>",
("psd", "PSD",
"<span>Power Spectral Density, either per bin or referred to "
"<i>f<sub>S</sub></i></span>"),
("magnitude", "Mag.", "Signal magnitude"),
("angle", "Angle", "Phase, wrapped to ± π"),
("phase", "Phase", "Phase (unwrapped)")
]
# self.N
self.cmb_freq_display_items = [
"<span>Select how to display the spectrum.</span>",
("mag", "Magnitude", "<span>Spectral magnitude</span>"),
("mag_phi", "Mag. / Phase", "<span>Magnitude and phase.</span>"),
("re_im", "Re. / Imag.",
"<span>Real and imaginary part of spectrum.</span>")
]
self._construct_UI()
# self._enable_stim_widgets()
self.update_N(emit=False) # also updates window function and win_dict
# self._update_noi()
def _construct_UI(self):
# ----------- ---------------------------------------------------
# Run control widgets
# ---------------------------------------------------------------
# self.but_auto_run = QPushButtonRT(text=to_html("Auto", frmt="b"), margin=0)
self.but_auto_run = QPushButton(" Auto", self)
self.but_auto_run.setObjectName("but_auto_run")
self.but_auto_run.setToolTip(
"<span>Update response automatically when "
"parameters have been changed.</span>")
# self.but_auto_run.setMaximumWidth(qtext_width(text=" Auto "))
self.but_auto_run.setCheckable(True)
self.but_auto_run.setChecked(True)
but_height = self.but_auto_run.sizeHint().height()
self.but_run = QPushButton(self)
self.but_run.setIcon(QIcon(":/play.svg"))
self.but_run.setIconSize(QSize(but_height, but_height))
self.but_run.setFixedSize(QSize(2 * but_height, but_height))
self.but_run.setToolTip("Run simulation")
self.but_run.setEnabled(True)
self.cmb_sim_select = QComboBox(self)
self.cmb_sim_select.addItems(["Float", "Fixpoint"])
qset_cmb_box(self.cmb_sim_select, "Float")
self.cmb_sim_select.setToolTip("<span>Simulate floating-point or "
"fixpoint response.</span>")
self.lbl_N_points = QLabel(to_html("N", frmt='bi') + " =", self)
self.led_N_points = QLineEdit(self)
self.led_N_points.setText(str(self.N))
self.led_N_points.setToolTip(
"<span>Last data point. "
"<i>N</i> = 0 tries to choose for you.</span>")
self.led_N_points.setMaximumWidth(qtext_width(N_x=8))
self.lbl_N_start = QLabel(to_html("N_0", frmt='bi') + " =", self)
self.led_N_start = QLineEdit(self)
self.led_N_start.setText(str(self.N_start))
self.led_N_start.setToolTip("<span>First point to plot.</span>")
self.led_N_start.setMaximumWidth(qtext_width(N_x=8))
self.lbl_N_frame = QLabel(to_html("ΔN", frmt='bi') + " =", self)
self.led_N_frame = QLineEdit(self)
self.led_N_frame.setText(str(self.N_frame))
self.led_N_frame.setToolTip(
"<span>Frame length; longer frames calculate faster but calculation cannot "
"be stopped so quickly. "
"<i>ΔN</i> = 0 calculates all samples in one frame.</span>")
self.led_N_frame.setMaximumWidth(qtext_width(N_x=8))
self.prg_wdg = QProgressBar(self)
self.prg_wdg.setFixedHeight(but_height)
self.prg_wdg.setFixedWidth(qtext_width(N_x=6))
self.prg_wdg.setMinimum(0)
self.prg_wdg.setValue(0)
self.but_toggle_stim_options = PushButton(" Stimuli ", checked=True)
self.but_toggle_stim_options.setObjectName("but_stim_options")
self.but_toggle_stim_options.setToolTip(
"<span>Show / hide stimulus options.</span>")
self.lbl_stim_cmplx_warn = QLabel(self)
self.lbl_stim_cmplx_warn = QLabel(to_html("Cmplx!", frmt='b'), self)
self.lbl_stim_cmplx_warn.setToolTip(
'<span>Signal is complex valued; '
'single-sided and H<sub>id</sub> spectra may be wrong.</span>')
self.lbl_stim_cmplx_warn.setStyleSheet("background-color : yellow;"
"border : 1px solid grey")
self.but_fft_wdg = QPushButton(self)
self.but_fft_wdg.setIcon(QIcon(":/fft.svg"))
self.but_fft_wdg.setIconSize(QSize(but_height, but_height))
self.but_fft_wdg.setFixedSize(QSize(int(1.5 * but_height), but_height))
self.but_fft_wdg.setToolTip(
'<span>Show / hide FFT widget (select window type '
' and display its properties).</span>')
self.but_fft_wdg.setCheckable(True)
self.but_fft_wdg.setChecked(False)
self.qfft_win_select = QFFTWinSelector(self, self.win_dict)
self.but_fx_scale = PushButton(" FX:Int ")
self.but_fx_scale.setObjectName("but_fx_scale")
self.but_fx_scale.setToolTip(
"<span>Display data with integer (fixpoint) scale.</span>")
self.but_fx_range = PushButton(" FX:Range")
self.but_fx_range.setObjectName("but_fx_limits")
self.but_fx_range.setToolTip(
"<span>Display limits of fixpoint range.</span>")
layH_ctrl_run = QHBoxLayout()
layH_ctrl_run.addWidget(self.but_auto_run)
layH_ctrl_run.addWidget(self.but_run)
layH_ctrl_run.addWidget(self.cmb_sim_select)
layH_ctrl_run.addSpacing(10)
layH_ctrl_run.addWidget(self.lbl_N_start)
layH_ctrl_run.addWidget(self.led_N_start)
layH_ctrl_run.addWidget(self.lbl_N_points)
layH_ctrl_run.addWidget(self.led_N_points)
layH_ctrl_run.addWidget(self.lbl_N_frame)
layH_ctrl_run.addWidget(self.led_N_frame)
layH_ctrl_run.addWidget(self.prg_wdg)
layH_ctrl_run.addSpacing(20)
layH_ctrl_run.addWidget(self.but_toggle_stim_options)
layH_ctrl_run.addSpacing(5)
layH_ctrl_run.addWidget(self.lbl_stim_cmplx_warn)
layH_ctrl_run.addSpacing(20)
layH_ctrl_run.addWidget(self.but_fft_wdg)
layH_ctrl_run.addWidget(self.qfft_win_select)
layH_ctrl_run.addSpacing(20)
layH_ctrl_run.addWidget(self.but_fx_scale)
layH_ctrl_run.addWidget(self.but_fx_range)
layH_ctrl_run.addStretch(10)
# layH_ctrl_run.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_run = QWidget(self)
self.wdg_ctrl_run.setLayout(layH_ctrl_run)
# --- end of run control ----------------------------------------
# ----------- ---------------------------------------------------
# Controls for time domain
# ---------------------------------------------------------------
self.lbl_plt_time_stim = QLabel(to_html("Stim. x", frmt='bi'), self)
self.cmb_plt_time_stim = QComboBox(self)
qcmb_box_populate(self.cmb_plt_time_stim, self.plot_styles_list,
self.plt_time_stim)
self.cmb_plt_time_stim.setToolTip(
"<span>Plot style for stimulus.</span>")
self.lbl_plt_time_stmq = QLabel(
to_html(" Fixp. Stim. x_Q", frmt='bi'), self)
self.cmb_plt_time_stmq = QComboBox(self)
qcmb_box_populate(self.cmb_plt_time_stmq, self.plot_styles_list,
self.plt_time_stmq)
self.cmb_plt_time_stmq.setToolTip(
"<span>Plot style for <em>fixpoint</em> "
"(quantized) stimulus.</span>")
lbl_plt_time_resp = QLabel(to_html(" Resp. y", frmt='bi'),
self)
self.cmb_plt_time_resp = QComboBox(self)
qcmb_box_populate(self.cmb_plt_time_resp, self.plot_styles_list,
self.plt_time_resp)
self.cmb_plt_time_resp.setToolTip(
"<span>Plot style for response.</span>")
self.lbl_win_time = QLabel(to_html(" Win", frmt='bi'), self)
self.chk_win_time = QCheckBox(self)
self.chk_win_time.setObjectName("chk_win_time")
self.chk_win_time.setToolTip(
'<span>Plot FFT windowing function.</span>')
self.chk_win_time.setChecked(False)
line1 = QVLine()
line2 = QVLine(width=5)
self.but_log_time = PushButton(" dB")
self.but_log_time.setObjectName("but_log_time")
self.but_log_time.setToolTip(
"<span>Logarithmic scale for y-axis.</span>")
lbl_plt_time_spgr = QLabel(to_html("Spectrogram", frmt='bi'), self)
self.cmb_plt_time_spgr = QComboBox(self)
qcmb_box_populate(self.cmb_plt_time_spgr, self.cmb_time_spgr_items,
self.plt_time_spgr)
spgr_en = self.plt_time_spgr != "none"
self.cmb_mode_spgr_time = QComboBox(self)
qcmb_box_populate(self.cmb_mode_spgr_time,
self.cmb_mode_spgr_time_items, self.mode_spgr_time)
self.cmb_mode_spgr_time.setVisible(spgr_en)
self.lbl_byfs_spgr_time = QLabel(to_html(" per f_S", frmt='b'),
self)
self.lbl_byfs_spgr_time.setVisible(spgr_en)
self.chk_byfs_spgr_time = QCheckBox(self)
self.chk_byfs_spgr_time.setObjectName("chk_log_spgr")
self.chk_byfs_spgr_time.setToolTip("<span>Display spectral density "
"i.e. scale by f_S</span>")
self.chk_byfs_spgr_time.setChecked(True)
self.chk_byfs_spgr_time.setVisible(spgr_en)
self.but_log_spgr_time = QPushButton("dB")
self.but_log_spgr_time.setMaximumWidth(qtext_width(text=" dB"))
self.but_log_spgr_time.setObjectName("but_log_spgr")
self.but_log_spgr_time.setToolTip(
"<span>Logarithmic scale for spectrogram.</span>")
self.but_log_spgr_time.setCheckable(True)
self.but_log_spgr_time.setChecked(True)
self.but_log_spgr_time.setVisible(spgr_en)
self.lbl_time_nfft_spgr = QLabel(to_html(" N_FFT =", frmt='bi'),
self)
self.lbl_time_nfft_spgr.setVisible(spgr_en)
self.led_time_nfft_spgr = QLineEdit(self)
self.led_time_nfft_spgr.setText(str(self.time_nfft_spgr))
self.led_time_nfft_spgr.setToolTip("<span>Number of FFT points per "
"spectrogram segment.</span>")
self.led_time_nfft_spgr.setVisible(spgr_en)
self.lbl_time_ovlp_spgr = QLabel(to_html(" N_OVLP =", frmt='bi'),
self)
self.lbl_time_ovlp_spgr.setVisible(spgr_en)
self.led_time_ovlp_spgr = QLineEdit(self)
self.led_time_ovlp_spgr.setText(str(self.time_ovlp_spgr))
self.led_time_ovlp_spgr.setToolTip(
"<span>Number of overlap data points "
"between spectrogram segments.</span>")
self.led_time_ovlp_spgr.setVisible(spgr_en)
self.lbl_log_bottom_time = QLabel(to_html("min =", frmt='bi'), self)
self.led_log_bottom_time = QLineEdit(self)
self.led_log_bottom_time.setText(str(self.bottom_t))
self.led_log_bottom_time.setMaximumWidth(qtext_width(N_x=8))
self.led_log_bottom_time.setToolTip(
"<span>Minimum display value for time and spectrogram plots with log. scale."
"</span>")
self.lbl_log_bottom_time.setVisible(
self.but_log_time.isChecked()
or (spgr_en and self.but_log_spgr_time.isChecked()))
self.led_log_bottom_time.setVisible(
self.lbl_log_bottom_time.isVisible())
# self.lbl_colorbar_time = QLabel(to_html(" Col.bar", frmt='b'), self)
# self.lbl_colorbar_time.setVisible(spgr_en)
# self.chk_colorbar_time = QCheckBox(self)
# self.chk_colorbar_time.setObjectName("chk_colorbar_time")
# self.chk_colorbar_time.setToolTip("<span>Enable colorbar</span>")
# self.chk_colorbar_time.setChecked(True)
# self.chk_colorbar_time.setVisible(spgr_en)
layH_ctrl_time = QHBoxLayout()
layH_ctrl_time.addWidget(self.lbl_plt_time_stim)
layH_ctrl_time.addWidget(self.cmb_plt_time_stim)
#
layH_ctrl_time.addWidget(self.lbl_plt_time_stmq)
layH_ctrl_time.addWidget(self.cmb_plt_time_stmq)
#
layH_ctrl_time.addWidget(lbl_plt_time_resp)
layH_ctrl_time.addWidget(self.cmb_plt_time_resp)
#
layH_ctrl_time.addWidget(self.lbl_win_time)
layH_ctrl_time.addWidget(self.chk_win_time)
layH_ctrl_time.addSpacing(5)
layH_ctrl_time.addWidget(line1)
layH_ctrl_time.addSpacing(5)
#
layH_ctrl_time.addWidget(self.lbl_log_bottom_time)
layH_ctrl_time.addWidget(self.led_log_bottom_time)
layH_ctrl_time.addWidget(self.but_log_time)
layH_ctrl_time.addSpacing(5)
layH_ctrl_time.addWidget(line2)
layH_ctrl_time.addSpacing(5)
#
layH_ctrl_time.addWidget(lbl_plt_time_spgr)
layH_ctrl_time.addWidget(self.cmb_plt_time_spgr)
layH_ctrl_time.addWidget(self.cmb_mode_spgr_time)
layH_ctrl_time.addWidget(self.lbl_byfs_spgr_time)
layH_ctrl_time.addWidget(self.chk_byfs_spgr_time)
layH_ctrl_time.addWidget(self.but_log_spgr_time)
layH_ctrl_time.addWidget(self.lbl_time_nfft_spgr)
layH_ctrl_time.addWidget(self.led_time_nfft_spgr)
layH_ctrl_time.addWidget(self.lbl_time_ovlp_spgr)
layH_ctrl_time.addWidget(self.led_time_ovlp_spgr)
layH_ctrl_time.addStretch(10)
# layH_ctrl_time.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_time = QWidget(self)
self.wdg_ctrl_time.setLayout(layH_ctrl_time)
# ---- end time domain ------------------
# ---------------------------------------------------------------
# Controls for frequency domain
# ---------------------------------------------------------------
self.lbl_plt_freq_stim = QLabel(to_html("Stimulus X", frmt='bi'), self)
self.cmb_plt_freq_stim = QComboBox(self)
qcmb_box_populate(self.cmb_plt_freq_stim, self.plot_styles_list,
self.plt_freq_stim)
self.cmb_plt_freq_stim.setToolTip(
"<span>Plot style for stimulus.</span>")
self.lbl_plt_freq_stmq = QLabel(
to_html(" Fixp. Stim. X_Q", frmt='bi'), self)
self.cmb_plt_freq_stmq = QComboBox(self)
qcmb_box_populate(self.cmb_plt_freq_stmq, self.plot_styles_list,
self.plt_freq_stmq)
self.cmb_plt_freq_stmq.setToolTip(
"<span>Plot style for <em>fixpoint</em> (quantized) stimulus.</span>"
)
lbl_plt_freq_resp = QLabel(to_html(" Response Y", frmt='bi'),
self)
self.cmb_plt_freq_resp = QComboBox(self)
qcmb_box_populate(self.cmb_plt_freq_resp, self.plot_styles_list,
self.plt_freq_resp)
self.cmb_plt_freq_resp.setToolTip(
"<span>Plot style for response.</span>")
self.but_log_freq = QPushButton("dB")
self.but_log_freq.setMaximumWidth(qtext_width(" dB"))
self.but_log_freq.setObjectName(".but_log_freq")
self.but_log_freq.setToolTip(
"<span>Logarithmic scale for y-axis.</span>")
self.but_log_freq.setCheckable(True)
self.but_log_freq.setChecked(True)
self.lbl_log_bottom_freq = QLabel(to_html("min =", frmt='bi'), self)
self.lbl_log_bottom_freq.setVisible(self.but_log_freq.isChecked())
self.led_log_bottom_freq = QLineEdit(self)
self.led_log_bottom_freq.setText(str(self.bottom_f))
self.led_log_bottom_freq.setMaximumWidth(qtext_width(N_x=8))
self.led_log_bottom_freq.setToolTip(
"<span>Minimum display value for log. scale.</span>")
self.led_log_bottom_freq.setVisible(self.but_log_freq.isChecked())
if not self.but_log_freq.isChecked():
self.bottom_f = 0
self.cmb_freq_display = QComboBox(self)
qcmb_box_populate(self.cmb_freq_display, self.cmb_freq_display_items,
self.cmb_freq_display_item)
self.cmb_freq_display.setObjectName("cmb_re_im_freq")
self.but_Hf = QPushButtonRT(self, to_html("H_id", frmt="bi"), margin=5)
self.but_Hf.setObjectName("chk_Hf")
self.but_Hf.setToolTip(
"<span>Show ideal frequency response, calculated "
"from the filter coefficients.</span>")
self.but_Hf.setChecked(False)
self.but_Hf.setCheckable(True)
self.but_freq_norm_impz = QPushButtonRT(
text="<b><i>E<sub>X</sub></i> = 1</b>", margin=5)
self.but_freq_norm_impz.setToolTip(
"<span>Normalize the FFT of the stimulus with <i>N<sub>FFT</sub></i> for "
"<i>E<sub>X</sub></i> = 1. For a dirac pulse, this yields "
"|<i>Y(f)</i>| = |<i>H(f)</i>|. DC and Noise need to be "
"turned off, window should be <b>Rectangular</b>.</span>")
self.but_freq_norm_impz.setCheckable(True)
self.but_freq_norm_impz.setChecked(True)
self.but_freq_norm_impz.setObjectName("freq_norm_impz")
self.but_freq_show_info = QPushButton("Info", self)
self.but_freq_show_info.setMaximumWidth(qtext_width(" Info "))
self.but_freq_show_info.setObjectName("but_show_info_freq")
self.but_freq_show_info.setToolTip(
"<span>Show signal power in legend.</span>")
self.but_freq_show_info.setCheckable(True)
self.but_freq_show_info.setChecked(False)
layH_ctrl_freq = QHBoxLayout()
layH_ctrl_freq.addWidget(self.lbl_plt_freq_stim)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_stim)
#
layH_ctrl_freq.addWidget(self.lbl_plt_freq_stmq)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_stmq)
#
layH_ctrl_freq.addWidget(lbl_plt_freq_resp)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_resp)
#
layH_ctrl_freq.addSpacing(5)
layH_ctrl_freq.addWidget(self.but_Hf)
layH_ctrl_freq.addStretch(1)
#
layH_ctrl_freq.addWidget(self.lbl_log_bottom_freq)
layH_ctrl_freq.addWidget(self.led_log_bottom_freq)
layH_ctrl_freq.addWidget(self.but_log_freq)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(self.cmb_freq_display)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(self.but_freq_norm_impz)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(self.but_freq_show_info)
layH_ctrl_freq.addStretch(10)
# layH_ctrl_freq.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_freq = QWidget(self)
self.wdg_ctrl_freq.setLayout(layH_ctrl_freq)
# ---- end Frequency Domain ------------------
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
# connect FFT widget to qfft_selector and vice versa and to and signals upstream:
self.fft_widget.sig_tx.connect(self.process_sig_rx)
self.qfft_win_select.sig_tx.connect(self.process_sig_rx)
# connect process_sig_rx output to both FFT widgets
self.sig_tx_fft.connect(self.fft_widget.sig_rx)
self.sig_tx_fft.connect(self.qfft_win_select.sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
# --- run control ---
self.led_N_start.editingFinished.connect(self.update_N)
self.led_N_points.editingFinished.connect(self.update_N)
self.led_N_frame.editingFinished.connect(self.update_N)
self.but_fft_wdg.clicked.connect(self.toggle_fft_wdg)
# -------------------------------------------------------------------------
def update_N(self, emit=True):
"""
Update values for `self.N` and `self.win_dict['N']`, for `self.N_start` and
`self.N_end` from the corresponding QLineEditWidgets.
When `emit==True`, fire `'ui_changed': 'N'` to update the FFT window and the
`plot_impz` widgets. In contrast to `view_changed`, this also forces a
recalculation of the transient response.
This method is called by:
- `self._construct_ui()` with `emit==False`
- `plot_impz()` with `emit==False` when the automatic calculation
of N has to be updated (e.g. order of FIR Filter has changed
- signal-slot connection when `N_start` or `N_end` QLineEdit widgets have
been changed (`emit==True`)
"""
if not isinstance(emit, bool):
logger.error("update N: emit={0}".format(emit))
self.N_start = safe_eval(self.led_N_start.text(),
self.N_start,
return_type='int',
sign='poszero')
self.led_N_start.setText(str(self.N_start)) # update widget
self.N_user = safe_eval(self.led_N_points.text(),
self.N_user,
return_type='int',
sign='poszero')
if self.N_user == 0: # automatic calculation
self.N = self.calc_n_points(self.N_user) # widget remains set to 0
self.led_N_points.setText("0") # update widget
else:
self.N = self.N_user
self.led_N_points.setText(str(self.N)) # update widget
# total number of points to be calculated: N + N_start
self.N_end = self.N + self.N_start
self.N_frame_user = safe_eval(self.led_N_frame.text(),
self.N_frame_user,
return_type='int',
sign='poszero')
if self.N_frame_user == 0:
self.N_frame = self.N_end # use N_end for frame length
self.led_N_frame.setText(
"0") # update widget with "0" as set by user
else:
self.N_frame = self.N_frame_user
self.led_N_frame.setText(str(self.N_frame)) # update widget
# recalculate displayed freq. index values when freq. unit == 'k'
if fb.fil[0]['freq_specs_unit'] == 'k':
self.update_freqs()
if emit:
# use `'ui_changed'` as this triggers recalculation of the transient
# response
self.emit({'ui_changed': 'N'})
# ------------------------------------------------------------------------------
def toggle_fft_wdg(self):
"""
Show / hide FFT widget depending on the state of the corresponding button
When widget is shown, trigger an update of the window function.
"""
if self.but_fft_wdg.isChecked():
self.fft_widget.show()
self.emit({'view_changed': 'fft_win_type'}, sig_name='sig_tx_fft')
else:
self.fft_widget.hide()
# --------------------------------------------------------------------------
def hide_fft_wdg(self):
"""
The closeEvent caused by clicking the "x" in the FFT widget is caught
there and routed here to only hide the window
"""
self.but_fft_wdg.setChecked(False)
self.fft_widget.hide()
# ------------------------------------------------------------------------------
def calc_n_points(self, N_user=0):
"""
Calculate number of points to be displayed, depending on type of filter
(FIR, IIR) and user input. If the user selects 0 points, the number is
calculated automatically.
An improvement would be to calculate the dominant pole and the corresponding
settling time.
"""
if N_user == 0: # set number of data points automatically
if fb.fil[0]['ft'] == 'IIR':
# IIR: No algorithm yet, set N = 100
N = 100
else:
# FIR: N = number of coefficients (max. 100)
N = min(len(fb.fil[0]['ba'][0]), 100)
else:
N = N_user
return N
class UI_W(QWidget):
"""
Widget for entering integer and fractional bits. The result can be read out
via the attributes `self.WI`, `self.WF` and `self.W`.
The constructor accepts a dictionary for initial widget settings.
The following keys are defined; default values are used for missing keys:
'wdg_name' : 'ui_w' # widget name
'label' : 'WI.WF' # widget text label
'visible' : True # Is widget visible?
'enabled' : True # Is widget enabled?
'fractional' : True # Display WF, otherwise WF=0
'lbl_sep' : '.' # label between WI and WF field
'max_led_width' : 30 # max. length of lineedit field
'WI' : 0 # number of frac. *bits*
'WI_len' : 2 # max. number of integer *digits*
'tip_WI' : 'Number of integer bits' # Mouse-over tooltip
'WF' : 15 # number of frac. *bits*
'WF_len' : 2 # max. number of frac. *digits*
'tip_WF' : 'Number of frac. bits' # Mouse-over tooltip
'lock_visible' : False # Pushbutton for locking visible
'tip_lock' : 'Lock input/output quant.'# Tooltip for lock push button
'combo_visible' : False # Enable integrated combo widget
'combo_items' : ['auto', 'full', 'man'] # Combo selection
'tip_combo' : 'Calculate Acc. width.' # tooltip for combo
"""
# sig_rx = pyqtSignal(object) # incoming,
sig_tx = pyqtSignal(object) # outcgoing
from pyfda.libs.pyfda_qt_lib import emit
def __init__(self, parent, q_dict, **kwargs):
super(UI_W, self).__init__(parent)
self.q_dict = q_dict # pass a dict with initial settings for construction
self._construct_UI(**kwargs)
self.ui2dict(s='init') # initialize the class attributes
def _construct_UI(self, **kwargs):
"""
Construct widget from quantization dict, individual settings and
the default dict below """
# default settings
dict_ui = {
'wdg_name': 'ui_w',
'label': 'WI.WF',
'lbl_sep': '.',
'max_led_width': 30,
'WI': 0,
'WI_len': 2,
'tip_WI': 'Number of integer bits',
'WF': 15,
'WF_len': 2,
'tip_WF': 'Number of fractional bits',
'enabled': True,
'visible': True,
'fractional': True,
'combo_visible': False,
'combo_items': ['auto', 'full', 'man'],
'tip_combo': 'Calculate Acc. width.',
'lock_visible': False,
'tip_lock': 'Lock input/output quantization.'
} #: default values
if self.q_dict:
dict_ui.update(self.q_dict)
for k, v in kwargs.items():
if k not in dict_ui:
logger.warning("Unknown key {0}".format(k))
else:
dict_ui.update({k: v})
self.wdg_name = dict_ui['wdg_name']
if not dict_ui['fractional']:
dict_ui['WF'] = 0
self.WI = dict_ui['WI']
self.WF = dict_ui['WF']
self.W = int(self.WI + self.WF + 1)
if self.q_dict:
self.q_dict.update({'WI': self.WI, 'WF': self.WF, 'W': self.W})
else:
self.q_dict = {'WI': self.WI, 'WF': self.WF, 'W': self.W}
lblW = QLabel(to_html(dict_ui['label'], frmt='bi'), self)
self.cmbW = QComboBox(self)
self.cmbW.addItems(dict_ui['combo_items'])
self.cmbW.setVisible(dict_ui['combo_visible'])
self.cmbW.setToolTip(dict_ui['tip_combo'])
self.cmbW.setObjectName("cmbW")
self.butLock = QPushButton(self)
self.butLock.setCheckable(True)
self.butLock.setChecked(False)
self.butLock.setVisible(dict_ui['lock_visible'])
self.butLock.setToolTip(dict_ui['tip_lock'])
self.ledWI = QLineEdit(self)
self.ledWI.setToolTip(dict_ui['tip_WI'])
self.ledWI.setMaxLength(dict_ui['WI_len']) # maximum of 2 digits
self.ledWI.setFixedWidth(
dict_ui['max_led_width']) # width of lineedit in points
self.ledWI.setObjectName("WI")
lblDot = QLabel(dict_ui['lbl_sep'], self)
lblDot.setVisible(dict_ui['fractional'])
self.ledWF = QLineEdit(self)
self.ledWF.setToolTip(dict_ui['tip_WF'])
self.ledWF.setMaxLength(dict_ui['WI_len']) # maximum of 2 digits
self.ledWF.setFixedWidth(
dict_ui['max_led_width']) # width of lineedit in points
self.ledWF.setVisible(dict_ui['fractional'])
self.ledWF.setObjectName("WF")
layH = QHBoxLayout()
layH.addWidget(lblW)
layH.addStretch()
layH.addWidget(self.cmbW)
layH.addWidget(self.butLock)
layH.addWidget(self.ledWI)
layH.addWidget(lblDot)
layH.addWidget(self.ledWF)
layH.setContentsMargins(0, 0, 0, 0)
frmMain = QFrame(self)
frmMain.setLayout(layH)
layVMain = QVBoxLayout() # Widget main layout
layVMain.addWidget(frmMain)
layVMain.setContentsMargins(0, 5, 0, 0) # *params['wdg_margins'])
self.setLayout(layVMain)
# ----------------------------------------------------------------------
# INITIAL SETTINGS
# ----------------------------------------------------------------------
self.ledWI.setText(qstr(dict_ui['WI']))
self.ledWF.setText(qstr(dict_ui['WF']))
frmMain.setEnabled(dict_ui['enabled'])
frmMain.setVisible(dict_ui['visible'])
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.ledWI.editingFinished.connect(self.ui2dict)
self.ledWF.editingFinished.connect(self.ui2dict)
self.butLock.clicked.connect(self.butLock_clicked)
self.cmbW.currentIndexChanged.connect(self.ui2dict)
# initialize button icon
self.butLock_clicked(self.butLock.isChecked())
def quant_coeffs(self,
q_dict: dict,
coeffs: iterable,
to_int: bool = False) -> list:
"""
Quantize the coefficients, scale and convert them to integer and return them
as a list of integers
This is called every time one of the coefficient subwidgets is edited or changed.
Parameters:
-----------
q_dict: dict
Dictionary with quantizer settings for coefficients
coeffs: iterable
a list or ndarray of coefficients to be quantized
Returns:
--------
A list of integer coeffcients, quantized and scaled with the settings
of the passed quantization dict
"""
# Create coefficient quantizer instance using the passed quantization parameters
# dict from `input_widgets/input_coeffs.py` (and stored in the central
# filter dict)
Q_coeff = fx.Fixed(q_dict)
Q_coeff.frmt = 'dec' # always use decimal format for coefficients
if coeffs is None:
logger.error("Coeffs empty!")
# quantize floating point coefficients with the selected scale (WI.WF),
# next convert array float -> array of fixp
# -> list of int (scaled by 2^WF) when `to_int == True`
if to_int:
return list(Q_coeff.float2frmt(coeffs) * (1 << Q_coeff.WF))
else:
return list(Q_coeff.fixp(coeffs))
# --------------------------------------------------------------------------
def butLock_clicked(self, clicked):
"""
Update the icon of the push button depending on its state
"""
if clicked:
self.butLock.setIcon(QIcon(':/lock-locked.svg'))
else:
self.butLock.setIcon(QIcon(':/lock-unlocked.svg'))
q_icon_size = self.butLock.iconSize(
) # <- uncomment this for manual sizing
self.butLock.setIconSize(q_icon_size)
dict_sig = {'wdg_name': self.wdg_name, 'ui': 'butLock'}
self.emit(dict_sig)
# --------------------------------------------------------------------------
def ui2dict(self, s=None):
"""
Update the attributes `self.WI`, `self.WF` and `self.W` and `self.q_dict`
when one of the QLineEdit widgets has been edited.
Emit a signal with `{'ui':objectName of the sender}`.
"""
self.WI = int(
safe_eval(self.ledWI.text(),
self.WI,
return_type="int",
sign='poszero'))
self.ledWI.setText(qstr(self.WI))
self.WF = int(
safe_eval(self.ledWF.text(),
self.WF,
return_type="int",
sign='poszero'))
self.ledWF.setText(qstr(self.WF))
self.W = int(self.WI + self.WF + 1)
self.q_dict.update({'WI': self.WI, 'WF': self.WF, 'W': self.W})
if self.sender():
obj_name = self.sender().objectName()
logger.debug("sender: {0}".format(obj_name))
dict_sig = {'wdg_name': self.wdg_name, 'ui': obj_name}
self.emit(dict_sig)
elif s == 'init':
logger.debug("called by __init__")
else:
logger.error("sender without name!")
# --------------------------------------------------------------------------
def dict2ui(self, q_dict=None):
"""
Update the widgets `WI` and `WF` and the corresponding attributes
from the dict passed as the argument
"""
if q_dict is None:
q_dict = self.q_dict
if 'WI' in q_dict:
self.WI = safe_eval(q_dict['WI'],
self.WI,
return_type="int",
sign='poszero')
self.ledWI.setText(qstr(self.WI))
else:
logger.warning("No key 'WI' in dict!")
if 'WF' in q_dict:
self.WF = safe_eval(q_dict['WF'],
self.WF,
return_type="int",
sign='poszero')
self.ledWF.setText(qstr(self.WF))
else:
logger.warning("No key 'WF' in dict!")
self.W = self.WF + self.WI + 1
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) # local signal between FFT widget and FFTWin_Selector
sig_tx_local = pyqtSignal(object)
from pyfda.libs.pyfda_qt_lib import emit
def __init__(self):
QWidget.__init__(self)
self.ft = 'FIR'
win_names_list = [
"Boxcar", "Rectangular", "Barthann", "Bartlett", "Blackman",
"Blackmanharris", "Bohman", "Cosine", "Dolph-Chebyshev", "Flattop",
"General Gaussian", "Gauss", "Hamming", "Hann", "Kaiser",
"Nuttall", "Parzen", "Slepian", "Triangular", "Tukey"
]
self.cur_win_name = "Kaiser" # set initial window type
self.alg = "ichige"
# initialize windows dict with the list above for firwin window settings
self.win_dict = get_windows_dict(win_names_list=win_names_list,
cur_win_name=self.cur_win_name)
# get initial / last setting from dictionary, updating self.win_dict
self._load_dict()
# instantiate FFT window with windows dict
self.fft_widget = Plot_FFT_win(self,
win_dict=self.win_dict,
sym=True,
title="pyFDA FIR Window Viewer")
# hide window initially, this is modeless i.e. a non-blocking popup window
self.fft_widget.hide()
c = Common()
self.rt_dict = c.rt_base_iir
self.rt_dict_add = {
'COM': {
'min': {
'msg':
('a', "<br /><b>Note:</b> Filter order is only a rough "
"approximation and most likely far too low!")
},
'man': {
'msg':
('a', "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 process_sig_rx(self, dict_sig=None):
"""
Process local signals from / for
- FFT window widget
- qfft_win_select
"""
logger.debug("SIG_RX - vis: {0}\n{1}".format(self.isVisible(),
pprint_log(dict_sig)))
if dict_sig['id'] == id(self):
logger.warning(f"Stopped infinite loop:\n{pprint_log(dict_sig)}")
# --- signals coming from the FFT window widget or the qfft_win_select
if dict_sig['class'] in {'Plot_FFT_win', 'QFFTWinSelector'}:
if 'closeEvent' in dict_sig: # hide FFT window windget and return
self.hide_fft_wdg()
return
else:
if 'view_changed' in dict_sig and 'fft_win' in dict_sig[
'view_changed']:
# self._update_fft_window() # TODO: needed?
# local connection to FFT window widget and qfft_win_select
self.emit(dict_sig, sig_name='sig_tx_local')
# global connection to upper hierachies
# send notification that filter design has changed
self.emit({'filt_changed': 'firwin'})
# --------------------------------------------------------------------------
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()
self.qfft_win_select = QFFTWinSelector(self, self.win_dict)
# Minimum size, can be changed in the upper hierarchy levels using layouts:
# self.qfft_win_select.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.but_fft_wdg = QPushButton(self)
self.but_fft_wdg.setIcon(QIcon(":/fft.svg"))
but_height = self.qfft_win_select.sizeHint().height()
self.but_fft_wdg.setIconSize(QSize(but_height, but_height))
self.but_fft_wdg.setFixedSize(QSize(but_height, but_height))
self.but_fft_wdg.setToolTip(
'<span>Show / hide FFT widget (select window type '
' and display its properties).</span>')
self.but_fft_wdg.setCheckable(True)
self.but_fft_wdg.setChecked(False)
self.layHWin1 = QHBoxLayout()
# self.layHWin1.addWidget(self.cmb_firwin_win)
# self.layHWin1.addWidget(self.but_fft_wdg)
self.layHWin1.addWidget(self.cmb_firwin_alg)
self.layHWin2 = QHBoxLayout()
self.layHWin2.addWidget(self.but_fft_wdg)
self.layHWin2.addWidget(self.qfft_win_select)
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)
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
# connect FFT widget to qfft_selector and vice versa and to signals upstream:
self.fft_widget.sig_tx.connect(self.process_sig_rx)
self.qfft_win_select.sig_tx.connect(self.process_sig_rx)
# connect process_sig_rx output to both FFT widgets
self.sig_tx_local.connect(self.fft_widget.sig_rx)
self.sig_tx_local.connect(self.qfft_win_select.sig_rx)
# ----------------------------------------------------------------------
# SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.cmb_firwin_alg.currentIndexChanged.connect(
self._update_fft_window)
self.but_fft_wdg.clicked.connect(self.toggle_fft_wdg)
# ----------------------------------------------------------------------
# ==============================================================================
def _update_fft_window(self):
""" Update window type for FirWin - unneeded at the moment """
self.alg = str(self.cmb_firwin_alg.currentText())
self.emit({'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']
# alg_idx = 0
if 'wdg_fil' in fb.fil[0] and 'firwin' in fb.fil[0]['wdg_fil']\
and type(fb.fil[0]['wdg_fil']['firwin']) is dict:
self.win_dict = fb.fil[0]['wdg_fil']['firwin']
self.emit({'view_changed': 'fft_win_type'}, sig_name='sig_tx_local')
# --------------------------------------------------------------------------
def _store_dict(self):
"""
Store window and parameter settings using `self.win_dict` in filter dictionary.
"""
if 'wdg_fil' not in fb.fil[0]:
fb.fil[0].update({'wdg_fil': {}})
fb.fil[0]['wdg_fil'].update({'firwin': self.win_dict})
# --------------------------------------------------------------------------
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_dict()
# ------------------------------------------------------------------------------
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 = signaltools.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 "Kaiser" in self.win_dict and self.win_dict[
'cur_win_name'] == "Kaiser":
N, beta = sig.kaiserord(20 * np.log10(np.abs(fb.fil[0]['A_SB'])),
delta_f)
# logger.warning(f"N={N}, beta={beta}, A_SB={fb.fil[0]['A_SB']}")
self.win_dict["Kaiser"]["par"][0]["val"] = beta
self.qfft_win_select.led_win_par_0.setText(str(beta))
self.qfft_win_select.ui2dict_params(
) # pass changed parameter to other widgets
else:
N = remezord(F, W, A, fs=1, alg=alg)[0]
self.emit({'view_changed': 'fft_win_type'}, sig_name='sig_tx_local')
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
fil_dict['F_C'] = (self.F_SB +
self.F_PB) / 2 # average calculated F_PB and F_SB
self._save(
fil_dict,
self.firwin(self.N,
fil_dict['F_C'],
nyq=0.5,
window=self.qfft_win_select.get_window(self.N,
sym=True)))
def LPman(self, fil_dict):
self._get_params(fil_dict)
if not self._test_N():
return -1
logger.warning(self.win_dict["cur_win_name"])
self._save(
fil_dict,
self.firwin(self.N,
fil_dict['F_C'],
nyq=0.5,
window=self.qfft_win_select.get_window(self.N,
sym=True)))
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
fil_dict['F_C'] = (self.F_SB +
self.F_PB) / 2 # average calculated F_PB and F_SB
self._save(
fil_dict,
self.firwin(self.N,
fil_dict['F_C'],
pass_zero=False,
nyq=0.5,
window=self.qfft_win_select.get_window(self.N,
sym=True)))
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._save(
fil_dict,
self.firwin(self.N,
fil_dict['F_C'],
pass_zero=False,
nyq=0.5,
window=self.qfft_win_select.get_window(self.N,
sym=True)))
# 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
fil_dict['F_C'] = (self.F_SB +
self.F_PB) / 2 # average calculated F_PB and F_SB
fil_dict['F_C2'] = (self.F_SB2 + self.F_PB2) / 2
self._save(
fil_dict,
self.firwin(self.N, [fil_dict['F_C'], fil_dict['F_C2']],
nyq=0.5,
pass_zero=False,
window=self.qfft_win_select.get_window(self.N,
sym=True)))
def BPman(self, fil_dict):
self._get_params(fil_dict)
if not self._test_N():
return -1
self._save(
fil_dict,
self.firwin(self.N, [fil_dict['F_C'], fil_dict['F_C2']],
nyq=0.5,
pass_zero=False,
window=self.qfft_win_select.get_window(self.N,
sym=True)))
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
fil_dict['F_C'] = (self.F_SB +
self.F_PB) / 2 # average calculated F_PB and F_SB
fil_dict['F_C2'] = (self.F_SB2 + self.F_PB2) / 2
self._save(
fil_dict,
self.firwin(self.N, [fil_dict['F_C'], fil_dict['F_C2']],
window=self.qfft_win_select.get_window(self.N,
sym=True),
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._save(
fil_dict,
self.firwin(self.N, [fil_dict['F_C'], fil_dict['F_C2']],
window=self.qfft_win_select.get_window(self.N,
sym=True),
pass_zero=True,
nyq=0.5))
# ------------------------------------------------------------------------------
def toggle_fft_wdg(self):
"""
Show / hide FFT widget depending on the state of the corresponding button
When widget is shown, trigger an update of the window function.
"""
if self.but_fft_wdg.isChecked():
self.fft_widget.show()
self.emit({'view_changed': 'fft_win_type'},
sig_name='sig_tx_local')
else:
self.fft_widget.hide()
# --------------------------------------------------------------------------
def hide_fft_wdg(self):
"""
The closeEvent caused by clicking the "x" in the FFT widget is caught
there and routed here to only hide the window
"""
self.but_fft_wdg.setChecked(False)
self.fft_widget.hide()
class Input_Coeffs_UI(QWidget):
"""
Create the UI for the FilterCoeffs class
"""
sig_rx = pyqtSignal(dict) # incoming
sig_tx = pyqtSignal(dict) # outgoing
from pyfda.libs.pyfda_qt_lib import emit
def __init__(self, parent=None):
super(Input_Coeffs_UI, self).__init__(parent)
self.eps = 1.e-6 # initialize tolerance value
self._construct_UI()
# ------------------------------------------------------------------------------
def process_sig_rx(self, dict_sig=None):
"""
Process signals coming from the CSV pop-up window
"""
# logger.debug("PROCESS_SIG_RX:\n{0}".format(pprint_log(dict_sig)))
if 'closeEvent' in dict_sig:
self._close_csv_win()
self.emit({'ui_changed': 'csv'})
return
elif 'ui_changed' in dict_sig:
self._set_load_save_icons() # update icons file <-> clipboard
# inform e.g. the p/z input widget about changes in CSV options
self.emit({'ui_changed': 'csv'})
# ------------------------------------------------------------------------------
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- top chkbox row
- coefficient table
- two bottom rows with action buttons
"""
self.bfont = QFont()
self.bfont.setBold(True)
self.bifont = QFont()
self.bifont.setBold(True)
self.bifont.setItalic(True)
# q_icon_size = QSize(20, 20) # optional, size is derived from butEnable
#######################################################################
# frmMain
#
# This frame contains all the buttons
#######################################################################
# ---------------------------------------------
# layHDisplay
#
# UI Elements for controlling the display
# ---------------------------------------------
self.butEnable = PushButton(self, icon=QIcon(':/circle-check.svg'), checked=True)
q_icon_size = self.butEnable.iconSize() # <- uncomment this for manual sizing
self.butEnable.setToolTip(
"<span>Show / hide filter coefficients in an editable table."
" For high order systems, table display might be slow.</span>")
fix_formats = ['Dec', 'Hex', 'Bin', 'CSD']
self.cmbFormat = QComboBox(self)
model = self.cmbFormat.model()
item = QtGui.QStandardItem('Float')
item.setData('child', Qt.AccessibleDescriptionRole)
model.appendRow(item)
item = QtGui.QStandardItem('Fixp.:')
item.setData('parent', Qt.AccessibleDescriptionRole)
item.setData(0, QtGui.QFont.Bold)
item.setFlags(item.flags() & ~Qt.ItemIsEnabled) # | Qt.ItemIsSelectable))
model.appendRow(item)
for idx in range(len(fix_formats)):
item = QtGui.QStandardItem(fix_formats[idx])
# item.setForeground(QtGui.QColor('red'))
model.appendRow(item)
self.cmbFormat.insertSeparator(1)
qset_cmb_box(self.cmbFormat, 'float')
self.cmbFormat.setToolTip('Set the display format.')
self.cmbFormat.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.spnDigits = QSpinBox(self)
self.spnDigits.setRange(0, 16)
self.spnDigits.setValue(params['FMT_ba'])
self.spnDigits.setToolTip("Number of digits to display.")
self.lblDigits = QLabel("Digits", self)
self.lblDigits.setFont(self.bifont)
self.cmbQFrmt = QComboBox(self)
q_formats = [('Norm. Frac.', 'qnfrac'), ('Integer', 'qint'),
('Fractional', 'qfrac')]
for q in q_formats:
self.cmbQFrmt.addItem(*q)
self.lbl_W = QLabel("W = ", self)
self.lbl_W.setFont(self.bifont)
self.ledW = QLineEdit(self)
self.ledW.setToolTip("Specify total wordlength.")
self.ledW.setText("16")
self.ledW.setMaxLength(2) # maximum of 2 digits
self.ledW.setFixedWidth(30) # width of lineedit in points(?)
layHDisplay = QHBoxLayout()
layHDisplay.setAlignment(Qt.AlignLeft)
layHDisplay.addWidget(self.butEnable)
layHDisplay.addWidget(self.cmbFormat)
layHDisplay.addWidget(self.spnDigits)
layHDisplay.addWidget(self.lblDigits)
layHDisplay.addWidget(self.cmbQFrmt)
layHDisplay.addWidget(self.lbl_W)
layHDisplay.addWidget(self.ledW)
layHDisplay.addStretch()
#######################################################################
# frmButtonsCoeffs
#
# This frame contains all buttons for manipulating coefficients
#######################################################################
# -----------------------------------------------------------------
# layHButtonsCoeffs1
#
# UI Elements for loading / storing / manipulating cells and rows
# -----------------------------------------------------------------
self.cmbFilterType = QComboBox(self)
self.cmbFilterType.setObjectName("comboFilterType")
self.cmbFilterType.setToolTip(
"<span>Select between IIR and FIR filter for manual entry."
"Changing the type reloads the filter from the filter dict.</span>")
self.cmbFilterType.addItems(["FIR", "IIR"])
self.cmbFilterType.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.butAddCells = QPushButton(self)
self.butAddCells.setIcon(QIcon(':/row_insert_above.svg'))
self.butAddCells.setIconSize(q_icon_size)
self.butAddCells.setToolTip(
"<span>Select cells to insert a new cell above each selected cell. "
"Use <SHIFT> or <CTRL> to select multiple cells. "
"When nothing is selected, add a row at the end.</span>")
self.butDelCells = QPushButton(self)
self.butDelCells.setIcon(QIcon(':/row_delete.svg'))
self.butDelCells.setIconSize(q_icon_size)
self.butDelCells.setToolTip(
"<span>Delete selected cell(s) from the table. "
"Use <SHIFT> or <CTRL> to select multiple cells. "
"When nothing is selected, delete the last row.</span>")
self.butSave = QPushButton(self)
self.butSave.setIcon(QIcon(':/upload.svg'))
self.butSave.setIconSize(q_icon_size)
self.butSave.setToolTip(
"<span>Copy coefficient table to filter dict and update all plots"
"and widgets.</span>")
self.butLoad = QPushButton(self)
self.butLoad.setIcon(QIcon(':/download.svg'))
self.butLoad.setIconSize(q_icon_size)
self.butLoad.setToolTip("Reload coefficient table from filter dict.")
self.butClear = QPushButton(self)
self.butClear.setIcon(QIcon(':/trash.svg'))
self.butClear.setIconSize(q_icon_size)
self.butClear.setToolTip("Clear all table entries.")
self.butFromTable = QPushButton(self)
self.butFromTable.setIconSize(q_icon_size)
self.butToTable = QPushButton(self)
self.butToTable.setIconSize(q_icon_size)
self.but_csv_options = PushButton(self, icon=QIcon(':/settings.svg'),
checked=False)
self.but_csv_options.setIconSize(q_icon_size)
self.but_csv_options.setToolTip(
"<span>Select CSV format and whether "
"to copy to/from clipboard or file.</span>")
self._set_load_save_icons() # initialize icon / button settings
layHButtonsCoeffs1 = QHBoxLayout()
layHButtonsCoeffs1.addWidget(self.cmbFilterType)
layHButtonsCoeffs1.addWidget(self.butAddCells)
layHButtonsCoeffs1.addWidget(self.butDelCells)
layHButtonsCoeffs1.addWidget(self.butClear)
layHButtonsCoeffs1.addWidget(self.butSave)
layHButtonsCoeffs1.addWidget(self.butLoad)
layHButtonsCoeffs1.addWidget(self.butFromTable)
layHButtonsCoeffs1.addWidget(self.butToTable)
layHButtonsCoeffs1.addWidget(self.but_csv_options)
layHButtonsCoeffs1.addStretch()
# ----------------------------------------------------------------------
# layHButtonsCoeffs2
#
# Eps / set zero settings
# ---------------------------------------------------------------------
self.butSetZero = QPushButton("= 0", self)
self.butSetZero.setToolTip(
"<span>Set selected coefficients = 0 with a magnitude < ε. "
"When nothing is selected, test the whole table.</span>")
self.butSetZero.setIconSize(q_icon_size)
lblEps = QLabel(self)
lblEps.setText("<b><i>for b, a</i> <</b>")
self.ledEps = QLineEdit(self)
self.ledEps.setToolTip("Specify tolerance value.")
layHButtonsCoeffs2 = QHBoxLayout()
layHButtonsCoeffs2.addWidget(self.butSetZero)
layHButtonsCoeffs2.addWidget(lblEps)
layHButtonsCoeffs2.addWidget(self.ledEps)
layHButtonsCoeffs2.addStretch()
# -------------------------------------------------------------------
# Now put the ButtonsCoeffs HBoxes into frmButtonsCoeffs
# ---------------------------------------------------------------------
layVButtonsCoeffs = QVBoxLayout()
layVButtonsCoeffs.addLayout(layHButtonsCoeffs1)
layVButtonsCoeffs.addLayout(layHButtonsCoeffs2)
layVButtonsCoeffs.setContentsMargins(0, 5, 0, 0)
# This frame encompasses all Quantization Settings
self.frmButtonsCoeffs = QFrame(self)
self.frmButtonsCoeffs.setLayout(layVButtonsCoeffs)
# ######################################################################
# frmQSettings
#
# This frame contains all quantization settings
# ######################################################################
# -------------------------------------------------------------------
# layHW_Scale
#
# QFormat and scale settings
# ---------------------------------------------------------------------
lbl_Q = QLabel("Q =", self)
lbl_Q.setFont(self.bifont)
self.ledWI = QLineEdit(self)
self.ledWI.setToolTip("Specify number of integer bits.")
self.ledWI.setText("0")
self.ledWI.setMaxLength(2) # maximum of 2 digits
self.ledWI.setFixedWidth(30) # width of lineedit in points(?)
self.lblDot = QLabel(".", self) # class attribute, visibility is toggled
self.lblDot.setFont(self.bfont)
self.ledWF = QLineEdit(self)
self.ledWF.setToolTip("Specify number of fractional bits.")
self.ledWF.setText("15")
self.ledWF.setMaxLength(2) # maximum of 2 digits
# self.ledWF.setFixedWidth(30) # width of lineedit in points(?)
self.ledWF.setMaximumWidth(30)
self.lblScale = QLabel("<b><i>Scale</i> =</b>", self)
self.ledScale = QLineEdit(self)
self.ledScale.setToolTip(
"Set the scale for converting float to fixpoint representation.")
self.ledScale.setText(str(1))
self.ledScale.setEnabled(False)
layHWI_WF = QHBoxLayout()
layHWI_WF.addWidget(lbl_Q)
layHWI_WF.addWidget(self.ledWI)
layHWI_WF.addWidget(self.lblDot)
layHWI_WF.addWidget(self.ledWF)
layHWI_WF.addStretch()
layHScale = QHBoxLayout()
layHScale.addWidget(self.lblScale)
layHScale.addWidget(self.ledScale)
layHScale.addStretch()
layHW_Scale = QHBoxLayout()
layHW_Scale.addLayout(layHWI_WF)
layHW_Scale.addLayout(layHScale)
# -------------------------------------------------------------------
# layGQOpt
#
# Quantization / Overflow / MSB / LSB settings
# ---------------------------------------------------------------------
lblQOvfl = QLabel("Ovfl.:", self)
lblQOvfl.setFont(self.bifont)
lblQuant = QLabel("Quant.:", self)
lblQuant.setFont(self.bifont)
self.cmbQOvfl = QComboBox(self)
qOvfl = ['wrap', 'sat']
self.cmbQOvfl.addItems(qOvfl)
qset_cmb_box(self.cmbQOvfl, 'sat')
self.cmbQOvfl.setToolTip("Select overflow behaviour.")
# ComboBox size is adjusted automatically to fit the longest element
self.cmbQOvfl.setSizeAdjustPolicy(QComboBox.AdjustToContents)
layHQOvflOpt = QHBoxLayout()
layHQOvflOpt.addWidget(lblQOvfl)
layHQOvflOpt.addWidget(self.cmbQOvfl)
layHQOvflOpt.addStretch()
self.cmbQuant = QComboBox(self)
qQuant = ['none', 'round', 'fix', 'floor']
self.cmbQuant.addItems(qQuant)
qset_cmb_box(self.cmbQuant, 'round')
self.cmbQuant.setToolTip("Select the kind of quantization.")
self.cmbQuant.setSizeAdjustPolicy(QComboBox.AdjustToContents)
layHQuantOpt = QHBoxLayout()
layHQuantOpt.addWidget(lblQuant)
layHQuantOpt.addWidget(self.cmbQuant)
layHQuantOpt.addStretch()
self.butQuant = QPushButton(self)
self.butQuant.setToolTip(
"<span>Quantize selected coefficients / "
"whole table with specified settings.</span>")
self.butQuant.setIcon(QIcon(':/quantize.svg'))
self.butQuant.setIconSize(q_icon_size)
self.butQuant.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
lblMSBtxt = QLabel(self)
lblMSBtxt.setText("<b><i>MSB</i><sub>10</sub> =</b>")
self.lblMSB = QLabel(self)
layHMSB = QHBoxLayout()
layHMSB.addWidget(lblMSBtxt)
layHMSB.addWidget(self.lblMSB)
layHMSB.addStretch()
lblLSBtxt = QLabel(self)
lblLSBtxt.setText("<b><i>LSB</i><sub>10</sub> =</b>")
self.lblLSB = QLabel(self)
layHLSB = QHBoxLayout()
layHLSB.addWidget(lblLSBtxt)
layHLSB.addWidget(self.lblLSB)
layHLSB.addStretch()
layGQOpt = QGridLayout()
layGQOpt.addLayout(layHQOvflOpt, 0, 0)
layGQOpt.addLayout(layHQuantOpt, 0, 1)
layGQOpt.addWidget(self.butQuant, 0, 2, Qt.AlignCenter)
layGQOpt.addLayout(layHMSB, 1, 0)
layGQOpt.addLayout(layHLSB, 1, 1)
# -------------------------------------------------------------------
# Display MAX
# ---------------------------------------------------------------------
lblMAXtxt = QLabel(self)
lblMAXtxt.setText("<b><i>Max =</i></b>")
self.lblMAX = QLabel(self)
layHCoeffs_MAX = QHBoxLayout()
layHCoeffs_MAX.addWidget(lblMAXtxt)
layHCoeffs_MAX.addWidget(self.lblMAX)
layHCoeffs_MAX.addStretch()
#######################################################################
# Now put all the coefficient HBoxes into frmQSettings
# ---------------------------------------------------------------------
layVButtonsQ = QVBoxLayout()
layVButtonsQ.addLayout(layHW_Scale)
layVButtonsQ.addLayout(layGQOpt)
layVButtonsQ.addLayout(layHCoeffs_MAX)
layVButtonsQ.setContentsMargins(0, 0, 0, 0)
# This frame encompasses all Quantization Settings
self.frmQSettings = QFrame(self)
self.frmQSettings.setLayout(layVButtonsQ)
#######################################################################
# ######################## Main UI Layout ############################
#######################################################################
# layout for frame (UI widget)
layVMainF = QVBoxLayout()
layVMainF.addLayout(layHDisplay)
layVMainF.addWidget(self.frmQSettings)
layVMainF.addWidget(QHLine())
layVMainF.addWidget(self.frmButtonsCoeffs)
# This frame encompasses all UI elements
frmMain = QFrame(self)
frmMain.setLayout(layVMainF)
layVMain = QVBoxLayout()
# the following affects only the first widget (intended here)
layVMain.setAlignment(Qt.AlignTop)
layVMain.addWidget(frmMain)
layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(layVMain)
#######################################################################
# --- set initial values from dict ------------
self.spnDigits.setValue(params['FMT_ba'])
self.ledEps.setText(str(self.eps))
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.but_csv_options.clicked.connect(self._open_csv_win)
# --------------------------------------------------------------------------
def _open_csv_win(self):
"""
Pop-up window for CSV options
"""
if self.but_csv_options.isChecked():
qstyle_widget(self.but_csv_options, "changed")
else:
qstyle_widget(self.but_csv_options, "normal")
if dirs.csv_options_handle is None:
# no handle to the window? Create a new instance
if self.but_csv_options.isChecked():
# Important: Handle to window must be class attribute, otherwise it
# (and the attached window) is deleted immediately when it goes
# out of scope
dirs.csv_options_handle = CSV_option_box(self)
dirs.csv_options_handle.sig_tx.connect(self.process_sig_rx)
dirs.csv_options_handle.show() # modeless i.e. non-blocking popup window
else:
if not self.but_csv_options.isChecked(): # this should not happen
if dirs.csv_options_handle is None:
logger.warning("CSV options window is already closed!")
else:
dirs.csv_options_handle.close()
self.emit({'ui_changed': 'csv'})
# ------------------------------------------------------------------------------
def _close_csv_win(self):
dirs.csv_options_handle = None
self.but_csv_options.setChecked(False)
qstyle_widget(self.but_csv_options, "normal")
# ------------------------------------------------------------------------------
def _set_load_save_icons(self):
"""
Set icons / tooltipps for loading and saving data to / from file or
clipboard depending on selected options.
"""
if params['CSV']['clipboard']:
self.butFromTable.setIcon(QIcon(':/to_clipboard.svg'))
self.butFromTable.setToolTip(
"<span>Copy table to clipboard, SELECTED items are copied as "
"displayed. When nothing is selected, the whole table "
"is copied with full precision in decimal format.</span>")
self.butToTable.setIcon(QIcon(':/from_clipboard.svg'))
self.butToTable.setToolTip("<span>Copy clipboard to table.</span>")
else:
self.butFromTable.setIcon(QIcon(':/save.svg'))
self.butFromTable.setToolTip(
"<span>"
"Save table to file, SELECTED items are copied as "
"displayed. When nothing is selected, the whole table "
"is copied with full precision in decimal format.</span>")
self.butToTable.setIcon(QIcon(':/file.svg'))
self.butToTable.setToolTip("<span>Load table from file.</span>")
if dirs.csv_options_handle is None:
qstyle_widget(self.but_csv_options, "normal")
self.but_csv_options.setChecked(False)
else:
qstyle_widget(self.but_csv_options, "changed")
self.but_csv_options.setChecked(True)
def _construct_UI(self):
""" initialize the User Interface """
butClipboard = QPushButton(self)
butClipboard.setIcon(QIcon(':/clipboard.svg'))
butClipboard.setToolTip("Copy text to clipboard.")
butAbout = QPushButton(self)
butAbout.setText("About")
butAbout.setToolTip("Display 'About' info")
butChangelog = QPushButton(self)
butChangelog.setText("Changelog")
butChangelog.setToolTip("Display changelog")
butLicMIT = QPushButton(self)
butLicMIT.setText("MIT License")
butLicMIT.setToolTip("MIT License for pyFDA source code")
butLicGPLv3 = QPushButton(self)
butLicGPLv3.setText("GPLv3 License")
butLicGPLv3.setToolTip("GPLv3 License for bundled distribution")
butClose = QPushButton(self)
butClose.setIcon(QIcon(':/circle-x.svg'))
butClose.setToolTip("Close Window.")
layGButtons = QGridLayout()
layGButtons.addWidget(butClipboard, 0, 0)
layGButtons.addWidget(butAbout, 0, 1)
layGButtons.addWidget(butChangelog, 0, 2)
layGButtons.addWidget(butLicMIT, 0, 3)
layGButtons.addWidget(butLicGPLv3, 0, 4)
layGButtons.addWidget(butClose, 0, 5)
lblInfo = QLabel(self)
lblInfo.setText(self.info_str)
lblInfo.setFixedHeight(lblInfo.height() * 1.2)
#lblInfo.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
lblInfo.setOpenExternalLinks(True)
lblIcon = QLabel(self)
lblIcon.setPixmap(
QPixmap(':/pyfda_icon.svg').scaledToHeight(
lblInfo.height(), Qt.SmoothTransformation))
butClipboard.setFixedWidth(lblInfo.height())
butClose.setFixedWidth(lblInfo.height())
layHInfo = QHBoxLayout()
layHInfo.addWidget(lblIcon)
layHInfo.addWidget(lblInfo)
self.txtDisplay = QTextBrowser(self)
self.txtDisplay.setOpenExternalLinks(True)
self.display_about_str()
self.txtDisplay.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
#self.txtDisplay.setFixedHeight(self.txtDisplay.width() * 2)
layVMain = QVBoxLayout()
# layVMain.setAlignment(Qt.AlignTop) # this affects only the first widget (intended here)
layVMain.addLayout(layGButtons)
layVMain.addLayout(layHInfo)
layVMain.addWidget(self.txtDisplay)
layVMain.setContentsMargins(*params['wdg_margins_spc'])
self.setLayout(layVMain)
#self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
#self.resize(0,0)
#self.adjustSize()
#QApplication.processEvents()
butClipboard.clicked.connect(
lambda: self.to_clipboard(self.info_str + self.about_str))
butAbout.clicked.connect(self.display_about_str)
butChangelog.clicked.connect(self.display_changelog)
butLicMIT.clicked.connect(self.display_MIT_lic)
butLicGPLv3.clicked.connect(self.display_GPL_lic)
butClose.clicked.connect(self.close)
def about_window(self):
"""
Display an "About" window with copyright and version infos
"""
def to_clipboard(my_string):
"""
Copy version info to clipboard
"""
mapping = [
('<br>', '\n'),
('<br />', '\n'),
('</tr>', '\n'),
('</th>', '\n==============\n'),
('</table>', '\n'),
('<hr>', '\n---------\n'),
('<b>', ''),
('</b>', ''),
('<tr>', ''),
('<td>', ''),
('</td>', '\t'),
('<th>', ''),
(' ', ' '),
('<table>', ''), # ('</a>',''),
("<th style='font-size:large;'>", "\n")
]
for k, v in mapping:
my_string = my_string.replace(k, v)
fb.clipboard.setText(my_string)
user_dirs_str = ""
if dirs.USER_DIRS:
for d in dirs.USER_DIRS:
user_dirs_str += d + '<br />'
info_string = ("<b><a href=https://www.github.com/chipmuenk/pyfda>pyfda</a> "
"Version {0} (c) 2013 - 2020 Christian Münker</b><br />"
"Design, analyze and synthesize digital filters. Docs @ "
"<a href=https://pyfda.rtfd.org>pyfda.rtfd.org</a>"
" (<a href=https://media.readthedocs.org/pdf/pyfda/latest/pyfda.pdf>pdf</a>)<hr>"\
.format(version.__version__))
versions_string = (
"<b>OS:</b> {0} {1}<br><b>User Name:</b> {2}<br>".format(
dirs.OS, dirs.OS_VER, dirs.USER_NAME))
# dir_string = ("<table><th style='font-size:large;'>Imported Modules</th>"
# "<tr><td>  {0}</td></tr>"\
# .format( pyfda_lib.mod_version().replace("\n", "<br>  ")))
dir_string = (
"<table><th style='font-size:large;'>Software Versions</th>")
dir_string += pyfda_lib.mod_version()
dir_string += "</table>"
dir_string += ("<table><th style='font-size:large;'>Directories</th>"
"<tr><td><b>Home:</b></td><td>{0}</td></tr>"
"<tr><td><b>Install: </b></td><td>{1}</td></tr>"
"<tr><td><b>Config: </b></td><td>{2}</td></tr>"
"<tr><td><b>User: </b></td><td>{3}</td></tr>"
"<tr><td><b>Temp:</b></td><td>{4}</td></tr>"\
.format( dirs.HOME_DIR, dirs.INSTALL_DIR, dirs.CONF_DIR,
user_dirs_str[:-6], dirs.TEMP_DIR))
dir_string += ("<th style='font-size:large;'>Logging Files</th>"
"<tr><td><b>Config:</b></td><td>{0}</td></tr>"
"<tr><td><b>Output: </b></td><td>{1}</td></tr>"
"</table>"\
.format(dirs.USER_LOG_CONF_DIR_FILE, dirs.LOG_DIR_FILE))
about_string = info_string + versions_string + dir_string
#msg = QMessageBox.about(self, "About pyFDA", info_string)
butClipboard = QPushButton(self)
butClipboard.setIcon(QIcon(':/clipboard.svg'))
butClipboard.setToolTip("Copy text to clipboard.")
# butClipboard.adjustSize()
# butClipboard.setFixedSize(self.checkLayout.sizeHint())
msg = QMessageBox(self)
msg.setIconPixmap(
QPixmap(':/pyfda_icon.svg').scaledToHeight(
32, Qt.SmoothTransformation))
msg.addButton(butClipboard, QMessageBox.ActionRole)
msg.setText(about_string)
# msg.setInformativeText("This is additional information")
#msg.setDetailedText(versions_string) # adds a button that opens another textwindow
msg.setWindowTitle("About pyFDA")
msg.setStandardButtons(QMessageBox.Ok) # | QMessageBox.Cancel
# close Message box with close event triggered by "x" icon
msg.closeEvent = self.closeEvent
butClipboard.clicked.connect(lambda: to_clipboard(about_string))
retval = msg.exec_()
class Input_PZ_UI(QWidget):
"""
Create the UI for the FilterPZ class
"""
sig_rx = pyqtSignal(object) # incoming
sig_tx = pyqtSignal(object) # outgoing
def __init__(self, parent):
"""
Pass instance `parent` of parent class (FilterCoeffs)
"""
super(Input_PZ_UI, self).__init__(parent)
# self.parent = parent # instance of the parent (not the base) class
self.eps = 1.e-4 # # tolerance value for e.g. setting P/Z to zero
self._construct_UI()
#------------------------------------------------------------------------------
def process_sig_rx(self, dict_sig=None):
"""
Process signals coming from the CSV pop-up window
"""
logger.debug("PROCESS_SIG_RX\n{0}".format(pprint_log(dict_sig)))
if 'closeEvent' in dict_sig:
self._close_csv_win()
self.sig_tx.emit({'sender':__name__, 'ui_changed': 'csv'})
return # probably not needed
elif 'ui_changed' in dict_sig:
self._set_load_save_icons() # update icons file <-> clipboard
# inform e.g. the p/z input widget about changes in CSV options
self.sig_tx.emit({'sender':__name__, 'ui_changed': 'csv'})
#------------------------------------------------------------------------------
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- top chkbox row
- coefficient table
- two bottom rows with action buttons
"""
self.bfont = QFont()
self.bfont.setBold(True)
self.bifont = QFont()
self.bifont.setBold(True)
self.bifont.setItalic(True)
# q_icon_size = QSize(20, 20) # optional, size is derived from butEnable
# ---------------------------------------------
# UI Elements for controlling the display
# ---------------------------------------------
self.butEnable = QPushButton(self)
self.butEnable.setIcon(QIcon(':/circle-x.svg'))
q_icon_size = self.butEnable.iconSize() # <- set this for manual icon sizing
self.butEnable.setIconSize(q_icon_size)
self.butEnable.setCheckable(True)
self.butEnable.setChecked(True)
self.butEnable.setToolTip("<span>Show / hide poles and zeros in an editable table."
" For high order systems, the table display might be slow.</span>")
self.cmbPZFrmt = QComboBox(self)
pz_formats = [('Cartesian', 'cartesian'), ('Polar (rad)', 'polar_rad'),
('Polar (pi)', 'polar_pi'), ('Polar (°)', 'polar_deg')] # display text, data
# π: u'3C0, °: u'B0, ∠: u'2220
for pz in pz_formats:
self.cmbPZFrmt.addItem(*pz)
self.cmbPZFrmt.setSizeAdjustPolicy(QComboBox.AdjustToContents)
# self.cmbPZFrmt.setEnabled(False)
self.cmbPZFrmt.setToolTip("<span>Set display format for poles and zeros to"
" either cartesian (x + jy) or polar (r * ∠ Ω)."
" Type 'o' for '°', '<' for '∠' and 'pi' for 'π'.</span>")
self.spnDigits = QSpinBox(self)
self.spnDigits.setRange(0,16)
self.spnDigits.setToolTip("Number of digits to display.")
self.lblDigits = QLabel("Digits", self)
self.lblDigits.setFont(self.bifont)
self.cmbCausal = QComboBox(self)
causal_types = ['Causal', 'Acausal', 'Anticausal']
for cs in causal_types:
self.cmbCausal.addItem(cs)
qset_cmb_box(self.cmbCausal, 'Causal')
self.cmbCausal.setToolTip('<span>Set the system type. Not implemented yet.</span>')
self.cmbCausal.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmbCausal.setEnabled(False)
layHDisplay = QHBoxLayout()
layHDisplay.setAlignment(Qt.AlignLeft)
layHDisplay.addWidget(self.butEnable)
layHDisplay.addWidget(self.cmbPZFrmt)
layHDisplay.addWidget(self.spnDigits)
layHDisplay.addWidget(self.lblDigits)
layHDisplay.addWidget(self.cmbCausal)
layHDisplay.addStretch()
# ---------------------------------------------
# UI Elements for setting the gain
# ---------------------------------------------
self.lblNorm = QLabel(to_html("Normalize:", frmt='bi'), self)
self.cmbNorm = QComboBox(self)
self.cmbNorm.addItems(["None", "1", "Max"])
self.cmbNorm.setToolTip("<span>Set the gain <i>k</i> so that H(f)<sub>max</sub> is "
"either 1 or the max. of the previous system.</span>")
self.lblGain = QLabel(to_html("k =", frmt='bi'), self)
self.ledGain = QLineEdit(self)
self.ledGain.setToolTip("<span>Specify gain factor <i>k</i>"
" (only possible for Normalize = 'None').</span>")
self.ledGain.setText(str(1.))
self.ledGain.setObjectName("ledGain")
layHGain = QHBoxLayout()
layHGain.addWidget(self.lblNorm)
layHGain.addWidget(self.cmbNorm)
layHGain.addWidget(self.lblGain)
layHGain.addWidget(self.ledGain)
layHGain.addStretch()
# ---------------------------------------------
# UI Elements for loading / storing / manipulating cells and rows
# ---------------------------------------------
# self.cmbFilterType = QComboBox(self)
# self.cmbFilterType.setObjectName("comboFilterType")
# self.cmbFilterType.setToolTip("Select between IIR and FIR filte for manual entry.")
# self.cmbFilterType.addItems(["FIR","IIR"])
# self.cmbFilterType.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.butAddCells = QPushButton(self)
self.butAddCells.setIcon(QIcon(':/row_insert_above.svg'))
self.butAddCells.setIconSize(q_icon_size)
self.butAddCells.setToolTip("<SPAN>Select cells to insert a new cell above each selected cell. "
"Use <SHIFT> or <CTRL> to select multiple cells. "
"When nothing is selected, add a row at the end.</SPAN>")
self.butDelCells = QPushButton(self)
self.butDelCells.setIcon(QIcon(':/row_delete.svg'))
self.butDelCells.setIconSize(q_icon_size)
self.butDelCells.setToolTip("<SPAN>Delete selected cell(s) from the table. "
"Use <SHIFT> or <CTRL> to select multiple cells. "
"When nothing is selected, delete the last row.</SPAN>")
self.butSave = QPushButton(self)
self.butSave.setIcon(QIcon(':/upload.svg'))
self.butSave.setIconSize(q_icon_size)
self.butSave.setToolTip("<span>Copy P/Z table to filter dict and update all plots and widgets.</span>")
self.butLoad = QPushButton(self)
self.butLoad.setIcon(QIcon(':/download.svg'))
self.butLoad.setIconSize(q_icon_size)
self.butLoad.setToolTip("Reload P/Z table from filter dict.")
self.butClear = QPushButton(self)
self.butClear.setIcon(QIcon(':/trash.svg'))
self.butClear.setIconSize(q_icon_size)
self.butClear.setToolTip("Clear all table entries.")
self.butFromTable = QPushButton(self)
self.butFromTable.setIconSize(q_icon_size)
self.butToTable = QPushButton(self)
self.butToTable.setIconSize(q_icon_size)
self.but_csv_options = QPushButton(self)
self.but_csv_options.setIcon(QIcon(':/settings.svg'))
self.but_csv_options.setIconSize(q_icon_size)
self.but_csv_options.setToolTip("<span>Select CSV format and whether "
"to copy to/from clipboard or file.</span>")
self.but_csv_options.setCheckable(True)
self.but_csv_options.setChecked(False)
self._set_load_save_icons() # initialize icon / button settings
layHButtonsCoeffs1 = QHBoxLayout()
# layHButtonsCoeffs1.addWidget(self.cmbFilterType)
layHButtonsCoeffs1.addWidget(self.butAddCells)
layHButtonsCoeffs1.addWidget(self.butDelCells)
layHButtonsCoeffs1.addWidget(self.butClear)
layHButtonsCoeffs1.addWidget(self.butSave)
layHButtonsCoeffs1.addWidget(self.butLoad)
layHButtonsCoeffs1.addWidget(self.butFromTable)
layHButtonsCoeffs1.addWidget(self.butToTable)
layHButtonsCoeffs1.addWidget(self.but_csv_options)
layHButtonsCoeffs1.addStretch()
#-------------------------------------------------------------------
# Eps / set zero settings
# ---------------------------------------------------------------------
self.butSetZero = QPushButton("= 0", self)
self.butSetZero.setToolTip("<span>Set selected poles / zeros = 0 with a magnitude < ε. "
"When nothing is selected, test the whole table.</span>")
self.butSetZero.setIconSize(q_icon_size)
lblEps = QLabel(self)
lblEps.setText("<b><i>for ε</i> <</b>")
self.ledEps = QLineEdit(self)
self.ledEps.setToolTip("Specify tolerance value.")
layHButtonsCoeffs2 = QHBoxLayout()
layHButtonsCoeffs2.addWidget(self.butSetZero)
layHButtonsCoeffs2.addWidget(lblEps)
layHButtonsCoeffs2.addWidget(self.ledEps)
layHButtonsCoeffs2.addStretch()
# ######################## Main UI Layout ############################
# layout for frame (UI widget)
layVMainF = QVBoxLayout()
layVMainF.addLayout(layHDisplay)
layVMainF.addLayout(layHGain)
layVMainF.addLayout(layHButtonsCoeffs1)
layVMainF.addLayout(layHButtonsCoeffs2)
# This frame encompasses all UI elements
frmMain = QFrame(self)
frmMain.setLayout(layVMainF)
layVMain = QVBoxLayout()
layVMain.setAlignment(Qt.AlignTop) # this affects only the first widget (intended here)
layVMain.addWidget(frmMain)
layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(layVMain)
#--- set initial values from dict ------------
self.spnDigits.setValue(params['FMT_pz'])
self.ledEps.setText(str(self.eps))
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.but_csv_options.clicked.connect(self._open_csv_win)
#------------------------------------------------------------------------------
def _open_csv_win(self):
"""
Pop-up window for CSV options
"""
if self.but_csv_options.isChecked():
qstyle_widget(self.but_csv_options, "changed")
else:
qstyle_widget(self.but_csv_options, "normal")
if dirs.csv_options_handle is None: # no handle to the window? Create a new instance
if self.but_csv_options.isChecked():
# Important: Handle to window must be class attribute otherwise it
# (and the attached window) is deleted immediately when it goes out of scope
dirs.csv_options_handle = CSV_option_box(self)
dirs.csv_options_handle.sig_tx.connect(self.process_sig_rx)
dirs.csv_options_handle.show() # modeless i.e. non-blocking popup window
else:
if not self.but_csv_options.isChecked(): # this should not happen
if dirs.csv_options_handle is None:
logger.warning("CSV options window is already closed!")
else:
dirs.csv_options_handle.close()
self.sig_tx.emit({'sender':__name__, 'ui_changed': 'csv'})
#------------------------------------------------------------------------------
def _close_csv_win(self):
dirs.csv_options_handle = None
self.but_csv_options.setChecked(False)
qstyle_widget(self.but_csv_options, "normal")
#------------------------------------------------------------------------------
def _set_load_save_icons(self):
"""
Set icons / tooltipps for loading and saving data to / from file or
clipboard depending on selected options.
"""
if params['CSV']['clipboard']:
self.butFromTable.setIcon(QIcon(':/to_clipboard.svg'))
self.butFromTable.setToolTip("<span>"
"Copy table to clipboard, SELECTED items are copied as "
"displayed. When nothing is selected, the whole table "
"is copied with full precision in decimal format.</span>")
self.butToTable.setIcon(QIcon(':/from_clipboard.svg'))
self.butToTable.setToolTip("<span>Copy clipboard to table.</span>")
else:
self.butFromTable.setIcon(QIcon(':/save.svg'))
self.butFromTable.setToolTip("<span>"
"Save table to file, SELECTED items are copied as "
"displayed. When nothing is selected, the whole table "
"is copied with full precision in decimal format.</span>")
self.butToTable.setIcon(QIcon(':/file.svg'))
self.butToTable.setToolTip("<span>Load table from file.</span>")
if dirs.csv_options_handle is None:
qstyle_widget(self.but_csv_options, "normal")
self.but_csv_options.setChecked(False)
else:
qstyle_widget(self.but_csv_options, "changed")
self.but_csv_options.setChecked(True)