remove old func for compression

plugin.hpp

@@ -1,187 +0,0 @@
-#pragma once
-
-#include "monitor/utils/plugins/plugin.hpp"
-
-namespace monitor::utils
-{
-  struct raw_plugin : public plugin
-  {
-    public:
-      enum class TYPE
-      {
-        RAW_DATA,
-        MAGNITUDE,
-        ENERGY
-      };
-
-    public:
-      hr::result m_result;
-      TYPE m_type;
-      std::string m_display_name;
-
-    public:
-      struct graph
-      {
-        public:
-          // градуировка осьи X
-          hr::fvec_t m_ox;
-          // максимальное значение по оси Y
-          double m_max_element = 0.0;
-          // размер данных дял отрисовки
-          std::size_t m_size = 0;
-          // кол-во линий графика
-          std::size_t m_line_count = 0;
-          // тут кол-во графиков на массив данных из этих графиков т.е.:
-          // [1] = [1, 2, ..., 1'000'000'000]
-          // [2] = [1, 2, ..., 1'000'000'000]
-          std::vector<hr::fvec_t> m_data;
-          // говорит нужно ли делать сжатие графика ли нет
-          bool m_is_scale = false;
-
-          void fill_ox(std::size_t start_pos = 0)
-          {
-            m_ox.clear();
-            for (std::size_t i = start_pos; i < start_pos + m_size; ++i) m_ox.push_back(i);
-          }
-
-          void init()
-          {
-            m_data.reserve(m_line_count);
-            m_ox.reserve(m_size);
-            for (std::size_t i = 0; i < m_line_count; ++i) m_data.push_back(hr::fvec_t(m_size, 0.f));
-          }
-
-      } m_graph;
-
-    public:
-      bool empty() { return m_result.empty(); }
-
-      void graph_init()
-      {
-        try
-        {
-          auto raw_size = m_result.size();
-          if (raw_size == 0) throw std::invalid_argument("Error set data in plugin: empty data");
-
-          m_graph.m_is_scale = raw_size > var::MAX_RENDER_SIZE;
-          m_graph.m_size = std::min(raw_size, var::MAX_RENDER_SIZE);
-          m_graph.m_line_count = m_result.m_data.size();
-          m_graph.init();
-          m_graph.fill_ox();
-        }
-        catch(std::exception& e)
-        {
-          hack::error()(e.what());
-        }
-      }
-
-      // этот метод запускается один раз при первом рендеринге
-      // для заполнения начальными данными
-      void fill()
-      {
-        if (m_graph.m_is_scale)
-        {
-          m_step = m_result.size() / m_graph.m_size + 1;
-
-          std::size_t line_count = 0;
-          for (auto& gd : m_graph.m_data)
-          {
-            std::size_t index = 0;
-            for (auto& g : gd)
-            {
-              float tmp_e = 0.f;
-              for (std::size_t j = index - m_step; j < 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;
-              m_graph.m_max_element = std::fabs(hack::math::max_abs(g, m_graph.m_max_element));
-
-              index += m_step;
-              if (index >  m_result.size()) index = m_result.size();
-            }
-            ++line_count;
-          }
-        }
-        else
-        {
-          // заполняется, когда данных пришло меньше чем нужно для полного рендеринга
-          std::size_t graph_count = 0;
-          for (auto el : m_result.m_data)
-          {
-            std::size_t index = 0;
-            for (auto e : el)
-            {
-              m_graph.m_max_element = hack::math::max(e.m_value, m_graph.m_max_element);
-              m_graph.m_data[graph_count][index] = e.m_value;
-              ++index;
-            }
-            ++graph_count;
-          }
-        }
-      }
-
-      std::size_t m_local_k2 = 0;
-      std::size_t m_step;
-
-      bool is_scale()
-      {
-        return m_graph.m_is_scale;
-      }
-
-      // Это основной меод вычисления данных, которые нужно отрисовать
-      // 1. Проверяем размер сырых данных
-      // - если их больше чем var::MAX_RENDER_SIZE, то делаем сжатие
-      // - если их меньше, то отрисовка идет полностью и fill_ox уже заполнен так как надо и при масштабировании ни чего не пересчитывается is_scale
-      void fill(ImPlotRect current_limits)
-      {
-        // кол-во данных, которые мы сейчас хотим отрисовать, когда поменяли масштаб
-        auto total_dots_for_render = current_limits.Size().x;
-        // тоже, что начальный m_step, но если m_step меняется, то этот постоянный
-        // т.е. это максимальный коефиниент сужения графика
-        std::size_t k1 = m_result.size() / m_graph.m_size + 1;
-        // на сколько изменилось кол-во точек, которые нужно отрисовать
-        std::size_t k2 = var::MAX_RENDER_SIZE / total_dots_for_render - 1.f;
-
-        // стэк условий, котолрые ограничивают лишние расчеты и сохраняют текущие данные
-        if (k1 <= k2 && k2 != 0) return;
-        if (m_local_k2 == k2 && k2 != 0) return;
-        m_local_k2 = k2;
-
-        // сколько сместилось точке отрисовки во время масштабирования за экран (влево)
-        std::size_t skip_dots = current_limits.Min().x;
-        // кол-во точек, которые нужно пропустить из сырых данных чтобы они не были отрисованы во время масштабирования
-        std::size_t pos = skip_dots * (m_step + k2);
-        // шаг пропуска, по которому делаем сужение графика
-        m_step = k1 - k2;
-        
-        std::size_t line_count = 0;
-        for (auto& gd : m_graph.m_data)
-        {
-          std::size_t index = pos;
-          for (auto& g : gd)
-          {
-            float tmp_e = 0.f;
-            for (std::size_t j = index - m_step; j < index; ++j)
-            {
-              auto e = m_result.m_data[line_count][j].m_value;
-              // основной критерий сужения: берем максимальный элемент из данного интервала m_step
-              tmp_e = hack::math::max_abs(e, tmp_e);
-            }
-            g = tmp_e;
-            m_graph.m_max_element = std::fabs(hack::math::max_abs(g, m_graph.m_max_element));
-
-            index += m_step;
-            if (index >  m_result.size()) index = m_result.size();
-          }
-          ++line_count;
-        }
-
-        // нужно передать смещение для установки градации
-        m_graph.fill_ox(skip_dots);
-      }
-  };
-}
-
-

plugin.t.hpp

@@ -1,187 +0,0 @@
-#pragma once
-
-#include "monitor/utils/plugins/plugin.hpp"
-
-namespace monitor::utils
-{
-  struct raw_plugin : public plugin
-  {
-    public:
-      enum class TYPE
-      {
-        RAW_DATA,
-        MAGNITUDE,
-        ENERGY
-      };
-
-    public:
-      hr::result m_result;
-      TYPE m_type;
-      std::string m_display_name;
-
-    public:
-      struct graph
-      {
-        public:
-          // градуировка осьи X
-          hr::fvec_t m_ox;
-          // максимальное значение по оси Y
-          double m_max_element = 0.0;
-          // размер данных дял отрисовки
-          std::size_t m_size = 0;
-          // кол-во линий графика
-          std::size_t m_line_count = 0;
-          // тут кол-во графиков на массив данных из этих графиков т.е.:
-          // [1] = [1, 2, ..., 1'000'000'000]
-          // [2] = [1, 2, ..., 1'000'000'000]
-          std::vector<hr::fvec_t> m_data;
-          // говорит нужно ли делать сжатие графика ли нет
-          bool m_is_scale = false;
-
-          void fill_ox(std::size_t start_pos = 0)
-          {
-            m_ox.clear();
-            for (std::size_t i = start_pos; i < start_pos + m_size; ++i) m_ox.push_back(i);
-          }
-
-          void init()
-          {
-            m_data.reserve(m_line_count);
-            m_ox.reserve(m_size);
-            for (std::size_t i = 0; i < m_line_count; ++i) m_data.push_back(hr::fvec_t(m_size, 0.f));
-          }
-
-      } m_graph;
-
-    public:
-      bool empty() { return m_result.empty(); }
-
-      void graph_init()
-      {
-        try
-        {
-          auto raw_size = m_result.size();
-          if (raw_size == 0) throw std::invalid_argument("Error set data in plugin: empty data");
-
-          m_graph.m_is_scale = raw_size > var::MAX_RENDER_SIZE;
-          m_graph.m_size = std::min(raw_size, var::MAX_RENDER_SIZE);
-          m_graph.m_line_count = m_result.m_data.size();
-          m_graph.init();
-          m_graph.fill_ox();
-        }
-        catch(std::exception& e)
-        {
-          hack::error()(e.what());
-        }
-      }
-
-      // этот метод запускается один раз при первом рендеринге
-      // для заполнения начальными данными
-      void fill()
-      {
-        if (m_graph.m_is_scale)
-        {
-          m_step = m_result.size() / m_graph.m_size + 1;
-
-          std::size_t line_count = 0;
-          for (auto& gd : m_graph.m_data)
-          {
-            std::size_t index = 0;
-            for (auto& g : gd)
-            {
-              float tmp_e = 0.f;
-              for (std::size_t j = index - m_step; j < 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;
-              m_graph.m_max_element = std::fabs(hack::math::max_abs(g, m_graph.m_max_element));
-
-              index += m_step;
-              if (index >  m_result.size()) index = m_result.size();
-            }
-            ++line_count;
-          }
-        }
-        else
-        {
-          // заполняется, когда данных пришло меньше чем нужно для полного рендеринга
-          std::size_t graph_count = 0;
-          for (auto el : m_result.m_data)
-          {
-            std::size_t index = 0;
-            for (auto e : el)
-            {
-              m_graph.m_max_element = hack::math::max(e.m_value, m_graph.m_max_element);
-              m_graph.m_data[graph_count][index] = e.m_value;
-              ++index;
-            }
-            ++graph_count;
-          }
-        }
-      }
-
-      std::size_t m_local_k2 = 0;
-      std::size_t m_step;
-
-      bool is_scale()
-      {
-        return m_graph.m_is_scale;
-      }
-
-      // Это основной меод вычисления данных, которые нужно отрисовать
-      // 1. Проверяем размер сырых данных
-      // - если их больше чем var::MAX_RENDER_SIZE, то делаем сжатие
-      // - если их меньше, то отрисовка идет полностью и fill_ox уже заполнен так как надо и при масштабировании ни чего не пересчитывается is_scale
-      void fill(ImPlotRect current_limits)
-      {
-        // кол-во данных, которые мы сейчас хотим отрисовать, когда поменяли масштаб
-        auto total_dots_for_render = current_limits.Size().x;
-        // тоже, что начальный m_step, но если m_step меняется, то этот постоянный
-        // т.е. это максимальный коефиниент сужения графика
-        std::size_t k1 = m_result.size() / m_graph.m_size + 1;
-        // на сколько изменилось кол-во точек, которые нужно отрисовать
-        std::size_t k2 = var::MAX_RENDER_SIZE / total_dots_for_render - 1.f;
-
-        // стэк условий, котолрые ограничивают лишние расчеты и сохраняют текущие данные
-        if (k1 <= k2 && k2 != 0) return;
-        if (m_local_k2 == k2 && k2 != 0) return;
-        m_local_k2 = k2;
-
-        // сколько сместилось точке отрисовки во время масштабирования за экран (влево)
-        std::size_t skip_dots = current_limits.Min().x;
-        // кол-во точек, которые нужно пропустить из сырых данных чтобы они не были отрисованы во время масштабирования
-        std::size_t pos = skip_dots * (m_step + k2);
-        // шаг пропуска, по которому делаем сужение графика
-        m_step = k1 - k2;
-        
-        std::size_t line_count = 0;
-        for (auto& gd : m_graph.m_data)
-        {
-          std::size_t index = pos;
-          for (auto& g : gd)
-          {
-            float tmp_e = 0.f;
-            for (std::size_t j = index - m_step; j < index; ++j)
-            {
-              auto e = m_result.m_data[line_count][j].m_value;
-              // основной критерий сужения: берем максимальный элемент из данного интервала m_step
-              tmp_e = hack::math::max_abs(e, tmp_e);
-            }
-            g = tmp_e;
-            m_graph.m_max_element = std::fabs(hack::math::max_abs(g, m_graph.m_max_element));
-
-            index += m_step;
-            if (index >  m_result.size()) index = m_result.size();
-          }
-          ++line_count;
-        }
-
-        // нужно передать смещение для установки градации
-        m_graph.fill_ox(skip_dots);
-      }
-  };
-}
-
-

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

@@ -21,7 +21,7 @@ namespace monitor::components
 
     private:
       graph m_graph;
-      // fft_scaled m_fft_scaled;
+      fft_scaled m_fft_scaled;
 
     private:
       hr::setup m_setup;

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

@@ -9,7 +9,7 @@ namespace monitor::components
     CONNECT(this);
 
     m_graph.on_attach();
-    // m_fft_scaled.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::plugin>(utils::plugins::magnitude{}));
@@ -22,13 +22,13 @@ namespace monitor::components
   {
     DISCONNECT();
     m_graph.on_detach();
-    // m_fft_scaled.on_detach();
+    m_fft_scaled.on_detach();
   }
 
   void base_plugins::update() 
   {
     m_graph.update();
-    // m_fft_scaled.update();
+    m_fft_scaled.update();
   }
   
   void base_plugins::init(std::string snapshot_id, hr::setup setup)

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

@@ -31,7 +31,7 @@ namespace monitor::components
       ImGui::EndTabBar();
     }
 
-    // m_fft_scaled.render();
+    m_fft_scaled.render();
 
     utils::func::draw_border(m_size);
 

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

@@ -5,6 +5,8 @@ namespace monitor::components
   void fft_scaled::on_attach()
   {
     CONNECT(this);
+    m_size.x = VE::application::get()->get_glfw()->width() - VE::application::get()->get_glfw()->width() / 4.f;
+    m_fft_size = ImVec2(m_size.x / 3.f - 6.f, 0.f);
   }
 
   void fft_scaled::on_detach()
@@ -22,8 +24,8 @@ namespace monitor::components
     m_setup = setup;
     m_setup.m_domain = hr::DOMAIN_PLUGIN::FREQUENSY;
     m_plugin.m_result = hr::run<hr::plugins::fft>(m_setup);
-    m_plugin.init();
+    // m_plugin.init();
-    m_plugin.fill();
+    // m_plugin.fill();
   }
 }
 

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

@@ -4,7 +4,61 @@ namespace monitor::components
 {
   void fft_scaled::render()
   {
-    if (ImPlot::BeginPlot(VE_NO_NAME(m_plugin.m_display_name + m_snapshot_id), ImVec2(-1, 0), ImPlotFlags_NoMenus)) 
+    if (ImPlot::BeginPlot(VE_NO_NAME(m_plugin.m_display_name + m_snapshot_id + "0"), m_fft_size, ImPlotFlags_NoMenus)) 
+    {
+                                          // по оси X
+      ImPlot::SetupAxes(nullptr, nullptr, ImPlotAxisFlags_Opposite |  // смена полюсов у надписей оси x. они вверху
+                                          ImPlotAxisFlags_NoSideSwitch | // нельзя перетаскивать оси по сторонам
+                                          (m_is_first_render ? ImPlotAxisFlags_AutoFit : ImPlotAxisFlags_None) | // авто подстройка размера по горизонтале
+                                          ImPlotAxisFlags_NoHighlight, // не разобрался что это там подсвечивается, что-то с фоном оси
+                                          // по оси Y
+                                          ImPlotAxisFlags_AutoFit | // авто подстройка размера по вертикале
+                                          ImPlotAxisFlags_NoSideSwitch | 
+                                          ImPlotAxisFlags_NoHighlight | 
+                                          ImPlotAxisFlags_NoTickLabels // текстовые надписи отображаться не будут 
+                                        );
+
+      // ImPlot::SetupAxisLimits(ImAxis_X1, 0.f, m_plugin.m_graph.m_size);
+      // ImPlot::SetupAxisLimits(ImAxis_Y1, 0.f, m_plugin.m_graph.m_max_element + 2.f);
+      // ImPlot::SetupAxisLimitsConstraints(ImAxis_X1, 0, INFINITY);
+      // ImPlot::SetupLegend(ImPlotLocation_NorthEast);
+      //
+      // ImPlot::PlotStems(VE_NAME("fft_scaled" + m_snapshot_id), m_plugin.m_graph.m_ox.data(), m_plugin.m_graph.m_data[0].data(), m_plugin.m_graph.m_data[0].size());
+
+      m_is_first_render = false;
+      ImPlot::EndPlot();
+    }
+
+    ImGui::SameLine();
+
+    if (ImPlot::BeginPlot(VE_NO_NAME(m_plugin.m_display_name + m_snapshot_id + "1"), m_fft_size, ImPlotFlags_NoMenus)) 
+    {
+                                          // по оси X
+      ImPlot::SetupAxes(nullptr, nullptr, ImPlotAxisFlags_Opposite |  // смена полюсов у надписей оси x. они вверху
+                                          ImPlotAxisFlags_NoSideSwitch | // нельзя перетаскивать оси по сторонам
+                                          (m_is_first_render ? ImPlotAxisFlags_AutoFit : ImPlotAxisFlags_None) | // авто подстройка размера по горизонтале
+                                          ImPlotAxisFlags_NoHighlight, // не разобрался что это там подсвечивается, что-то с фоном оси
+                                          // по оси Y
+                                          ImPlotAxisFlags_AutoFit | // авто подстройка размера по вертикале
+                                          ImPlotAxisFlags_NoSideSwitch | 
+                                          ImPlotAxisFlags_NoHighlight | 
+                                          ImPlotAxisFlags_NoTickLabels // текстовые надписи отображаться не будут 
+                                        );
+
+      // ImPlot::SetupAxisLimits(ImAxis_X1, 0.f, m_plugin.m_graph.m_size);
+      // ImPlot::SetupAxisLimits(ImAxis_Y1, 0.f, m_plugin.m_graph.m_max_element + 2.f);
+      // ImPlot::SetupAxisLimitsConstraints(ImAxis_X1, 0, INFINITY);
+      // ImPlot::SetupLegend(ImPlotLocation_NorthEast);
+      //
+      // ImPlot::PlotStems(VE_NAME("fft_scaled" + m_snapshot_id), m_plugin.m_graph.m_ox.data(), m_plugin.m_graph.m_data[0].data(), m_plugin.m_graph.m_data[0].size());
+
+      m_is_first_render = false;
+      ImPlot::EndPlot();
+    }
+
+    ImGui::SameLine();
+
+    if (ImPlot::BeginPlot(VE_NO_NAME(m_plugin.m_display_name + m_snapshot_id + "2"), m_fft_size, ImPlotFlags_NoMenus)) 
     {
                                           // по оси X
       ImPlot::SetupAxes(nullptr, nullptr, ImPlotAxisFlags_Opposite |  // смена полюсов у надписей оси x. они вверху

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

@@ -13,6 +13,7 @@ namespace monitor::components
       
     private:
       ImVec2 m_size = { 0.f, 0.f };
+      ImVec2 m_fft_size;
       ImGuiTabBarFlags m_tab_bar_flags { ImGuiTabBarFlags_None };
       ImPlotRect m_current_limits;
       bool m_is_first_render = true;

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

@@ -55,16 +55,4 @@ namespace monitor::components
       }
     }
   }
-
-  void graph::refresh(ImPlotRect current_limits)
-  {
-    if (!m_plugin->is_scale()) return;
-    if (m_current_limits.Min().x != current_limits.Min().x)
-    {
-      m_current_limits = current_limits;
-      m_plugin->refresh(m_current_limits);
 }
-  }
-}
-
-

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

@@ -19,12 +19,10 @@ namespace monitor::components
                                         );
 
       ImPlot::SetupAxisLimits(ImAxis_X1, 0.f, m_plugin->m_size);
-      ImPlot::SetupAxisLimits(ImAxis_Y1, 0.f, m_plugin->m_result.m_max + 2.f);
+      ImPlot::SetupAxisLimits(ImAxis_Y1, 0.f, m_plugin->m_result.m_max + m_plugin->m_result.m_max * 0.1);
       ImPlot::SetupAxisLimitsConstraints(ImAxis_X1, 0, INFINITY);
       ImPlot::SetupLegend(ImPlotLocation_NorthEast);
 
-      refresh(ImPlot::GetPlotLimits());
-
       for (std::size_t i = 0; i < m_plugin->m_line_count; ++i)
       {
         if (m_plugin->m_type == utils::plugin::TYPE::ENERGY)

src/monitor/gui/components/graph/graph.hpp

@@ -21,9 +21,6 @@ namespace monitor::components
       void init(std::string snapshot_id, hr::setup setup);
       void set_plugin(std::shared_ptr<utils::plugin> plugin) noexcept;
 
-    private:
-      void refresh(ImPlotRect current_limits);
-
     private:
       std::shared_ptr<utils::plugin> m_plugin;
       hr::setup m_setup;

src/monitor/utils/plugin.hpp

@@ -2,6 +2,7 @@
 
 #include <VE.hpp>
 #include <harmonica.hpp>
+#include <math.h>
 #include "monitor/utils/var.hpp"
 
 namespace monitor::utils
@@ -24,22 +25,29 @@ namespace monitor::utils
     public:
       hr::result m_result;
       TYPE m_type;
+      std::string m_display_name;
 
     public:
       // градуировка осьи X
       hr::fvec_t m_ox;
-      // размер данных для отрисовки
+
-      std::size_t m_size = 0;
+      // размер данных для отрисовки. уситанавливает размер графика
+      // штука плавающая в зависимости от масштаба
+      std::size_t m_size = utils::var::MAX_RENDER_SIZE;
+
       // кол-во линий графика
       std::size_t m_line_count = 0;
+
       // тут кол-во графиков на массив данных из этих графиков т.е.:
       // [1] = [1, 2, ..., 1'000'000'000]
       // [2] = [1, 2, ..., 1'000'000'000]
       std::vector<hr::fvec_t> m_line_data;
+
       // говорит нужно ли делать сжатие графика ли нет
       bool m_is_scale = false;
-      std::string m_display_name;
+
       std::size_t m_step = 0;
+
       // это кол-во точек, которые нужно отрисовать с учетом текущего масштаба но в прошлом шаге
       std::size_t m_past_k2 = 0;
 
@@ -50,15 +58,16 @@ namespace monitor::utils
       {
         try
         {
-          auto raw_size = m_result.m_size;
+          auto raw_data_size = m_result.m_size;
-          if (raw_size == 0) throw std::invalid_argument("Error set data in plugin: empty data");
+          if (raw_data_size == 0) throw std::invalid_argument("Error set data in plugin: empty data");
+
+          m_is_scale = raw_data_size > m_size;
 
-          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_size);
           for (std::size_t i = 0; i < m_line_count; ++i) m_line_data.push_back(hr::fvec_t(m_size, 0.f));
+
+          m_ox.reserve(m_size);
           fill_ox();
         }
         catch(std::exception& e)
@@ -84,18 +93,18 @@ namespace monitor::utils
           std::size_t line_count = 0;
           for (auto& gd : m_line_data)
           {
-            std::size_t index = 0;
+            std::size_t bin_index = 0;
             for (auto& g : gd)
             {
               float tmp_e = 0.f;
-              for (std::size_t j = index - m_step; j < index; ++j)
+              for (std::size_t j = bin_index - m_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;
-              index += m_step;
+              bin_index += m_step;
-              if (index >  m_result.m_size) index = m_result.m_size;
+              if (bin_index >  m_result.m_size) bin_index = m_result.m_size;
             }
             ++line_count;
           }
@@ -106,71 +115,15 @@ namespace monitor::utils
           std::size_t line_count = 0;
           for (auto el : m_result.m_data)
           {
-            std::size_t index = 0;
+            std::size_t bin_index = 0;
             for (auto e : el)
             {
-              m_line_data[line_count][index] = e.m_value;
+              m_line_data[line_count][bin_index] = e.m_value;
-              ++index;
+              ++bin_index;
             }
             ++line_count;
           }
         }
       }
-
-      virtual bool is_scale()
-      {
-        return m_is_scale;
-      }
-
-      // Это метод вычисления данных, которые нужно отрисовать, приизменении масштаба
-      // 1. Проверяем размер сырых данных
-      // - если их больше чем var::MAX_RENDER_SIZE, то делаем сжатие
-      // - если их меньше, то отрисовка идет полностью и fill_ox уже заполнен так как надо и при масштабировании ни чего не пересчитывается is_scale
-      virtual void refresh(ImPlotRect current_limits)
-      {
-        // кол-во данных, которые мы сейчас хотим отрисовать, когда поменяли масштаб
-        auto total_dots_for_render = current_limits.Size().x;
-        // тоже, что начальный m_step, но если m_step меняется, то этот постоянный
-        // т.е. это максимальный коефициент сужения графика
-        std::size_t k1 = m_result.m_size / m_size + 1;
-        // на сколько изменилось кол-во точек, которые нужно отрисовать
-        std::size_t k2 = var::MAX_RENDER_SIZE / total_dots_for_render - 1.f;
-
-        // стэк условий, которые ограничивают лишние расчеты и сохраняют текущие данные
-        if (k1 <= k2 && k2 != 0) return;
-        if (m_past_k2 == k2 && k2 != 0) return;
-        m_past_k2 = k2;
-
-        // сколько сместилось точке отрисовки во время масштабирования за экран (влево)
-        std::size_t skip_dots = current_limits.Min().x;
-        // кол-во точек, которые нужно пропустить из сырых данных чтобы они не были отрисованы во время масштабирования
-        std::size_t pos = skip_dots * (m_step + k2);
-        // шаг пропуска, по которому делаем сужение графика
-        m_step = k1 - k2;
-        
-        std::size_t line_count = 0;
-        for (auto& gd : m_line_data)
-        {
-          std::size_t index = pos;
-          for (auto& g : gd)
-          {
-            float tmp_e = 0.f;
-            for (std::size_t j = index - m_step; j < index; ++j)
-            {
-              auto e = m_result.m_data[line_count][j].m_value;
-              // основной критерий сужения: берем максимальный элемент из данного интервала m_step
-              tmp_e = hack::math::max_abs(e, tmp_e);
-            }
-            g = tmp_e;
-            index += m_step;
-            if (index >  m_result.m_size) index = m_result.m_size;
-          }
-          ++line_count;
-        }
-
-        // нужно передать смещение для установки градации
-        fill_ox(skip_dots);
-      }
   };
 }
-

src/monitor/utils/plugins/fft.hpp

@@ -20,8 +20,8 @@ namespace monitor::utils::plugins
           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_is_scale = raw_size > var::MAX_RENDER_SIZE;
-          m_size = std::min(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());
@@ -57,62 +57,6 @@ namespace monitor::utils::plugins
           ++line_count;
         }
       }
-
-      virtual bool is_scale()
-      {
-        return m_is_scale;
-      }
-
-      // Это метод вычисления данных, которые нужно отрисовать, приизменении масштаба
-      // 1. Проверяем размер сырых данных
-      // - если их больше чем var::MAX_RENDER_SIZE, то делаем сжатие
-      // - если их меньше, то отрисовка идет полностью и fill_ox уже заполнен так как надо и при масштабировании ни чего не пересчитывается is_scale
-      virtual void refresh(ImPlotRect current_limits)
-      {
-        // кол-во данных, которые мы сейчас хотим отрисовать, когда поменяли масштаб
-        auto total_dots_for_render = current_limits.Size().x;
-        // тоже, что начальный m_step, но если m_step меняется, то этот постоянный
-        // т.е. это максимальный коефиниент сужения графика
-        std::size_t k1 = m_result.m_size / m_size + 1;
-        // на сколько изменилось кол-во точек, которые нужно отрисовать
-        std::size_t k2 = var::MAX_RENDER_SIZE / total_dots_for_render - 1.f;
-
-        // стэк условий, котолрые ограничивают лишние расчеты и сохраняют текущие данные
-        if (k1 <= k2 && k2 != 0) return;
-        if (m_past_k2 == k2 && k2 != 0) return;
-        m_past_k2 = k2;
-
-        // сколько сместилось точке отрисовки во время масштабирования за экран (влево)
-        std::size_t skip_dots = current_limits.Min().x;
-        // кол-во точек, которые нужно пропустить из сырых данных чтобы они не были отрисованы во время масштабирования
-        std::size_t pos = skip_dots * (m_step + k2);
-        // шаг пропуска, по которому делаем сужение графика
-        m_step = k1 - k2;
-        
-        std::size_t line_count = 0;
-        for (auto& gd : m_line_data)
-        {
-          std::size_t index = pos;
-          for (auto& g : gd)
-          {
-            float tmp_e = 0.f;
-            for (std::size_t j = index - m_step; j < index; ++j)
-            {
-              auto e = m_result.m_data[line_count][j].m_value;
-              // основной критерий сужения: берем максимальный элемент из данного интервала m_step
-              tmp_e = hack::math::max_abs(e, tmp_e);
-            }
-            g = tmp_e;
-
-            index += m_step;
-            if (index >  m_result.m_size) index = m_result.m_size;
-          }
-          ++line_count;
-        }
-
-        // нужно передать смещение для установки градации
-        fill_ox(skip_dots);
-      }
   };
 }