Optimize rendering (#149)

* Draw a vertical min-max line for zoomed out signals

* Use polyline

* Implement downsampling pyramid

* Add changelog entry

Author: cbrnr

CHANGELOG.md

@@ -3,6 +3,9 @@
 - Use SVG icons with support for light and dark themes
 - Add option to toggle between showing the menubar and using a hamburger menu on Windows and Linux
 
+### 🌀 Changed
+- Faster scrolling/zooming for long recordings at high zoom-out levels (uses a per-pixel min–max envelope with automatic downsampling depending on the zoom level)
+
 ## [0.6.5] · 2026-03-24
 ### 🌀 Changed
 - Switch from Qt 5 to Qt 6

CMakeLists.txt

@@ -153,6 +153,8 @@ qt_add_library(sigviewer_objects OBJECT
     src/file_handling/evt_writer.cpp
     src/file_handling/evt_writer.h
     src/file_handling/file_handler_factory_registrator.h
+    src/file_handling/down_sampling_thread.cpp
+    src/file_handling/down_sampling_thread.h
     src/file_handling/xdf_reader.cpp
     src/file_handling/xdf_reader.h
 

src/file_handling/down_sampling_thread.cpp

@@ -4,20 +4,24 @@
 
 
 #include "down_sampling_thread.h"
-
-#include <fstream>
-
-#include "signal_processing/SPUC/butterworth.h"
 #include "base/fixed_data_block.h"
 #include "gui/background_processes.h"
 
 #include <vector>
-#include <QMessageBox>
+#include <limits>
+#include <cmath>
 #include <QDebug>
 
+// SPUC headers define macros (E, PI, ...) that must come after Qt/STL headers
+// to avoid corrupting Qt6's C++20 constructs in C++17 mode.
+#include <fstream>
+#include "signal_processing/SPUC/butterworth.h"
+
 namespace SigViewer_
 {
 
+using namespace sigviewer;
+
 QString DownSamplingThread::PROCESS_NAME_ ("Downsampling...");
 
 //-----------------------------------------------------------------------------
@@ -63,10 +67,102 @@ void DownSamplingThread::run ()
     running_ = false;
 }
 
+//-------------------------------------------------------------------------
+void DownSamplingThread::runSynchronously ()
+{
+    minMaxDownsampling ();
+}
+
 //-------------------------------------------------------------------------
 void DownSamplingThread::minMaxDownsampling ()
 {
+    std::set<ChannelID> channels = channel_manager_->getChannels ();
+    size_t num_samples = channel_manager_->getNumberSamples ();
+    double sample_rate = channel_manager_->getSampleRate ();
 
+    for (ChannelID id : channels)
+    {
+        QSharedPointer<DataBlock const> full_data =
+            channel_manager_->getData (id, 0, static_cast<unsigned>(num_samples));
+        if (full_data.isNull () || full_data->size () == 0)
+            continue;
+
+        size_t cur_size = full_data->size ();
+
+        // Seed working buffers from the raw samples.
+        // NaN values propagate: a downsampled window is NaN only when every
+        // raw sample inside it is NaN.
+        QVector<float32> cur_min (static_cast<int>(cur_size));
+        QVector<float32> cur_max (static_cast<int>(cur_size));
+        for (size_t i = 0; i < cur_size; i++)
+        {
+            float32 v = (*full_data)[i];
+            cur_min[static_cast<int>(i)] = v;
+            cur_max[static_cast<int>(i)] = v;
+        }
+
+        // Build the min/max pyramid hierarchically: each level aggregates the
+        // previous one by downsampling_step_, so total work is O(N) per channel
+        // (geometric series: N + N/step + N/step^2 + ...).
+        for (unsigned factor = downsampling_step_;
+             factor < downsampling_max_ && cur_size > 1;
+             factor *= downsampling_step_)
+        {
+            size_t next_size = (cur_size + downsampling_step_ - 1) / downsampling_step_;
+            QVector<float32> next_min (static_cast<int>(next_size));
+            QVector<float32> next_max (static_cast<int>(next_size));
+
+            for (size_t i = 0; i < next_size; i++)
+            {
+                size_t j0 = i * downsampling_step_;
+                size_t j1 = std::min (j0 + static_cast<size_t>(downsampling_step_), cur_size);
+
+                float32 vmin = std::numeric_limits<float32>::quiet_NaN ();
+                float32 vmax = std::numeric_limits<float32>::quiet_NaN ();
+
+                for (size_t j = j0; j < j1; j++)
+                {
+                    float32 lo = cur_min[static_cast<int>(j)];
+                    float32 hi = cur_max[static_cast<int>(j)];
+                    if (!std::isnan (lo))
+                    {
+                        if (std::isnan (vmin))
+                        {
+                            vmin = lo;
+                            vmax = hi;
+                        }
+                        else
+                        {
+                            if (lo < vmin) vmin = lo;
+                            if (hi > vmax) vmax = hi;
+                        }
+                    }
+                }
+
+                next_min[static_cast<int>(i)] = vmin;
+                next_max[static_cast<int>(i)] = vmax;
+            }
+
+            // Persist this level – copy into fresh QVectors so the working
+            // buffers below can be moved cheaply on the next iteration.
+            auto stored_min = QSharedPointer<QVector<float32>> (
+                                  new QVector<float32> (next_min));
+            auto stored_max = QSharedPointer<QVector<float32>> (
+                                  new QVector<float32> (next_max));
+
+            double ds_rate = sample_rate / factor;
+            channel_manager_->addDownsampledMinMaxVersion (
+                id,
+                QSharedPointer<DataBlock const> (new FixedDataBlock (stored_min, ds_rate)),
+                QSharedPointer<DataBlock const> (new FixedDataBlock (stored_max, ds_rate)),
+                factor);
+
+            // Advance working buffers to this level for the next iteration.
+            cur_min = std::move (next_min);
+            cur_max = std::move (next_max);
+            cur_size = next_size;
+        }
+    }
 }
 
 //-------------------------------------------------------------------------
@@ -83,14 +179,11 @@ void DownSamplingThread::downsampleAllOnBasisData ()
     {
         for (int channel = 0; channel < data_.size(); channel++)
         {
-            max_channel_length = std::max (max_channel_length, basis_data_[channel]->size());
+            max_channel_length = std::max (max_channel_length, static_cast<unsigned>(basis_data_[channel]->size()));
             sample_rates[downsampling_factor].append (basis_data_[channel]->getSampleRatePerUnit() / downsampling_factor);
 
             QSharedPointer<QVector<float32> > raw_data_vector (new QVector<float32> (static_cast<int>(basis_data_[channel]->size () / downsampling_factor) + 1));
 
-            QSharedPointer<DataBlock> downsampled_data (new FixedDataBlock (raw_data_vector, sample_rates[downsampling_factor][channel]));
-            basis_data_[channel]->addDownSampledVersion (downsampled_data, downsampling_factor);
-
             raw_downsampled_data[downsampling_factor].append (raw_data_vector);
             low_pass_filters[downsampling_factor].append (QSharedPointer<SPUC::butterworth<float32> > (new SPUC::butterworth<float32> (0.5 / downsampling_factor, 4, 3)));
         }
@@ -132,7 +225,7 @@ void DownSamplingThread::downsampleOnDownsampledData ()
 
         for (int channel = 0; channel < data_.size(); channel++)
         {
-            max_channel_length = std::max (max_channel_length, data_[channel]->size());
+            max_channel_length = std::max (max_channel_length, static_cast<unsigned>(data_[channel]->size()));
             raw_downsampled_data.append (QSharedPointer<QVector<float32> > (new QVector<float32> (static_cast<int>(data_[channel]->size () / downsampling_step_) + 1)));
             low_pass_filters.append (QSharedPointer<SPUC::butterworth<float32> > (new SPUC::butterworth<float32> (0.9 / downsampling_step_, 4, 3)));
             sample_rates_.append (data_[channel]->getSampleRatePerUnit() / downsampling_step_);
@@ -156,7 +249,6 @@ void DownSamplingThread::downsampleOnDownsampledData ()
         for (int channel = 0; channel < raw_downsampled_data.size(); channel++)
         {
             QSharedPointer<DataBlock> downsampled_data (new FixedDataBlock (raw_downsampled_data[channel], sample_rates_[channel]));
-            basis_data_[channel]->addDownSampledVersion (downsampled_data, downsampling_factor);
             data_.append (downsampled_data);
         }
     }

src/file_handling/down_sampling_thread.h

@@ -18,6 +18,10 @@
 namespace SigViewer_
 {
 
+using sigviewer::DataBlock;
+using sigviewer::ChannelManager;
+using sigviewer::ChannelID;
+
 class DownSamplingThread : public QThread
 {
     Q_OBJECT
@@ -31,6 +35,12 @@ class DownSamplingThread : public QThread
     //-------------------------------------------------------------------------
     virtual ~DownSamplingThread ();
 
+    //-------------------------------------------------------------------------
+    /// Run minMaxDownsampling() directly on the calling thread.
+    /// Use this instead of start()+wait() when already on the main thread to
+    /// avoid Qt widgets being instantiated on a background thread.
+    void runSynchronously ();
+
 signals:
     //-------------------------------------------------------------------------
     void downsamplingDataFinished (QSharedPointer<DataBlock> data, ChannelID channel, unsigned factor);

src/gui/commands/open_file_gui_command.cpp

@@ -13,6 +13,7 @@
 #include "file_handling/file_signal_reader_factory.h"
 #include "file_handling/event_manager.h"
 #include "file_handling/file_channel_manager.h"
+#include "file_handling/down_sampling_thread.h"
 #include "tab_context.h"
 #include "file_context.h"
 #include "gui/main_window_model.h"
@@ -323,6 +324,16 @@ void OpenFileGuiCommand::openFileImpl (QString file_path, bool instantly)
 
     ProgressBar::instance().initAndShow (channel_manager->getNumberChannels() * 3, tr("Opening ") + file_name,
                                          applicationContext());
+
+    // Build the min/max downsampling pyramid used by the zoomed-out rendering
+    // path.  Runs synchronously so the data is ready before the first paint.
+    {
+        QSharedPointer<ChannelManager> cm (channel_manager, [] (ChannelManager*) {});
+        SigViewer_::DownSamplingThread ds_thread (cm, 2,
+            static_cast<unsigned> (channel_manager->getNumberSamples ()) + 1u);
+        ds_thread.runSynchronously ();
+    }
+
     QSharedPointer<EventManager> event_manager (new EventManager (*file_signal_reader));
     QSharedPointer<FileContext> file_context (new FileContext (file_path, event_manager,
                                                  channel_manager, file_signal_reader->getBasicHeader()));