Add detrending option (#150)

* Add option to detrend channels

* Optimize

Author: cbrnr

CMakeLists.txt

@@ -144,6 +144,10 @@ qt_add_library(sigviewer_objects OBJECT
     src/file_handling/biosig_reader.h
     src/file_handling/biosig_writer.cpp
     src/file_handling/biosig_writer.h
+    src/file_handling/channel_manager_proxy.cpp
+    src/file_handling/channel_manager_proxy.h
+    src/file_handling/detrend_channel_manager.cpp
+    src/file_handling/detrend_channel_manager.h
     src/file_handling/file_channel_manager.cpp
     src/file_handling/file_channel_manager.h
     src/file_handling/event_manager.cpp
@@ -197,6 +201,8 @@ qt_add_library(sigviewer_objects OBJECT
     src/gui/commands/adapt_event_view_gui_command.h
     src/gui/commands/close_file_gui_command.cpp
     src/gui/commands/close_file_gui_command.h
+    src/gui/commands/detrend_gui_command.cpp
+    src/gui/commands/detrend_gui_command.h
     src/gui/commands/event_editing_gui_command.cpp
     src/gui/commands/event_editing_gui_command.h
     src/gui/commands/help_gui_command.cpp

src/base/fixed_data_block.cpp

@@ -49,23 +49,22 @@ float32 const& FixedDataBlock::operator[] (size_t index) const
 //! Get the minimal value in a data block, excluding any NANs
 float32 FixedDataBlock::getMin () const
 {
+    size_t len = size ();
     float32 min = 0;
-    for (auto const elem : *data_)
+    for (size_t i = 0; i < len; ++i)
     {
-        if (!std::isnan(elem))
+        float32 v = (*data_)[start_index_ + i];
+        if (!std::isnan (v))
         {
-            min = elem;
+            min = v;
             break;
         }
     }
-
-    for (auto const elem : *data_)
+    for (size_t i = 0; i < len; ++i)
     {
-        if (!std::isnan(elem))
-        {
-            if (elem < min)
-                min = elem;
-        }
+        float32 v = (*data_)[start_index_ + i];
+        if (!std::isnan (v) && v < min)
+            min = v;
     }
     return min;
 }
@@ -74,23 +73,22 @@ float32 FixedDataBlock::getMin () const
 //! Get the maximal value in a data block, excluding any NANs
 float32 FixedDataBlock::getMax () const
 {
+    size_t len = size ();
     float32 max = 0;
-    for (auto const elem : *data_)
+    for (size_t i = 0; i < len; ++i)
     {
-        if (!std::isnan(elem))
+        float32 v = (*data_)[start_index_ + i];
+        if (!std::isnan (v))
         {
-            max = elem;
+            max = v;
             break;
         }
     }
-
-    for (auto const elem : *data_)
+    for (size_t i = 0; i < len; ++i)
     {
-        if (!std::isnan(elem))
-        {
-            if (elem > max)
-                max = elem;
-        }
+        float32 v = (*data_)[start_index_ + i];
+        if (!std::isnan (v) && v > max)
+            max = v;
     }
     return max;
 }

src/file_context.cpp

@@ -21,6 +21,10 @@ FileContext::FileContext (QString const& file_path_and_name,
       file_path_and_name_ (file_path_and_name),
       event_manager_ (event_manager),
       channel_manager_ (channel_manager),
+      detrend_manager_ (nullptr),
+      proxy_manager_ (new ChannelManagerProxy (channel_manager)),
+      detrend_enabled_ (false),
+      detrend_cutoff_hz_ (0.0),
       basic_header_ (header)
 {
     connect (event_manager_.data(), SIGNAL(changed()), SLOT(setAsChanged()));
@@ -30,6 +34,8 @@ FileContext::FileContext (QString const& file_path_and_name,
 FileContext::~FileContext ()
 {
     qDebug () << "deleting FileContext";
+    delete proxy_manager_;
+    delete detrend_manager_;
     delete channel_manager_;
 }
 
@@ -87,13 +93,73 @@ QSharedPointer<EventManager> FileContext::getEventManager ()
 //-----------------------------------------------------------------------------
 ChannelManager const& FileContext::getChannelManager () const
 {
-    return *channel_manager_;
+    return *proxy_manager_;
 }
 
 //-----------------------------------------------------------------------------
 ChannelManager& FileContext::getChannelManager ()
 {
-    return *channel_manager_;
+    return *proxy_manager_;
+}
+
+//-------------------------------------------------------------------------
+void FileContext::precomputeDetrendChannel (double cutoff_hz, ChannelID id)
+{
+    if (!detrend_manager_ || detrend_manager_->hpCutoff () != cutoff_hz)
+    {
+        delete detrend_manager_;
+        detrend_manager_  = new DetrendChannelManager (channel_manager_, cutoff_hz);
+        detrend_cutoff_hz_ = cutoff_hz;
+    }
+    // A getData(id, 0, 1) call is enough to trigger and cache processedChannel()
+    // which also populates the per-channel min/max cache.
+    detrend_manager_->getData (id, 0, 1);
+}
+
+//-------------------------------------------------------------------------
+void FileContext::ensureDetrendManager (double cutoff_hz)
+{
+    if (!detrend_manager_ || detrend_manager_->hpCutoff () != cutoff_hz)
+    {
+        delete detrend_manager_;
+        detrend_manager_   = new DetrendChannelManager (channel_manager_, cutoff_hz);
+        detrend_cutoff_hz_ = cutoff_hz;
+    }
+}
+
+//-------------------------------------------------------------------------
+void FileContext::precomputeDetrendChannelFromRaw (ChannelID id,
+                                                   QSharedPointer<DataBlock const> raw)
+{
+    // detrend_manager_ must already exist (call ensureDetrendManager first).
+    if (detrend_manager_)
+        detrend_manager_->precomputeFromRawData (id, raw);
+}
+
+//-------------------------------------------------------------------------
+bool FileContext::setDetrendEnabled (bool enabled, double hp_cutoff_hz)
+{
+    detrend_enabled_   = enabled;
+    detrend_cutoff_hz_ = hp_cutoff_hz;
+
+    bool rebuilt = false;
+    if (enabled)
+    {
+        // Only rebuild if parameters changed or no manager exists yet.
+        if (!detrend_manager_ || detrend_manager_->hpCutoff () != hp_cutoff_hz)
+        {
+            delete detrend_manager_;
+            detrend_manager_ = new DetrendChannelManager (channel_manager_, hp_cutoff_hz);
+            rebuilt = true;
+        }
+        proxy_manager_->setTarget (detrend_manager_);
+    }
+    else
+    {
+        proxy_manager_->setTarget (channel_manager_);
+        // Keep detrend_manager_ alive so toggling back on reuses the cache.
+    }
+    return rebuilt;
 }
 
 //-------------------------------------------------------------------------

src/file_context.h

@@ -9,6 +9,9 @@
 #include "file_handling/event_manager.h"
 #include "file_handling/basic_header.h"
 #include "file_handling/channel_manager.h"
+#include "file_handling/channel_manager_proxy.h"
+#include "file_handling/detrend_channel_manager.h"
+#include "base/data_block.h"
 #include "gui/signal_visualisation_model.h"
 #include "base/file_states.h"
 
@@ -74,6 +77,38 @@ class FileContext : public QObject
     //-------------------------------------------------------------------------
     ChannelManager& getChannelManager ();
 
+    //-------------------------------------------------------------------------
+    /// Enable or disable offset removal (mean subtraction + optional FIR
+    /// high-pass filter).  A high-pass cutoff of 0.0 means mean-only.
+    /// Returns true if the filter was (re)built, false if the existing cache
+    /// was reused (e.g. toggling off then back on with the same parameters).
+    bool setDetrendEnabled (bool enabled, double hp_cutoff_hz = 0.0);
+
+    //-------------------------------------------------------------------------
+    /// Pre-warms the detrend manager for a single channel during file load.
+    /// Creates the DetrendChannelManager if it does not yet exist or if the
+    /// cutoff changed.  Does NOT enable detrend — user still toggles it on.
+    void precomputeDetrendChannel (double cutoff_hz, ChannelID id);
+
+    //-------------------------------------------------------------------------
+    /// Ensures the DetrendChannelManager exists with the given cutoff.
+    /// Must be called on the main thread before any parallel
+    /// precomputeDetrendChannelFromRaw() calls.
+    void ensureDetrendManager (double cutoff_hz);
+
+    //-------------------------------------------------------------------------
+    /// Pre-compute a single channel from already-read raw data.
+    /// Thread-safe — multiple channels can be processed concurrently once
+    /// ensureDetrendManager() has been called on the main thread.
+    void precomputeDetrendChannelFromRaw (ChannelID id,
+                                          QSharedPointer<DataBlock const> raw);
+
+    //-------------------------------------------------------------------------
+    bool isDetrendEnabled () const { return detrend_enabled_; }
+
+    //-------------------------------------------------------------------------
+    double getDetrendCutoffHz () const { return detrend_cutoff_hz_; }
+
     //-------------------------------------------------------------------------
     QSharedPointer<BasicHeader> getHeader () {return basic_header_;}
 
@@ -103,7 +138,11 @@ public slots:
     FileState state_;
     QString file_path_and_name_;
     QSharedPointer<EventManager> event_manager_;
-    ChannelManager* channel_manager_;
+    ChannelManager* channel_manager_;          ///< raw source (owned)
+    DetrendChannelManager* detrend_manager_;   ///< detrend wrapper (owned, may be null)
+    ChannelManagerProxy* proxy_manager_;       ///< stable pointer given to views (owned)
+    bool detrend_enabled_;
+    double detrend_cutoff_hz_;
     QSharedPointer<BasicHeader> basic_header_;
     QSharedPointer<SignalVisualisationModel> main_signal_vis_model_;
 };

src/file_handling/channel_manager.cpp

@@ -107,6 +107,25 @@ float64 ChannelManager::getMaxValue (ChannelID channel_id) const
 }
 
 //-------------------------------------------------------------------------
+void ChannelManager::invalidateMinMaxCache ()
+{
+    min_max_initialized_ = false;
+    min_values_.clear ();
+    max_values_.clear ();
+    offsets_.clear ();
+}
+
+void ChannelManager::setChannelMinMax (ChannelID id, float64 min_val, float64 max_val)
+{
+    min_values_[id] = min_val;
+    max_values_[id] = max_val;
+}
+
+void ChannelManager::markMinMaxInitialized ()
+{
+    min_max_initialized_ = true;
+}
+
 void ChannelManager::initMinMax () const
 {
     if (min_max_initialized_)

src/file_handling/channel_manager.h

@@ -57,32 +57,46 @@ class ChannelManager
     virtual float64 getSampleRate () const = 0;
 
     //-------------------------------------------------------------------------
-    void addDownsampledMinMaxVersion (ChannelID id, QSharedPointer<DataBlock const> min,
+    virtual void addDownsampledMinMaxVersion (ChannelID id, QSharedPointer<DataBlock const> min,
                                       QSharedPointer<DataBlock const> max, unsigned factor);
 
     //-------------------------------------------------------------------------
-    unsigned getNearestDownsamplingFactor (ChannelID id, unsigned factor) const;
+    virtual unsigned getNearestDownsamplingFactor (ChannelID id, unsigned factor) const;
 
     //-------------------------------------------------------------------------
-    QSharedPointer<DataBlock const> getDownsampledMin (ChannelID id, unsigned factor) const;
+    virtual QSharedPointer<DataBlock const> getDownsampledMin (ChannelID id, unsigned factor) const;
 
     //-------------------------------------------------------------------------
-    QSharedPointer<DataBlock const> getDownsampledMax (ChannelID id, unsigned factor) const;
+    virtual QSharedPointer<DataBlock const> getDownsampledMax (ChannelID id, unsigned factor) const;
+
+    //-------------------------------------------------------------------------
+    /// Clears the cached min/max values so they are recomputed on the next
+    /// access. Call this when the underlying data source changes.
+    void invalidateMinMaxCache ();
+
+    //-------------------------------------------------------------------------
+    /// Pre-populate one channel's min/max entry.  Call markMinMaxInitialized()
+    /// once all channels have been set to skip the lazy per-channel file scan.
+    void setChannelMinMax (ChannelID id, float64 min_val, float64 max_val);
+
+    //-------------------------------------------------------------------------
+    /// Mark the min/max cache as fully built so initMinMax() is never called.
+    void markMinMaxInitialized ();
 
     //-------------------------------------------------------------------------
     float64 getValueRange (std::set<ChannelID> const& channels) const;
 
     //-------------------------------------------------------------------------
-    float64 getMinValue (std::set<ChannelID> const& channels) const;
+    virtual float64 getMinValue (std::set<ChannelID> const& channels) const;
 
     //-------------------------------------------------------------------------
-    float64 getMaxValue (std::set<ChannelID> const& channels) const;
+    virtual float64 getMaxValue (std::set<ChannelID> const& channels) const;
 
     //-------------------------------------------------------------------------
-    float64 getMinValue (ChannelID channel_id) const;
+    virtual float64 getMinValue (ChannelID channel_id) const;
 
     //-------------------------------------------------------------------------
-    float64 getMaxValue (ChannelID channel_id) const;
+    virtual float64 getMaxValue (ChannelID channel_id) const;
 
     //-------------------------------------------------------------------------
     void setXAxisUnitLabel (QString const& label) {x_axis_unit_label_ = label;}