Refactor signal generation GUI

b_asic/GUI/signal_generator_input.py

+# -*- coding: utf-8 -*-
+from qtpy.QtWidgets import QGridLayout, QLabel, QLineEdit, QSpinBox
+
+from b_asic.signal_generator import Gaussian, Impulse, Sinusoid, Step, ZeroPad
+
+
+class SignalGeneratorInput(QGridLayout):
+    """Abstract class for graphically configuring and generating signal generators."""
+
+    def get_generator(self):
+        raise NotImplementedError
+
+
+class DelayInput(SignalGeneratorInput):
+    """
+    Abstract class for graphically configuring and generating signal generators that
+    have a single delay parameter.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.delay_label = QLabel("Delay")
+        self.addWidget(self.delay_label, 0, 0)
+        self.delay_spin_box = QSpinBox()
+        self.delay_spin_box.setRange(0, 2147483647)
+        self.addWidget(self.delay_spin_box, 0, 1)
+
+
+class ImpulseInput(DelayInput):
+    """
+    Class for graphically configuring and generating a
+    :class:`~b_asic.signal_generators.Impulse` signal generator.
+    """
+
+    def get_generator(self):
+        return Impulse(self.delay_spin_box.value())
+
+
+class StepInput(DelayInput):
+    """
+    Class for graphically configuring and generating a
+    :class:`~b_asic.signal_generators.Step` signal generator.
+    """
+
+    def get_generator(self):
+        return Step(self.delay_spin_box.value())
+
+
+class ZeroPadInput(SignalGeneratorInput):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.input_label = QLabel("Input")
+        self.addWidget(self.input_label, 0, 0)
+        self.input_sequence = QLineEdit()
+        self.addWidget(self.input_sequence, 0, 1)
+
+    def get_generator(self):
+        input_values = []
+        for val in self.input_sequence.text().split(","):
+            val = val.strip()
+            try:
+                if not val:
+                    val = 0
+
+                val = complex(val)
+            except ValueError:
+                self._window.logger.warning(f"Skipping value: {val}, not a digit.")
+                continue
+
+            input_values.append(val)
+
+        return ZeroPad(input_values)
+
+
+class SinusoidInput(SignalGeneratorInput):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.frequency_label = QLabel("Frequency")
+        self.addWidget(self.frequency_label, 0, 0)
+        self.frequency_input = QLineEdit()
+        self.addWidget(self.frequency_input, 0, 1)
+
+        self.phase_label = QLabel("Phase")
+        self.addWidget(self.phase_label, 1, 0)
+        self.phase_input = QLineEdit()
+        self.addWidget(self.phase_input, 1, 1)
+
+    def get_generator(self):
+        frequency = self.frequency_input.text().strip()
+        try:
+            if not frequency:
+                frequency = 0.1
+
+            frequency = float(frequency)
+        except ValueError:
+            self._window.logger.warning(
+                f"Cannot parse frequency: {frequency} not a number."
+            )
+            frequency = 0.1
+
+        phase = self.phase_input.text().strip()
+        try:
+            if not phase:
+                phase = 0
+
+            phase = float(phase)
+        except ValueError:
+            self._window.logger.warning(f"Cannot parse phase: {phase} not a number.")
+            phase = 0
+
+        return Sinusoid(frequency, phase)
+
+
+class GaussianInput(SignalGeneratorInput):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.scale_label = QLabel("Standard deviation")
+        self.addWidget(self.scale_label, 0, 0)
+        self.scale_input = QLineEdit()
+        self.addWidget(self.scale_input, 0, 1)
+
+        self.loc_label = QLabel("Average value")
+        self.addWidget(self.loc_label, 1, 0)
+        self.loc_input = QLineEdit()
+        self.addWidget(self.loc_input, 1, 1)
+
+        self.seed_label = QLabel("Seed")
+        self.addWidget(self.seed_label, 2, 0)
+        self.seed_spin_box = QSpinBox()
+        self.seed_spin_box.setRange(0, 2147483647)
+        self.addWidget(self.seed_spin_box, 2, 1)
+
+    def get_generator(self):
+        scale = self.scale_input.text().strip()
+        try:
+            if not scale:
+                scale = 1
+
+            scale = float(scale)
+        except ValueError:
+            self._window.logger.warning(f"Cannot parse scale: {scale} not a number.")
+            scale = 1
+
+        loc = self.loc_input.text().strip()
+        try:
+            if not loc:
+                loc = 0
+
+            loc = float(loc)
+        except ValueError:
+            self._window.logger.warning(f"Cannot parse loc: {loc} not a number.")
+            loc = 0
+
+        return Gaussian(self.seed_spin_box.value(), loc, scale)
+
+
+_GENERATOR_MAPPING = {
+    "Gaussian": GaussianInput,
+    "Impulse": ImpulseInput,
+    "Sinusoid": SinusoidInput,
+    "Step": StepInput,
+    "ZeroPad": ZeroPadInput,
+}