add signal type as own struc

bin/main.signal_generator.cpp

@@ -4,7 +4,10 @@
 auto main() -> int
 {
   hr::signal_generator generator;
-  auto s = generator.generate(hr::SIGNAL_TYPE::SIN);
+  hr::signal_type st;
-  hack::log()(hr::get_signal_name(hr::SIGNAL_TYPE::SIN));
+  st.m_type = hr::signal_type::type::SIN;
+
+  auto s = generator.generate(st);
+  hack::log()(st.get_name());
   hack::log()(s);
 }

src/utils/signal_generator/signal_generator.cpp

@@ -4,30 +4,30 @@
 
 namespace hr
 {
-  std::vector<float> signal_generator::generate(SIGNAL_TYPE type, NOISE noise)
+  std::vector<float> signal_generator::generate(signal_type st, NOISE noise)
   {
     std::vector<float> res;
-    switch (type) 
+    switch (st.m_type) 
     {
-      case SIGNAL_TYPE::SIN:
+      case signal_type::type::SIN:
         res = sin(noise);
         break;
-      case SIGNAL_TYPE::SQUARE:
+      case signal_type::type::SQUARE:
         res = square(noise);
         break;
-      case SIGNAL_TYPE::TRIANGLE:
+      case signal_type::type::TRIANGLE:
         res = triangle(noise);
         break;
-      case SIGNAL_TYPE::SAW:
+      case signal_type::type::SAW:
         res = saw(noise);
         break;
-      case SIGNAL_TYPE::SPEECH_LIKE:
+      case signal_type::type::SPEECH_LIKE:
         res = speech_like(noise);
         break;
-      case SIGNAL_TYPE::NOISE_ONLY:
+      case signal_type::type::NOISE_ONLY:
         res = noise_only();
         break;
-      case SIGNAL_TYPE::THREE_SINES:
+      case signal_type::type::THREE_SINES:
         res = three_sines(noise);
       break;
     }

src/utils/signal_generator/signal_generator.hpp

@@ -1,41 +1,11 @@
 #pragma once
 
 #include <random>
-#include "utils/var.hpp"
+#include "utils/workers/signal_type.hpp"
 
-// Генерирует простую синусоиду и др. полезности см. SIGNAL_TYPE
+// Генерирует простую синусоиду и др. полезности см. workers/signal_type.hpp
 namespace hr
 {
-  std::string inline get_signal_name(SIGNAL_TYPE t)
-  {
-    std::string name;
-    switch (t) 
-    {
-      case SIGNAL_TYPE::SIN:
-        name = "SIN";
-        break;
-      case SIGNAL_TYPE::SQUARE:
-        name = "SQUARE";
-        break;
-      case SIGNAL_TYPE::TRIANGLE:
-        name = "TRIANGLE";
-        break;
-      case SIGNAL_TYPE::SAW:
-        name = "SAW";
-        break;
-      case SIGNAL_TYPE::NOISE_ONLY:
-        name = "NOISE_ONLY";
-        break;
-      case SIGNAL_TYPE::SPEECH_LIKE:
-        name = "SPEECH_LIKE";
-        break;
-      case SIGNAL_TYPE::THREE_SINES:
-        name = "THREE_SINES";
-        break;
-    }
-    return name;
-  };
-
   enum class NOISE 
   {
     NO,
@@ -54,7 +24,7 @@ namespace hr
     public:
       signal_generator() : m_gen(12345) {}
       
-      std::vector<float> generate(SIGNAL_TYPE type, NOISE noise = NOISE::NO);
+      std::vector<float> generate(signal_type st, NOISE noise = NOISE::NO);
 
     public:
       struct signal_params

src/utils/var.hpp

@@ -1,20 +1,4 @@
 #pragma once
 
 #include "noincl.hpp" // IWYU pragma: keep
-
+namespace hr { }
-namespace hr
-{
-  enum class SIGNAL_TYPE
-  {
-    FILE,        // Из файла
-    SIN,         // Синусоида
-    SQUARE,      // Прямоугольный
-    TRIANGLE,    // Треугольный
-    SAW,         // Пилообразный
-    NOISE_ONLY,  // Только шум
-    SPEECH_LIKE, // Типа речь
-    THREE_SINES  // Три частоты 
-  };
-}
-
-

src/utils/workers/setup.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
+#include "utils/workers/signal_type.hpp"
 #include <filesystem>
-#include "utils/var.hpp"
 
 namespace hr
 {
@@ -18,10 +18,11 @@ namespace hr
     int m_frames;
     int m_channels;
 
-    SIGNAL_TYPE m_signal_type = SIGNAL_TYPE::FILE;
     std::filesystem::path m_file; 
     std::size_t m_block_size = 1'024;
     std::size_t m_step_size = 512;
+    
+    signal_type m_signal_type;
     DOMAIN_PLUGIN m_domain = DOMAIN_PLUGIN::FREQUENSY;
   };
 }

src/utils/workers/signal_type.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <vector>
+#include <string>
+
+namespace hr
+{
+  // Некая структура описывающая базоввые типы сигналов
+  struct signal_type
+  {
+    enum class type
+    {
+      FILE,        // Из файла
+      SIN,         // Синусоида
+      SQUARE,      // Прямоугольный
+      TRIANGLE,    // Треугольный
+      SAW,         // Пилообразный
+      NOISE_ONLY,  // Только шум
+      SPEECH_LIKE, // Типа речь
+      THREE_SINES  // Три частоты 
+    } m_type = type::FILE;
+
+    signal_type() = default;
+    explicit signal_type(type t) : m_type(t) {}
+    
+    // Получить имя типа 
+    std::string get_name() const 
+    {
+      switch (m_type) 
+      {
+        case type::FILE:         return "FILE";
+        case type::SIN:          return "SIN";
+        case type::SQUARE:       return "SQUARE";
+        case type::TRIANGLE:     return "TRIANGLE";
+        case type::SAW:          return "SAW";
+        case type::NOISE_ONLY:   return "NOISE_ONLY";
+        case type::SPEECH_LIKE:  return "SPEECH_LIKE";
+        case type::THREE_SINES:  return "THREE_SINES";
+        default:                 return "UNKNOWN";
+      }
+    }
+    
+    bool operator<(const signal_type& other) const 
+    {
+      return m_type < other.m_type;
+    }
+    
+    bool operator==(const signal_type& other) const 
+    {
+      return m_type == other.m_type;
+    }
+  };
+    
+  // просто для итерации в графическом интерфейсе
+  inline const std::vector<signal_type>& all_types() 
+  {
+    static const std::vector<signal_type> signals = {
+      signal_type(signal_type::type::FILE),
+      signal_type(signal_type::type::SIN),
+      signal_type(signal_type::type::SQUARE),
+      signal_type(signal_type::type::TRIANGLE),
+      signal_type(signal_type::type::SAW),
+      signal_type(signal_type::type::NOISE_ONLY),
+      signal_type(signal_type::type::SPEECH_LIKE),
+      signal_type(signal_type::type::THREE_SINES)
+    };
+    return signals;
+  }
+}