add mark positions completed

meson.build

@@ -53,5 +53,3 @@ deps = [
 
 subdir('src')
 subdir('bin')
-#############################################################
-

src/meson.build

@@ -21,9 +21,9 @@ headers = [
   'monitor/utils/var.hpp',
   'monitor/utils/func.hpp',
   'monitor/utils/plugin.hpp',
-  'monitor/utils/plugins/raw_data.hpp',
+  'monitor/utils/plugins/raw_data/raw_data.hpp',
-  'monitor/utils/plugins/magnitude.hpp',
+  'monitor/utils/plugins/magnitude/magnitude.hpp',
-  'monitor/utils/plugins/fft.hpp',
+  'monitor/utils/plugins/fft/fft.hpp',
 
   ############ LIBS
   'monitor/libs/audio/audio.hpp',
@@ -99,6 +99,9 @@ sources = [
   ############ UTILS
   'monitor/libs/audio/audio.cpp',
   'monitor/libs/gtkfd/gtkfd.cpp',
+  'monitor/utils/plugins/raw_data/raw_data.cpp',
+  'monitor/utils/plugins/magnitude/magnitude.cpp',
+  'monitor/utils/plugins/fft/fft.cpp',
 ]
 
 lib = library(

src/monitor/gui/components/audio/audio.hpp

@@ -1,8 +1,10 @@
 #pragma once
 
 #include <VE.hpp> 
+#include <harmonica.hpp>
 #include "monitor/libs/audio/audio.hpp"
 #include "monitor/utils/var.hpp"
+#include "monitor/utils/setup.hpp"
 
 namespace monitor::components
 {
@@ -18,9 +20,14 @@ namespace monitor::components
       {
         std::string m_id;
         sf::Time m_current_time;
-        std::filesystem::path m_file;
+        utils::setup m_setup;
       } m_current_audio;
       std::map<std::string, music> m_audio_data;
+      std::size_t m_compression = 0;
+
+      
+
+
 
       std::vector<std::string> m_domains = { "time", "frequensy"};
 
@@ -33,7 +40,7 @@ namespace monitor::components
       void set_pos(double pos);
 
     private:
-      void init(std::string snapshot_id, std::filesystem::path file);
+      void init(std::string snapshot_id, utils::setup& setup);
       void change(std::string snapshot_id);
       void callback(sf::Time time);
   };

src/monitor/gui/components/audio/cpp/base.cpp

@@ -31,10 +31,11 @@ namespace monitor::components
     m_player.pause();
   }
 
-  void audio::init(std::string snapshot_id, std::filesystem::path file)
+  void audio::init(std::string snapshot_id, utils::setup& setup)
   {
     m_player.stop();
-    m_audio_data[snapshot_id] =  music{ .m_id = snapshot_id, .m_current_time = sf::Time(), .m_file = file };
+    m_audio_data[snapshot_id] =  music{ .m_id = snapshot_id, .m_current_time = sf::Time(), .m_setup = setup };
+    m_status = utils::var::STATUS::ACTIVE;
   }
 
   void audio::change(std::string snapshot_id)
@@ -42,18 +43,27 @@ namespace monitor::components
     m_audio_data[m_current_audio.m_id].m_current_time = m_current_audio.m_current_time;
     m_player.stop();
     m_current_audio = m_audio_data[snapshot_id];
-    m_player.set_file(m_current_audio.m_file);
+    m_player.set_file(m_current_audio.m_setup.m_file);
     m_player.set_audio_pos(m_current_audio.m_current_time);
+    callback(m_current_audio.m_current_time);
   }
 
   void audio::callback(sf::Time time)
   {
     m_current_audio.m_current_time = time;
-    VE::event e { utils::event_type::INCREMENT_MARKER_AUDIO_POSITION, time };
+    double seconds = time.asSeconds();
+    double current_sample_index = seconds * m_current_audio.m_setup.m_sample_rate / m_compression;
+
+    // send to:: components/markers
+    VE::event e { utils::event_type::SET_MARKER_AUDIO_POSITION, current_sample_index };
     EMIT(e);
   }
 
-  // делать
+
+
+
+  // HERE
+  // делать нужно, но надо разобраться зачем?
   void audio::drop()
   {
     m_player.stop();

src/monitor/gui/components/audio/cpp/on_event.cpp

@@ -1,4 +1,3 @@
-#include <harmonica.hpp>
 #include "monitor/gui/components/audio/audio.hpp"
 #include "monitor/utils/event_type.hpp"
 
@@ -29,9 +28,8 @@ namespace monitor::components
       {
         case utils::event_type::INIT_AUDIO:
         {
-          auto [snapshot_id, file] = std::any_cast<std::pair<std::string, std::filesystem::path>>(e.m_data);
+          auto [snapshot_id, setup] = std::any_cast<std::pair<std::string, utils::setup>>(e.m_data);
-          init(snapshot_id, file);
+          init(snapshot_id, setup);
-          m_status = utils::var::STATUS::ACTIVE;
           break;
         }
 
@@ -48,6 +46,12 @@ namespace monitor::components
           break;
         }
 
+        case utils::event_type::SET_COMPRESSION:
+        {
+          m_compression = std::any_cast<std::size_t>(e.m_data);
+          break;
+        }
+
         case utils::event_type::SET_AUDIO_POSITION:
         {
           auto d = std::any_cast<double>(e.m_data);

src/monitor/gui/components/base_plugins/base_plugins.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <VE.hpp> 
+#include "monitor/utils/setup.hpp"
 #include "monitor/gui/components/graph/graph.hpp"
 #include "monitor/gui/components/fft_scaled/fft_scaled.hpp"
 
@@ -24,11 +25,15 @@ namespace monitor::components
       fft_scaled m_fft_scaled;
 
     private:
-      hr::setup m_setup;
+      utils::setup m_setup;
       std::vector<std::shared_ptr<utils::plugin>> m_base_plugins; 
 
     public:
-      void init(std::string snapshot_id, hr::setup setup);
+      void init(std::string snapshot_id, utils::setup setup);
+
+    private:
+      void calculate_plugin(std::shared_ptr<utils::plugin> plugin);
+      void change_tab(std::size_t index);
   };
 }
 

src/monitor/gui/components/base_plugins/cpp/base.cpp

@@ -1,6 +1,6 @@
 #include "monitor/gui/components/base_plugins/base_plugins.hpp"
-#include "monitor/utils/plugins/raw_data.hpp"
+#include "monitor/utils/plugins/raw_data/raw_data.hpp"
-#include "monitor/utils/plugins/magnitude.hpp"
+#include "monitor/utils/plugins/magnitude/magnitude.hpp"
 #include "monitor/utils/event_type.hpp"
 
 namespace monitor::components
@@ -12,8 +12,8 @@ namespace monitor::components
     m_graph.on_attach();
     m_fft_scaled.on_attach();
 
-    m_base_plugins.push_back(std::make_shared<utils::plugin>(utils::plugins::raw_data{}));
+    m_base_plugins.push_back(std::make_shared<utils::plugins::raw_data>());
-    m_base_plugins.push_back(std::make_shared<utils::plugin>(utils::plugins::magnitude{}));
+    m_base_plugins.push_back(std::make_shared<utils::plugins::magnitude>());
 
     m_size.x = VE::application::get()->get_glfw()->width() - VE::application::get()->get_glfw()->width() / 4.f;
     m_size.y = VE::application::get()->get_glfw()->height() / 2.f;
@@ -32,16 +32,60 @@ namespace monitor::components
     m_fft_scaled.update();
   }
   
-  void base_plugins::init(std::string snapshot_id, hr::setup setup)
+  void base_plugins::init(std::string snapshot_id, utils::setup setup)
   {
     m_snapshot_id = snapshot_id;
     m_setup = setup;
+
     m_graph.init(m_snapshot_id, m_setup);
-    m_graph.set_plugin(m_base_plugins[0]);
     // m_fft_scaled.init(m_snapshot_id, m_setup);
 
+    change_tab(0);
+
     // send to: components/audio
-    VE::event e { utils::event_type::INIT_AUDIO, std::pair<std::string, std::filesystem::path>(m_snapshot_id, setup.m_file) };
+    VE::event e { utils::event_type::INIT_AUDIO, std::pair<std::string, utils::setup>(m_snapshot_id, m_setup) };
     EMIT(e);
   }
+
+  void base_plugins::change_tab(std::size_t index)
+  {
+    m_current_open_index = index;
+    calculate_plugin(m_base_plugins[index]);
+    m_graph.set_plugin(m_base_plugins[index]);
+
+    // send to: components/audio
+    VE::event e { utils::event_type::SET_COMPRESSION, m_base_plugins[index]->m_compression_step };
+    EMIT(e);
+  }
+
+  void base_plugins::calculate_plugin(std::shared_ptr<utils::plugin> plugin)
+  {
+    if (!plugin->empty()) return;
+
+    switch (plugin->m_type) 
+    {
+      case utils::plugin::TYPE::RAW_DATA:
+      {
+        m_setup.m_domain = hr::DOMAIN_PLUGIN::TIME;
+        plugin->m_result = hr::run<hr::plugins::raw_data>(m_setup);
+        break;
+      }
+      case utils::plugin::TYPE::MAGNITUDE:
+      {
+        m_setup.m_domain = hr::DOMAIN_PLUGIN::FREQUENSY;
+        plugin->m_result = hr::run<hr::plugins::magnitude>(m_setup);
+        break;
+      }
+    }
+
+    if (!plugin->empty())
+    {
+      plugin->init(m_setup);
+      plugin->fill();
+    }
+    else
+    {
+      hack::error()("NOT SET DATA!");
+    }
+  }
 }

src/monitor/gui/components/base_plugins/cpp/on_event.cpp

@@ -11,11 +11,16 @@ namespace monitor::components
 
       switch (type)
       {
-        // case utils::event_type::CREATE_SNAPSHOT_COMPLETED:
+        case utils::event_type::PREPARE_BASE_PLUGIN_COMPRESSION:
-        // {
+        {
-        //   clear();
+          auto snapshot_id = std::any_cast<std::string>(e.m_data);
-        //   break;
+          if (m_snapshot_id != snapshot_id) return;
-        // }
+
+          // send to: components/audio
+          VE::event e { utils::event_type::SET_COMPRESSION, m_base_plugins[m_current_open_index]->m_compression_step };
+          EMIT(e);
+          break;
+        }
       }
     }
   }

src/monitor/gui/components/base_plugins/cpp/render.cpp

@@ -22,11 +22,7 @@ namespace monitor::components
           ImGui::EndTabItem();
         }
 
-        if (ImGui::IsItemClicked()) 
+        if (ImGui::IsItemClicked()) change_tab(i);
-        {
-          m_current_open_index = i;
-          m_graph.set_plugin(m_base_plugins[i]);
-        }
       }
       ImGui::EndTabBar();
     }

src/monitor/gui/components/creator/cpp/render/setup.cpp

@@ -8,7 +8,7 @@ namespace monitor::components
     float spacing = ImGui::GetStyle().ItemInnerSpacing.x;
     std::size_t step = 256;
 
-    // block_size
+    // BLOCK SIZE
     ImGui::Text("block size:");
     ImGui::SameLine(0.0f, spacing);
 
@@ -37,11 +37,11 @@ namespace monitor::components
     ImGui::PopID();
     VE_POP_FONT();
     ImGui::PopItemFlag();
-    // end
+    // end BLOCK SIZE
 
     ImGui::SameLine(0.f, 3.f * spacing);
 
-    // step size
+    // STEP SIZE
     ImGui::Text("step size:");
     ImGui::SameLine(0.0f, spacing);
 
@@ -70,6 +70,6 @@ namespace monitor::components
     ImGui::PopID();
     VE_POP_FONT();
     ImGui::PopItemFlag();
-    // end
+    // end STEP SIZE
   }
 }

src/monitor/gui/components/creator/creator.hpp

@@ -5,6 +5,7 @@
 #include "monitor/gui/components/spinner/spinner.hpp"
 #include "monitor/gui/components/file_dialog/file_dialog.hpp"
 #include "monitor/utils/var.hpp"
+#include "monitor/utils/setup.hpp"
 
 namespace monitor::components
 {
@@ -18,13 +19,15 @@ namespace monitor::components
       components::spinner m_spinner;
       
     private:
-      hr::setup m_setup;
+      utils::setup m_setup;
       file_dialog m_fd;
       std::filesystem::path m_file_path;
 
     private:
       void render_setup();
       void render_spinner(ImVec2 pos = { 10.f, 8.f });
+
+    private:
       void create();
       void clear();
   };

src/monitor/gui/components/fft_scaled/fft_scaled.hpp

@@ -2,7 +2,7 @@
 
 #include <VE.hpp>
 #include <harmonica.hpp>
-#include "monitor/utils/plugins/fft.hpp"
+#include "monitor/utils/plugins/fft/fft.hpp"
 
 namespace monitor::components
 {

src/monitor/gui/components/graph/cpp/base.cpp

@@ -30,35 +30,6 @@ namespace monitor::components
   {
     m_plugin = std::move(plugin);
     if (!m_plugin) hack::error()("The object is not installed");
-
-    if (m_plugin->empty())
-    {
-      switch (m_plugin->m_type) 
-      {
-        case utils::plugin::TYPE::RAW_DATA:
-        {
-          m_setup.m_domain = hr::DOMAIN_PLUGIN::TIME;
-          m_plugin->m_result = hr::run<hr::plugins::raw_data>(m_setup);
-          hack::log()(m_plugin->m_result.m_size);
-          break;
-        }
-        case utils::plugin::TYPE::MAGNITUDE:
-        {
-          m_setup.m_domain = hr::DOMAIN_PLUGIN::FREQUENSY;
-          m_plugin->m_result = hr::run<hr::plugins::magnitude>(m_setup);
-          break;
-        }
-      }
-      if (!m_plugin->empty())
-      {
-        m_plugin->init();
-        m_plugin->fill();
-      }
-      else
-      {
-        hack::error()("NOT SET RAW DATA!");
-      }
-    }
   }
 
   std::size_t graph::get_plugin_size() noexcept

src/monitor/gui/components/markers/cpp/on_event.cpp

@@ -34,15 +34,6 @@ namespace monitor::components
       auto type = std::any_cast<utils::event_type>(e.m_type);
       switch (type)
       {
-        case utils::event_type::INCREMENT_MARKER_AUDIO_POSITION:
-        {
-          auto t = std::any_cast<sf::Time>(e.m_data);
-          static int index = 0;
-          if (index%16 == 0) ++m_marker_audio_position;
-          ++index;
-          break;
-        }
-
         case utils::event_type::SET_MARKER_AUDIO_POSITION:
         {
           auto pos = std::any_cast<double>(e.m_data);

src/monitor/gui/components/snapshot/cpp/base.cpp

@@ -26,7 +26,7 @@ namespace monitor::components
     m_status = s;
   }
 
-  void snapshot::init(hr::setup setup)
+  void snapshot::init(utils::setup setup)
   {
     m_snapshot_id = hack::security::generate_uuid();
     m_setup = setup;

src/monitor/gui/components/snapshot/cpp/render.cpp

@@ -11,94 +11,5 @@ namespace monitor::components
     ImGui::PushID("scale");
     m_base_controls.render();
     ImGui::PopID();
-
-
-    // m_audio.render();
-    //
-    // ImGui::SameLine();
-    //
-    // // HERE 
-    // // выбор домена для плагина
-    // auto ctx = ImGui::GetCurrentContext();
-    // ImGui::SameLine(0.f, ctx->Style.FramePadding.x);
-    // ImGui::SetNextItemWidth(120.f);
-    // static std::size_t domain_id = 0;
-    // if (ImGui::BeginCombo(VE_NO_NAME("select_domain"), m_domains[domain_id].c_str()))
-    // {
-    //   for (std::size_t i = 0; i < m_domains.size(); ++i)
-    //   {
-    //     const bool is_selected = (domain_id == i);
-    //     if (ImGui::Selectable(m_domains[i].c_str(), is_selected)) 
-    //       domain_id = i;
-    //     if (is_selected) ImGui::SetItemDefaultFocus();
-    //   }
-    //   ImGui::EndCombo();
-    // }
-    //
-    // ImGui::SameLine();
-    //
-    // ImGui::SetNextItemWidth(400.f);
-    // if (ImGui::BeginCombo(VE_NO_NAME("select_plugin"), m_plugin.m_id < 0 ? "---" : m_plugins[m_plugin.m_id].m_name.c_str()))
-    // {
-    //   for (std::size_t i = 0; i < m_plugins.size(); ++i)
-    //   {
-    //     const bool is_selected = (m_plugin.m_id == static_cast<int>(i));
-    //     if (ImGui::Selectable(m_plugins[i].m_name.c_str(), is_selected)) 
-    //       m_plugin = m_plugins[i];
-    //     if (is_selected) ImGui::SetItemDefaultFocus();
-    //   }
-    //   ImGui::EndCombo();
-    // }
-    //
-    // ImGui::SameLine();
-    //
-    // if (ImGui::Button("add plugin", ImVec2{ 94.f, 27.f })) add_plugin();
-    //
-    // if (ImPlot::BeginSubplots(VE_NO_NAME("graph" + m_snapshot_id), m_rows, m_cols, ImVec2(-1, -1), ImPlotSubplotFlags_LinkRows | ImPlotSubplotFlags_LinkCols)) 
-    // {
-    //   for (const auto& graph : m_graphs) 
-    //   {
-    //     if (ImPlot::BeginPlot(VE_NAME(graph.m_name), ImVec2(-1, 0), ImPlotFlags_NoMenus)) 
-    //     {
-    //                                           // по оси X
-    //       ImPlot::SetupAxes(nullptr, nullptr, ImPlotAxisFlags_Opposite |  // смена полюсов у надписей оси x. они вверху
-    //                                           ImPlotAxisFlags_NoSideSwitch | // нельзя перетаскивать оси по сторонам
-    //                                           (is_first_render ? ImPlotAxisFlags_AutoFit : ImPlotAxisFlags_None) | // авто подстройка размера по горизонтале
-    //                                           ImPlotAxisFlags_NoHighlight, // не разобрался что это там подсвечивается, что-то с фоном оси
-    //                                           // по оси Y
-    //                                           ImPlotAxisFlags_AutoFit | // авто подстройка размера по вертикале
-    //                                           ImPlotAxisFlags_NoSideSwitch | 
-    //                                           ImPlotAxisFlags_NoHighlight | 
-    //                                           ImPlotAxisFlags_NoTickLabels // текстовые надписи отображаться не будут 
-    //                                         );
-    //
-    //       ImPlot::SetupAxisLimits(ImAxis_X1, 0.f, graph.m_render_data[0].size());
-    //       ImPlot::SetupAxisLimits(ImAxis_Y1, 0.f, graph.m_max_element);
-    //       ImPlot::SetupAxisLimitsConstraints(ImAxis_X1, 0, INFINITY);
-    //       ImPlot::SetupLegend(ImPlotLocation_NorthEast);
-    //
-    //
-    //       std::size_t index = 0;
-    //       for (auto& line : graph.m_render_data)
-    //       {
-    //         if (graph.m_type == utils::var::PLUGIN_TYPE::SEGMENTER)
-    //           ImPlot::PlotStems(VE_NAME(std::to_string(index)), graph.m_ox.data(), line.data(), line.size());
-    //         else
-    //           ImPlot::PlotLine(VE_NAME(std::to_string(index)), graph.m_ox.data(), line.data(), line.size());
-    //         ++index;
-    //       }
-    //
-    //       if (graph.m_type != utils::var::PLUGIN_TYPE::MAGNITUDE) m_markers.set_tag_show(false);
-    //       else m_markers.set_tag_show(true);
-    //
-    //       m_markers.render();
-    //
-    //       ImPlot::EndPlot();
-    //     }
-    //   }
-    //   ImPlot::EndSubplots();
-    // }
-    //
-    // is_first_render = false;
   }
 }

src/monitor/gui/components/snapshot/snapshot.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
 #include <VE.hpp>
-#include <harmonica.hpp>
 #include "monitor/utils/var.hpp"
+#include "monitor/utils/setup.hpp"
 #include "monitor/gui/components/base_plugins/base_plugins.hpp"
 #include "monitor/gui/components/base_controls/base_controls.hpp"
 
@@ -20,7 +20,7 @@ namespace monitor::components
     public:
       std::string m_snapshot_id;
       utils::var::STATUS m_status;
-      hr::setup m_setup;
+      utils::setup m_setup;
 
     private:
       ImVec2 m_size = { 0.f, 0.f };
@@ -49,6 +49,6 @@ namespace monitor::components
 
     public:
       void set_status(utils::var::STATUS s);
-      void init(hr::setup setup);
+      void init(utils::setup setup);
   };
 }

src/monitor/gui/components/tabs/cpp/base.cpp

@@ -6,6 +6,9 @@ namespace monitor::components
   void tabs::on_attach()
   {
     CONNECT(this);
+
+    hack::log().on_full_path();
+    hack::log().set_devider(" = ");
   }
 
   void tabs::on_detach()
@@ -22,7 +25,7 @@ namespace monitor::components
     for (auto & s : m_snapshots) s->update();
   }
 
-  void tabs::create_snapshot(hr::setup setup)
+  void tabs::create_snapshot(utils::setup setup)
   {
     auto s = std::make_shared<snapshot>();
     s->on_attach();
@@ -41,8 +44,12 @@ namespace monitor::components
     m_snapshots[i]->set_status(utils::var::STATUS::ACTIVE);
     m_current_open_index = i;
 
+    // send to: components/base_plugins
+    VE::event e0 { utils::event_type::PREPARE_BASE_PLUGIN_COMPRESSION,  m_snapshots[i]->m_snapshot_id };
+    EMIT(e0);
+
     // send to: components/audio
-    VE::event e { utils::event_type::CHANGE_AUDIO,  m_snapshots[i]->m_snapshot_id };
+    VE::event e1 { utils::event_type::CHANGE_AUDIO,  m_snapshots[i]->m_snapshot_id };
-    EMIT(e);
+    EMIT(e1);
   };
 }

src/monitor/gui/components/tabs/cpp/on_event.cpp

@@ -13,7 +13,7 @@ namespace monitor::components
       {
         case utils::event_type::CREATE_SNAPSHOT:
         {
-          auto data = std::any_cast<hr::setup>(e.m_data);
+          auto data = std::any_cast<utils::setup>(e.m_data);
           create_snapshot(data);
           break;
         }

src/monitor/gui/components/tabs/tabs.hpp

@@ -3,6 +3,7 @@
 #include <VE.hpp>
 #include <harmonica.hpp>
 #include "monitor/gui/components/snapshot/snapshot.hpp"
+#include "monitor/utils/setup.hpp"
 
 namespace monitor::components
 {
@@ -18,7 +19,7 @@ namespace monitor::components
       std::size_t m_current_open_index = 0;
 
     private:
-      void create_snapshot(hr::setup setup);
+      void create_snapshot(utils::setup setup);
       void change_tab(std::size_t i);
   };
 }

src/monitor/libs/audio/audio.cpp

@@ -15,7 +15,7 @@ namespace monitor::libs
     // сделать выбор устройства из интерфейса
     // поставь, то которое есть в списке устройств
     for (auto& d : devices) std::cout << d << std::endl;
-    std::string target_device = devices[2]; 
+    std::string target_device = devices[1]; 
     if (sf::PlaybackDevice::setDevice(target_device)) 
       hack::log()("Устройство успешно установлено: ", target_device);
     else 
@@ -25,7 +25,6 @@ namespace monitor::libs
   void audio::set_file(std::filesystem::path p)
   {
     if (!m_music.openFromFile(p)) hack::error()("dont open file:", p.string());
-    hack::log()("0", m_music.getDuration().asMicroseconds());
   }
 
   void audio::set_callback(std::function<void(sf::Time)> c)
@@ -58,7 +57,11 @@ namespace monitor::libs
 
   void audio::emit()
   {
-    while (is_playing()) m_callback(m_music.getPlayingOffset());
+    while (is_playing()) 
+    {
+      m_callback(m_music.getPlayingOffset());
+      sf::sleep(sf::milliseconds(20));
+    }
   }
 
   bool audio::is_playing()

src/monitor/utils/event_type.hpp

@@ -10,6 +10,9 @@ namespace monitor::utils
     STATUS_COMPLETED,
     INIT_AUDIO,
     CHANGE_AUDIO,
+    SET_COMPRESSION,
+    SET_MARKER_AUDIO_POSITION,
+    PREPARE_BASE_PLUGIN_COMPRESSION,
 
 
     /// делать
@@ -17,8 +20,6 @@ namespace monitor::utils
     AUDIO_PAUSE,
     AUDIO_STOP,
 
-    INCREMENT_MARKER_AUDIO_POSITION,
-    SET_MARKER_AUDIO_POSITION,
     SET_MARKER_MOUSE_POSITION
   };
 }

src/monitor/utils/plugin.hpp

@@ -44,80 +44,15 @@ namespace monitor::utils
       std::vector<hr::fvec_t> m_line_data;
 
       // говорит нужно ли делать сжатие графика ли нет
-      bool m_comporession = false;
+      bool m_compression = false;
 
       // шаг сжатия
-      std::size_t m_comporession_step = 0;
+      std::size_t m_compression_step = 0;
 
     public:
-      virtual bool empty() { return m_result.empty(); }
+      virtual bool empty() = 0;
-
+      virtual void init(hr::setup setup) = 0;
-      virtual void init()
+      virtual void fill() = 0;
-      {
+      virtual void set_ox(std::size_t start_pos = 0) = 0;
-        try
-        {
-          m_comporession = m_result.m_size > m_size;
-          if (!m_comporession) m_size = m_result.m_size;
-
-          m_line_count = m_result.m_data.size();
-          m_line_data.reserve(m_line_count);
-          for (std::size_t i = 0; i < m_line_count; ++i) m_line_data.push_back(hr::fvec_t(m_size, 0.f));
-
-          fill_ox();
-        }
-        catch(std::exception& e)
-        {
-          hack::error()(e.what());
-        }
-      }
-
-      virtual void fill_ox(std::size_t start_pos = 0)
-      {
-        m_ox.reserve(m_size);
-        for (std::size_t i = start_pos; i < m_size + start_pos; ++i) m_ox.push_back(i);
-      }
-
-      virtual void fill()
-      {
-        if (m_comporession)
-        {
-          m_comporession_step = m_result.m_size / m_size;
-
-          std::size_t line_count = 0;
-          for (auto& gd : m_line_data)
-          {
-            std::size_t bin_index = 0;
-            for (auto& g : gd)
-            {
-              float tmp_e = 0.f;
-              for (std::size_t j = bin_index - m_comporession_step; j < bin_index; ++j)
-              {
-                auto e = m_result.m_data[line_count][j].m_value;
-                tmp_e = hack::math::max_abs(e, tmp_e);
-              }
-              g = tmp_e;
-              bin_index += m_comporession_step;
-              if (bin_index >  m_result.m_size) bin_index = m_result.m_size;
-            }
-            m_size = bin_index / m_comporession_step;
-            hack::log()(m_comporession_step, m_size);
-            ++line_count;
-          }
-        }
-        else
-        {
-          std::size_t line_count = 0;
-          for (auto el : m_result.m_data)
-          {
-            std::size_t bin_index = 0;
-            for (auto e : el)
-            {
-              m_line_data[line_count][bin_index] = e.m_value;
-              ++bin_index;
-            }
-            ++line_count;
-          }
-        }
-      }
   };
 }

src/monitor/utils/plugins/fft.hpp

@@ -1,63 +0,0 @@
-#pragma once
-
-#include "monitor/utils/plugin.hpp"
-
-namespace monitor::utils::plugins
-{
-  struct fft : public plugin
-  {
-    fft() 
-    {    
-      m_type = plugin::TYPE::FFT;
-      m_display_name = "FFT"; 
-    }
-
-      virtual void init()
-      {
-        try
-        {
-          // тут просто берем из первой линии, первые данные, т.к это fft см. реализацию самого плагина в harmonica
-          auto raw_size = m_result.m_data[0][0].m_values.size();
-          if (raw_size == 0) throw std::invalid_argument("Error set data in plugin: empty data");
-
-          // m_is_scale = raw_size > var::MAX_RENDER_SIZE;
-          // m_size = std::min(raw_size, var::MAX_RENDER_SIZE);
-          m_line_count = m_result.m_data.size();
-          m_line_data.reserve(m_line_count);
-          m_ox.reserve(m_result.m_grad.size());
-          for (std::size_t i = 0; i < m_line_count; ++i) m_line_data.push_back(hr::fvec_t(m_size, 0.f));
-          fill_ox();
-        }
-        catch(std::exception& e)
-        {
-          hack::error()(e.what());
-        }
-      }
-
-      virtual void fill_ox(std::size_t start_pos = 0)
-      {
-        for (auto x : m_result.m_grad) m_ox.push_back(x);
-      }
-
-      // этот метод запускается один раз при первом рендеринге
-      // для заполнения начальными данными
-      virtual void fill()
-      {
-        if (m_comporession) hack::error()("Данных больше чем можем отрисовать на экране, см. что-то с масштабированием...");
-
-        std::size_t line_count = 0;
-        for (auto el : m_result.m_data)
-        {
-          std::size_t index = 0;
-          for (auto e : el)
-          {
-            m_line_data[line_count][index] = e.m_value;
-            ++index;
-          }
-          ++line_count;
-        }
-      }
-  };
-}
-
-

src/monitor/utils/plugins/fft/fft.cpp

@@ -0,0 +1,61 @@
+#include "fft.hpp"
+
+namespace monitor::utils::plugins
+{
+  fft::fft() 
+  {    
+    m_type = plugin::TYPE::FFT;
+    m_display_name = "FFT"; 
+  }
+
+  void fft::init(hr::setup setup)
+  {
+    try
+    {
+      // тут просто берем из первой линии, первые данные, т.к это fft см. реализацию самого плагина в harmonica
+      auto raw_size = m_result.m_data[0][0].m_values.size();
+      if (raw_size == 0) throw std::invalid_argument("Error set data in plugin: empty data");
+
+      // m_is_scale = raw_size > var::MAX_RENDER_SIZE;
+      // m_size = std::min(raw_size, var::MAX_RENDER_SIZE);
+      m_line_count = m_result.m_data.size();
+      m_line_data.reserve(m_line_count);
+      m_ox.reserve(m_result.m_grad.size());
+      for (std::size_t i = 0; i < m_line_count; ++i) m_line_data.push_back(hr::fvec_t(m_size, 0.f));
+      set_ox();
+    }
+    catch(std::exception& e)
+    {
+      hack::error()(e.what());
+    }
+  }
+
+  void fft::set_ox(std::size_t start_pos)
+  {
+    for (auto x : m_result.m_grad) m_ox.push_back(x);
+  }
+
+  void fft::fill()
+  {
+    if (m_compression) hack::error()("Данных больше чем можем отрисовать на экране, см. что-то с масштабированием...");
+
+    std::size_t line_count = 0;
+    for (auto el : m_result.m_data)
+    {
+      std::size_t index = 0;
+      for (auto e : el)
+      {
+        m_line_data[line_count][index] = e.m_value;
+        ++index;
+      }
+      ++line_count;
+    }
+  }
+
+  bool fft::empty() 
+  { 
+    return m_result.empty(); 
+  }
+}
+
+

src/monitor/utils/plugins/fft/fft.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "monitor/utils/plugin.hpp"
+
+namespace monitor::utils::plugins
+{
+  struct fft : public plugin
+  {
+    fft();
+    ~fft() = default;
+
+    void init(hr::setup setup) override;
+    void set_ox(std::size_t start_pos = 0) override;
+    void fill() override;
+    bool empty() override;
+  };
+}
+
+

src/monitor/utils/plugins/magnitude.hpp

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "monitor/utils/plugin.hpp"
-
-namespace monitor::utils::plugins
-{
-  struct magnitude : public plugin
-  {
-    magnitude() 
-    {    
-      m_type = plugin::TYPE::MAGNITUDE;
-      m_display_name = "Magnitude"; 
-    }
-  };
-}
-
-

src/monitor/utils/plugins/magnitude/magnitude.cpp

@@ -0,0 +1,56 @@
+#include "magnitude.hpp"
+
+namespace monitor::utils::plugins
+{
+  magnitude::magnitude() 
+  {    
+    m_type = plugin::TYPE::MAGNITUDE;
+    m_display_name = "Magnitude"; 
+  }
+
+  void magnitude::init(hr::setup setup)
+  {
+    try
+    {
+      m_size = m_result.m_size;
+      m_compression_step = setup.m_step_size;
+      m_line_count = m_result.m_data.size();
+      m_line_data.reserve(m_line_count);
+      for (std::size_t i = 0; i < m_line_count; ++i) m_line_data.push_back(hr::fvec_t(m_size, 0.f));
+
+      set_ox();
+    }
+    catch(std::exception& e)
+    {
+      hack::error()(e.what());
+    }
+  }
+
+  void magnitude::fill()
+  {
+    std::size_t line_count = 0;
+    for (auto el : m_result.m_data)
+    {
+      std::size_t bin_index = 0;
+      for (auto e : el)
+      {
+        m_line_data[line_count][bin_index] = e.m_value;
+        ++bin_index;
+      }
+      ++line_count;
+    }
+  }
+
+  void magnitude::set_ox(std::size_t start_pos)
+  {
+    m_ox.reserve(m_size);
+    for (std::size_t i = start_pos; i < m_size + start_pos; ++i) m_ox.push_back(i);
+  }
+  
+  bool magnitude::empty() 
+  { 
+    return m_result.empty(); 
+  }
+}
+
+

src/monitor/utils/plugins/magnitude/magnitude.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "monitor/utils/plugin.hpp"
+
+namespace monitor::utils::plugins
+{
+  struct magnitude : public plugin
+  {
+    magnitude();
+    ~magnitude() = default;
+
+    void init(hr::setup setup) override;
+    void fill() override;
+    void set_ox(std::size_t start_pos = 0) override;
+    bool empty() override;
+  };
+}
+
+

src/monitor/utils/plugins/raw_data.hpp

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "monitor/utils/plugin.hpp"
-
-namespace monitor::utils::plugins
-{
-  struct raw_data : public plugin
-  {
-    raw_data() 
-    {    
-      m_type = plugin::TYPE::RAW_DATA;
-      m_display_name = "Raw Data"; 
-    }
-  };
-}
-
-

src/monitor/utils/plugins/raw_data/raw_data.cpp

@@ -0,0 +1,82 @@
+#include "raw_data.hpp"
+
+namespace monitor::utils::plugins
+{
+  raw_data::raw_data() 
+  {    
+    m_type = plugin::TYPE::RAW_DATA;
+    m_display_name = "Raw Data"; 
+  }
+
+  void raw_data::init(hr::setup setup)
+  {
+    try
+    {
+      m_compression = m_result.m_size > m_size;
+      if (!m_compression) m_size = m_result.m_size;
+
+      m_line_count = m_result.m_data.size();
+      m_line_data.reserve(m_line_count);
+      for (std::size_t i = 0; i < m_line_count; ++i) m_line_data.push_back(hr::fvec_t(m_size, 0.f));
+
+      set_ox();
+    }
+    catch(std::exception& e)
+    {
+      hack::error()(e.what());
+    }
+  }
+
+  void raw_data::fill()
+  {
+    if (m_compression)
+    {
+      m_compression_step = m_result.m_size / m_size + 1;
+
+      std::size_t line_count = 0;
+      for (auto& gd : m_line_data)
+      {
+        std::size_t bin_index = 0;
+        for (auto& g : gd)
+        {
+          float tmp_e = 0.f;
+          for (std::size_t j = bin_index - m_compression_step; j < bin_index; ++j)
+          {
+            auto e = m_result.m_data[line_count][j].m_value;
+            tmp_e = hack::math::max_abs(e, tmp_e);
+          }
+          g = tmp_e;
+          bin_index += m_compression_step;
+          if (bin_index >  m_result.m_size) bin_index = m_result.m_size;
+        }
+        m_size = bin_index / m_compression_step;
+        ++line_count;
+      }
+    }
+    else
+    {
+      std::size_t line_count = 0;
+      for (auto el : m_result.m_data)
+      {
+        std::size_t bin_index = 0;
+        for (auto e : el)
+        {
+          m_line_data[line_count][bin_index] = e.m_value;
+          ++bin_index;
+        }
+        ++line_count;
+      }
+    }
+  }
+
+  void raw_data::set_ox(std::size_t start_pos)
+  {
+    m_ox.reserve(m_size);
+    for (std::size_t i = start_pos; i < m_size + start_pos; ++i) m_ox.push_back(i);
+  }
+
+  bool raw_data::empty() 
+  { 
+    return m_result.empty(); 
+  }
+}

src/monitor/utils/plugins/raw_data/raw_data.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "monitor/utils/plugin.hpp"
+
+namespace monitor::utils::plugins
+{
+  struct raw_data : public plugin
+  {
+    raw_data(); 
+    ~raw_data() = default;
+
+    void init(hr::setup setup) override;
+    void fill() override;
+    void set_ox(std::size_t start_pos = 0) override;
+    bool empty() override;
+  };
+}
+
+

src/monitor/utils/setup.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <harmonica.hpp>
+
+namespace monitor::utils
+{
+  struct setup : public hr::setup
+  {
+    // // это меняющеесе значение в зависимости от плагина, а не 
+    // // как может показаться от аудио файла
+    // std::size_t m_graph_compression = 0;
+  };
+}
+