chatlanin/monitor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove old func for compression

Browse Source
This commit is contained in:
Андрей Зимин
2026-03-27 12:52:23 +03:00
parent cfa39f850b
commit c049455a88
13 changed files with 92 additions and 529 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
plugin.hpp
View File

@@ -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);
}
};
}

187
plugin.t.hpp
View File

@@ -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);
}
};
}

2
src/monitor/gui/components/base_plugins/base_plugins.hpp
View File

@@ -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;

6
src/monitor/gui/components/base_plugins/cpp/base.cpp
View File

@@ -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)

2
src/monitor/gui/components/base_plugins/cpp/render.cpp
View File

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

6
src/monitor/gui/components/fft_scaled/cpp/base.cpp
View File

@@ -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.fill();
// m_plugin.init();
// m_plugin.fill();
}
}

56
src/monitor/gui/components/fft_scaled/cpp/render.cpp
View File

@@ -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. они вверху

1
src/monitor/gui/components/fft_scaled/fft_scaled.hpp
View File

@@ -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;

12
src/monitor/gui/components/graph/cpp/base.cpp
View File

@@ -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);
}
}
}

4
src/monitor/gui/components/graph/cpp/render.cpp
View File

@@ -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)

3
src/monitor/gui/components/graph/graph.hpp
View File

@@ -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;

95
src/monitor/utils/plugin.hpp
View File

@@ -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;
if (raw_size == 0) throw std::invalid_argument("Error set data in plugin: empty data");
auto raw_data_size = m_result.m_size;
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;
if (index > m_result.m_size) index = m_result.m_size;
bin_index += m_step;
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;
++index;
m_line_data[line_count][bin_index] = e.m_value;
++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);
}
};
}

60
src/monitor/utils/plugins/fft.hpp
View File

@@ -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_size = std::min(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_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);
}
};
}