sourceestimateoverlay.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef SOURCEESTIMATEOVERLAY_H
#define SOURCEESTIMATEOVERLAY_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../disp3D_global.h"
 
#include <inv/inv_source_estimate.h>
#include <QVector>
#include <QString>
#include <QSharedPointer>
#include <QHash>
#include <QPair>
#include <Eigen/Sparse>
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
namespace DISP3DLIB
{
 
class BrainSurface;
 
//=============================================================================================================
class DISP3DSHARED_EXPORT SourceEstimateOverlay
{
public:
    //=========================================================================================================
    SourceEstimateOverlay();
 
    //=========================================================================================================
    ~SourceEstimateOverlay();
 
    //=========================================================================================================
    bool loadStc(const QString& path, int hemi);
 
    //=========================================================================================================
    bool isLoaded() const;
 
    //=========================================================================================================
    void applyToSurface(BrainSurface* surface, int timeIndex);
 
    //=========================================================================================================
    void computeInterpolationMatrix(BrainSurface* surface, int hemi, double cancelDist = 0.05);
 
    //=========================================================================================================
    void setColormap(const QString& name);
 
    //=========================================================================================================
    QString colormap() const
    {
        return m_colormap;
    }
 
    //=========================================================================================================
    void setThresholds(float min, float mid, float max);
 
    //=========================================================================================================
    float thresholdMin() const
    {
        return m_threshMin;
    }
    float thresholdMid() const
    {
        return m_threshMid;
    }
    float thresholdMax() const
    {
        return m_threshMax;
    }
 
    //=========================================================================================================
    int numTimePoints() const;
 
    //=========================================================================================================
    float timeAtIndex(int idx) const;
 
    //=========================================================================================================
    float tmin() const;
 
    //=========================================================================================================
    float tstep() const;
 
    //=========================================================================================================
    void getDataRange(double& minVal, double& maxVal) const;
 
    //=========================================================================================================
    void setStcData(const INVLIB::InvSourceEstimate& stc, int hemi);
 
    //=========================================================================================================
    void setInterpolationMatrix(QSharedPointer<Eigen::SparseMatrix<float>> mat, int hemi);
 
    //=========================================================================================================
    void updateThresholdsFromData();
 
    //=========================================================================================================
    QSharedPointer<Eigen::SparseMatrix<float>> interpolationMatLh() const
    {
        return m_interpolationMatLh;
    }
 
    //=========================================================================================================
    QSharedPointer<Eigen::SparseMatrix<float>> interpolationMatRh() const
    {
        return m_interpolationMatRh;
    }
 
    //=========================================================================================================
    Eigen::VectorXd sourceDataColumn(int timeIndex) const;
 
private:
    //=========================================================================================================
    uint32_t valueToColor(double value, uint8_t alpha = 255) const;
 
    INVLIB::InvSourceEstimate m_stcLh; 
    INVLIB::InvSourceEstimate m_stcRh; 
    bool m_hasLh = false;              
    bool m_hasRh = false;              
 
    QString m_colormap = "Hot"; 
    float m_threshMin = 0.0f;   
    float m_threshMid = 0.5f;   
    float m_threshMax = 1.0f;   
 
    QSharedPointer<Eigen::SparseMatrix<float>> m_interpolationMatLh; 
    QSharedPointer<Eigen::SparseMatrix<float>> m_interpolationMatRh; 
 
    // ── Per-time-point color cache ─────────────────────────────────────
    // Keyed by (hemi, vertexCount). The inner hash maps timeIndex →
    // pre-computed packed-ABGR color buffer. Invalidated whenever the
    // colormap, thresholds or source data change. This makes scrubbing
    // and auto-loop playback effectively free after the first pass: only
    // the per-vertex color blend + GPU upload happens, never the sparse
    // interpolation matvec or the per-vertex colormap calculation.
    using ColorCacheKey = QPair<int, int>;                       
    using ColorCacheBucket = QHash<int, QVector<uint32_t>>;      
    mutable QHash<ColorCacheKey, ColorCacheBucket> m_colorCache; 
    void invalidateColorCache()
    {
        m_colorCache.clear();
    }
};
 
} // namespace DISP3DLIB
 
#endif // SOURCEESTIMATEOVERLAY_H