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
//=============================================================================================================
 
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(); }
};
 
#endif // SOURCEESTIMATEOVERLAY_H