in the middle of non-linear pixels debuggingconflicting_master

1 files changed, 97 insertions, 34 deletions

diff --git a/src/dumps.cpp b/src/dumps.cpp
index 3e138b3..90716b9 100644
--- a/src/dumps.cpp
+++ b/src/dumps.cpp
@@ -10,6 +10,9 @@
 
 #include "fuck_intel.h"
 
+#include "calibration.h"
+
+#include <chrono>
 #include <execution>
 #include <iostream>
 
@@ -55,56 +58,116 @@ QList<Pixels> openDump(
     }
 
     if (false) {
-        filenames = filenames.first(10000);
+        filenames = filenames.first(1000);
     }
 
-    std::sort(filenames.begin(), filenames.end(), [](const auto &a, const auto &b) {
-        const auto mca = a.split('_').at(3).toInt();
-        const auto mcb = b.split('_').at(3).toInt();
+    using mc_t = decltype(Counters::measurementCounter);
+    using ep_t = decltype(Counters::encoderPosition);
+    using counters_tuple_t = std::tuple<mc_t, ep_t>;
+    std::vector<counters_tuple_t> metaFilenames{static_cast<size_t>(filenames.size())};
+
+    const auto fn2meta = [](const QString &filename) -> counters_tuple_t {
+        const auto splitted = filename.split('_');
+        const auto mc = splitted.at(3).toUInt();
+        const auto ep = splitted.at(5).toUInt();
+        return std::make_tuple(mc, ep);
+    };
+
+    const auto meta2fn = [](const counters_tuple_t &meta) {
+        const auto &[mc, ep] = meta;
+        const auto tmp = QStringLiteral("raw_profile_meas_%1_enc_%2").arg(mc).arg(ep);
+        return tmp;
+    };
+
+    std::transform(filenames.cbegin(), filenames.cend(), metaFilenames.begin(), fn2meta);
+
+    filenames.clear();
+    filenames.squeeze();
+
+    std::sort(metaFilenames.begin(), metaFilenames.end(), [](const auto &a, const auto &b) {
+        const auto &[mca, epa] = a;
+        const auto &[mcb, epb] = b;
         return mca < mcb;
     });
 
-    qDebug() << __func__ << "create results array" << filenames.size();
-    auto resultOptionals = QScopedPointer(
-        new QList<std::optional<Pixels>>(filenames.size()));
-    qDebug() << __func__ << "created results array";
+    // std::multimap<ep_t, mc_t> enc_meas;
+    std::map<ep_t, std::vector<mc_t>> enc_meas;
+
+    for (const auto &mf : metaFilenames) {
+        const auto &[mc, ep] = mf;
+        enc_meas[ep].push_back(mc);
+    }
+
+    metaFilenames.clear();
+    metaFilenames.shrink_to_fit();
+
+    QList<Pixels> result;
+    result.reserve(static_cast<qsizetype>(enc_meas.size()));
 
     QElapsedTimer t;
     t.start();
     qDebug() << __func__ << "open real files";
-    // std::cout << "here" << std::endl;
+    uint8_t lastPercent{std::numeric_limits<decltype(lastPercent)>::max()};
+    auto lastPercentTime = std::chrono::system_clock::now();
 
-    std::transform(/*std::execution::par_unseq,*/
-                   filenames.begin(),
-                   filenames.end(),
-                   resultOptionals->begin(),
-                   [dirToRead](const auto &filename) {
-                       // std::cout << '.';
-                       // auto rawProfile = openRawProfile(dirToRead + "/" + filename);
-                       auto rawProfile = Pixels::load(dirToRead + '/' + filename);
+    // for (const auto &[ep, mcl] : enc_meas) {
+    for (auto em = enc_meas.cbegin(); em != enc_meas.cend(); ++em) {
+        const auto &[ep, mcl] = *em;
+        std::vector<Pixels> toFilter;
+        toFilter.reserve(mcl.size());
 
-                       return rawProfile;
-                   });
+        for (const auto &mc : mcl) {
+            const auto &filename = meta2fn(std::make_tuple(mc, ep));
+            const auto pixelsOpt = Pixels::load(dirToRead + '/' + filename);
 
-    filenames.clear();
-    filenames.squeeze();
+            if (pixelsOpt.has_value()) {
+                toFilter.push_back(*pixelsOpt);
+            }
+        };
+
+        // const auto filtered = op::avgFilterAtPos(std::move(toFilter));
+        const auto filtered = op::medianFilterAtPos(std::move(toFilter));
+
+        if (filtered.has_value()) {
+            result.push_back(*filtered);
+        }
+
+        const uint8_t percent{
+            static_cast<uint8_t>(std::distance(enc_meas.cbegin(), em) * 100 / enc_meas.size())};
+
+        if (percent != lastPercent) {
+            lastPercent = percent;
+            const auto now = std::chrono::system_clock::now();
+            const auto diffMs = std::chrono::duration_cast<std::chrono::milliseconds>(
+                                    now - lastPercentTime)
+                                    .count();
+            lastPercentTime = std::chrono::system_clock::now();
+            qDebug().nospace() << Q_FUNC_INFO << ": " << lastPercent
+                               << "%; count: " << result.size() << "; ms (1%): " << diffMs;
+        }
+    }
 
-    qDebug() << Q_FUNC_INFO << "open raw profiles: elapsed (ms)" << t.elapsed();
-    // std::cout << std::endl;
+    // std::sort(filenames.begin(), filenames.end(), [](const auto &a, const auto &b) {
+    //     const auto mca = a.split('_').at(3).toInt();
+    //     const auto mcb = b.split('_').at(3).toInt();
+    //     return mca < mcb;
+    // });
 
-    // FIXME: no effect
-    std::remove_if(std::execution::par,
-                   resultOptionals->begin(),
-                   resultOptionals->end(),
-                   [](auto &a) { return !a.has_value(); });
+    // for (size_t i{0}; i < metaFilenames.size(); ++i) {
+    //     const auto &meta = metaFilenames.at(i);
+    //     const auto filename = meta2fn(meta);
+    //     auto rawProfile = Pixels::load(dirToRead + '/' + filename);
 
-    QList<Pixels> result(resultOptionals->size());
+    //     if (rawProfile.has_value()) {
+    //         result << *rawProfile;
+    //     }
+    //     const uint8_t percent{static_cast<uint8_t>(i * 100 / metaFilenames.size())};
 
-    std::transform(std::execution::par,
-                   std::make_move_iterator(resultOptionals->begin()),
-                   std::make_move_iterator(resultOptionals->end()),
-                   result.begin(),
-                   [](auto &p) { return p.value(); });
+    //     if (percent != lastPercent) {
+    //         lastPercent = percent;
+    //         qDebug().nospace() << Q_FUNC_INFO << ": " << lastPercent << '%';
+    //     }
+    // }
 
     qDebug() << Q_FUNC_INFO << "elapsed (ms)" << t.elapsed();