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 Impulse, Sinusoid, Step, ZeroPad
-
-_GENERATOR_MAPPING = {
-    "Impulse": ImpulseInput,
-    "Sinusoid": SinusoidInput,
-    "Step": StepInput,
-    "ZeroPad": ZeroPadInput,
-}
+from b_asic.signal_generator import (
+    Constant,
+    Gaussian,
+    Impulse,
+    SignalGenerator,
+    Sinusoid,
+    Step,
+    Uniform,
+    ZeroPad,
+)
 
 
 class SignalGeneratorInput(QGridLayout):
     """Abstract class for graphically configuring and generating signal generators."""
 
-    def get_generator(self):
+    def __init__(self, logger, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._logger = logger
+
+    def get_generator(self) -> SignalGenerator:
+        """Return the SignalGenerator based on the graphical input."""
         raise NotImplementedError
 
 
@@ -32,6 +39,9 @@ class DelayInput(SignalGeneratorInput):
         self.delay_spin_box.setRange(0, 2147483647)
         self.addWidget(self.delay_spin_box, 0, 1)
 
+    def get_generator(self) -> SignalGenerator:
+        raise NotImplementedError
+
 
 class ImpulseInput(DelayInput):
     """
@@ -39,7 +49,7 @@ class ImpulseInput(DelayInput):
     :class:`~b_asic.signal_generators.Impulse` signal generator.
     """
 
-    def get_generator(self):
+    def get_generator(self) -> SignalGenerator:
         return Impulse(self.delay_spin_box.value())
 
 
@@ -49,11 +59,16 @@ class StepInput(DelayInput):
     :class:`~b_asic.signal_generators.Step` signal generator.
     """
 
-    def get_generator(self):
+    def get_generator(self) -> SignalGenerator:
         return Step(self.delay_spin_box.value())
 
 
 class ZeroPadInput(SignalGeneratorInput):
+    """
+    Class for graphically configuring and generating a
+    :class:`~b_asic.signal_generators.ZeroPad` signal generator.
+    """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.input_label = QLabel("Input")
@@ -61,7 +76,7 @@ class ZeroPadInput(SignalGeneratorInput):
         self.input_sequence = QLineEdit()
         self.addWidget(self.input_sequence, 0, 1)
 
-    def get_generator(self):
+    def get_generator(self) -> SignalGenerator:
         input_values = []
         for val in self.input_sequence.text().split(","):
             val = val.strip()
@@ -71,7 +86,7 @@ class ZeroPadInput(SignalGeneratorInput):
 
                 val = complex(val)
             except ValueError:
-                self._window.logger.warning(f"Skipping value: {val}, not a digit.")
+                self._logger.warning(f"Skipping value: {val}, not a digit.")
                 continue
 
             input_values.append(val)
@@ -80,6 +95,11 @@ class ZeroPadInput(SignalGeneratorInput):
 
 
 class SinusoidInput(SignalGeneratorInput):
+    """
+    Class for graphically configuring and generating a
+    :class:`~b_asic.signal_generators.Sinusoid` signal generator.
+    """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.frequency_label = QLabel("Frequency")
@@ -92,7 +112,7 @@ class SinusoidInput(SignalGeneratorInput):
         self.phase_input = QLineEdit()
         self.addWidget(self.phase_input, 1, 1)
 
-    def get_generator(self):
+    def get_generator(self) -> SignalGenerator:
         frequency = self.frequency_input.text().strip()
         try:
             if not frequency:
@@ -100,9 +120,7 @@ class SinusoidInput(SignalGeneratorInput):
 
             frequency = float(frequency)
         except ValueError:
-            self._window.logger.warning(
-                f"Cannot parse frequency: {frequency} not a number."
-            )
+            self._logger.warning(f"Cannot parse frequency: {frequency} not a number.")
             frequency = 0.1
 
         phase = self.phase_input.text().strip()
@@ -112,7 +130,146 @@ class SinusoidInput(SignalGeneratorInput):
 
             phase = float(phase)
         except ValueError:
-            self._window.logger.warning(f"Cannot parse phase: {phase} not a number.")
+            self._logger.warning(f"Cannot parse phase: {phase} not a number.")
             phase = 0
 
         return Sinusoid(frequency, phase)
+
+
+class GaussianInput(SignalGeneratorInput):
+    """
+    Class for graphically configuring and generating a
+    :class:`~b_asic.signal_generators.Gaussian` signal generator.
+    """
+
+    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.scale_input.setText("1.0")
+        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.loc_input.setText("0.0")
+        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) -> SignalGenerator:
+        scale = self.scale_input.text().strip()
+        try:
+            if not scale:
+                scale = 1
+
+            scale = float(scale)
+        except ValueError:
+            self._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._logger.warning(f"Cannot parse loc: {loc} not a number.")
+            loc = 0
+
+        return Gaussian(self.seed_spin_box.value(), loc, scale)
+
+
+class UniformInput(SignalGeneratorInput):
+    """
+    Class for graphically configuring and generating a
+    :class:`~b_asic.signal_generators.Uniform` signal generator.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.low_label = QLabel("Lower bound")
+        self.addWidget(self.low_label, 0, 0)
+        self.low_input = QLineEdit()
+        self.low_input.setText("-1.0")
+        self.addWidget(self.low_input, 0, 1)
+
+        self.high_label = QLabel("Upper bound")
+        self.addWidget(self.high_label, 1, 0)
+        self.high_input = QLineEdit()
+        self.high_input.setText("1.0")
+        self.addWidget(self.high_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) -> SignalGenerator:
+        low = self.low_input.text().strip()
+        try:
+            if not low:
+                low = -1.0
+
+            low = float(low)
+        except ValueError:
+            self._logger.warning(f"Cannot parse low: {low} not a number.")
+            low = -1.0
+
+        high = self.high_input.text().strip()
+        try:
+            if not high:
+                high = 1.0
+
+            high = float(high)
+        except ValueError:
+            self._logger.warning(f"Cannot parse high: {high} not a number.")
+            high = 1.0
+
+        return Uniform(self.seed_spin_box.value(), low, high)
+
+
+class ConstantInput(SignalGeneratorInput):
+    """
+    Class for graphically configuring and generating a
+    :class:`~b_asic.signal_generators.Constant` signal generator.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.constant_label = QLabel("Constant")
+        self.addWidget(self.constant_label, 0, 0)
+        self.constant_input = QLineEdit()
+        self.constant_input.setText("1.0")
+        self.addWidget(self.constant_input, 0, 1)
+
+    def get_generator(self) -> SignalGenerator:
+        constant = self.constant_input.text().strip()
+        try:
+            if not constant:
+                constant = 1.0
+
+            constant = complex(constant)
+        except ValueError:
+            self._logger.warning(f"Cannot parse constant: {constant} not a number.")
+            constant = 0.0
+
+        return Constant(constant)
+
+
+_GENERATOR_MAPPING = {
+    "Constant": ConstantInput,
+    "Gaussian": GaussianInput,
+    "Impulse": ImpulseInput,
+    "Sinusoid": SinusoidInput,
+    "Step": StepInput,
+    "Uniform": UniformInput,
+    "ZeroPad": ZeroPadInput,
+}