add min max to result

bin/main.cpp

@@ -13,6 +13,7 @@ auto main() -> int
 
   auto r = hr::run<hr::plugins::fft>(setup);
   hack::log()("grad:", r.m_grad);
+  hack::log()("min:", r.m_min, "max:", r.m_max);
 
   if (!r.empty())
   {

src/plugins/fft/fft.cpp

@@ -35,10 +35,11 @@ namespace hr::plugins
     for (size_t i = 0; i < m_frames; ++i) 
     {
       // Конвертация в децибелы
-      auto a = fft.m_norm[i];
+      auto v = fft.m_norm[i];
-      if (a > 0.000001f) a = 20.0f * log10(a);
+      if (v > 0.000001f) v = 20.0f * log10(v);
-      else a = -120.0f; // Минимальное значение для логарифмической шкалы
+      else v = -120.0f; // Минимальное значение для логарифмической шкалы
-      b.m_values.push_back(a);
+      b.m_values.push_back(v);
+      m_result.set_min_max(v);
     }
     m_result.set_bit(0, b);
   }

src/plugins/magnitude/magnitude.cpp

@@ -20,15 +20,19 @@ namespace hr::plugins
   void magnitude::process(cvec_t& fft, fvec_t& base, real_time timestamp)
   {
     std::size_t frames = fft.size(); 
-    base_t m = 0.f;
+    base_t v = 0.f;
-    for (std::size_t i = 0; i < frames; ++i) m += fft.m_norm[i];
+    for (std::size_t i = 0; i < frames; ++i) v += fft.m_norm[i];
-    m /= frames;
+    v /= frames;
+
+    m_result.m_max = hack::math::max(m_result.m_max, v);
+    m_result.m_min = hack::math::min(m_result.m_min, v);
 
     result::bit b;
-    b.m_value = m;
+    b.m_value = v;
     b.m_duration = timestamp;
 
     m_result.set_bit(0, b);
+    m_result.set_min_max(v);
   }
 
   result magnitude::get_result()

src/plugins/raw_data/raw_data.cpp

@@ -25,6 +25,7 @@ namespace hr::plugins
       b.m_value = v;
       b.m_duration = timestamp;
       m_result.set_bit(0, b);
+      m_result.set_min_max(v);
     }
   }
 

src/utils/workers/result.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <vector>
+#include <hack/math/math.hpp>
 #include <hack/logger/logger.hpp>
 #include "utils/real_time/real_time.hpp"
 #include "utils/using.hpp"
@@ -55,6 +56,18 @@ namespace hr
     // Второй вектор - данные для каждой линии, т.е. именно сими биты
     std::vector<std::vector<bit>> m_data;
 
+    // максимальные и минимальные элементы в принципе в данном расчете
+    // в основном нужны для графической реализации
+    // соответственно метод ниже в попощь
+    base_t m_max = std::numeric_limits<base_t>::min();
+    base_t m_min = std::numeric_limits<base_t>::max();
+    void set_min_max(base_t v) 
+    {
+      m_max = hack::math::max(m_max, v);
+      m_min = hack::math::min(m_min, v);
+    }
+
+
     // иногда нужна градуировка одна и тажа для всех бинов
     std::vector<base_t> m_grad;
   };