sensorfieldmapper.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef SENSORFIELDMAPPER_H
#define SENSORFIELDMAPPER_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../disp3D_global.h"
 
#include "core/viewstate.h"
 
#include <fiff/fiff_evoked.h>
#include <fiff/fiff_coord_trans.h>
 
#include <Eigen/Core>
#include <QMap>
#include <QVector>
#include <QString>
#include <memory>
#include <vector>
 
class BrainSurface;
 
//=============================================================================================================
class DISP3DSHARED_EXPORT SensorFieldMapper
{
public:
    //=========================================================================================================
    SensorFieldMapper() = default;
 
    //=========================================================================================================
    void setEvoked(const FIFFLIB::FiffEvoked &evoked);
 
    //=========================================================================================================
    bool isLoaded() const { return m_loaded; }
 
    //=========================================================================================================
    void setTimePoint(int tp) { m_timePoint = tp; }

    int timePoint() const { return m_timePoint; }
 
    //=========================================================================================================
    void setMegFieldMapOnHead(bool onHead) { m_megOnHead = onHead; }
 
    bool megFieldMapOnHead() const { return m_megOnHead; }
 
    //=========================================================================================================
    void setColormap(const QString &name) { m_colormap = name; }
 
    const QString &colormap() const { return m_colormap; }
 
    //=========================================================================================================
    const FIFFLIB::FiffEvoked &evoked() const { return m_evoked; }
 
    //=========================================================================================================
    bool hasMappingFor(const FIFFLIB::FiffEvoked &newEvoked) const;

    const Eigen::VectorXi &megPick() const { return m_megPick; }

    const Eigen::VectorXi &eegPick() const { return m_eegPick; }

    std::shared_ptr<Eigen::MatrixXf> megMapping() const { return m_megMapping; }

    std::shared_ptr<Eigen::MatrixXf> eegMapping() const { return m_eegMapping; }
 
    //=========================================================================================================
    bool buildMapping(const QMap<QString, std::shared_ptr<BrainSurface>> &surfaces,
                      const FIFFLIB::FiffCoordTrans &headToMriTrans,
                      bool applySensorTrans);
 
    //=========================================================================================================
    void apply(QMap<QString, std::shared_ptr<BrainSurface>> &surfaces,
               const SubView &singleView,
               const QVector<SubView> &subViews);
 
    //=========================================================================================================
    const QString &megSurfaceKey() const { return m_megSurfaceKey; }

    const QString &eegSurfaceKey() const { return m_eegSurfaceKey; }
 
    //=========================================================================================================
    // ── Static utilities ───────────────────────────────────────────────

    static QString findHeadSurfaceKey(const QMap<QString, std::shared_ptr<BrainSurface>> &surfaces);

    static QString findHelmetSurfaceKey(const QMap<QString, std::shared_ptr<BrainSurface>> &surfaces);

    static float contourStep(float minVal, float maxVal, int targetTicks);

    static Eigen::Vector3f fitSphereOrigin(const FIFFLIB::FiffInfo &info,
                                           float *radius = nullptr);

    void computeNormRange();
 
private:
    //=========================================================================================================
    // ── Contour surface generation ─────────────────────────────────────

    void updateContourSurfaces(QMap<QString, std::shared_ptr<BrainSurface>> &surfaces,
                               const QString &prefix,
                               const BrainSurface &surface,
                               const QVector<float> &values,
                               float step,
                               bool visible);
 
    //=========================================================================================================
    // ── Internal data ──────────────────────────────────────────────────
 
    FIFFLIB::FiffEvoked m_evoked;
    bool   m_loaded    = false;
    int    m_timePoint = 0;
    bool   m_megOnHead = false;
    QString m_colormap = QStringLiteral("MNE");
 
    QString m_megSurfaceKey;
    QString m_eegSurfaceKey;
    QString m_megContourPrefix = QStringLiteral("sens_contour_meg");
    QString m_eegContourPrefix = QStringLiteral("sens_contour_eeg");
 
    Eigen::VectorXi                   m_megPick;
    Eigen::VectorXi                   m_eegPick;
    std::vector<Eigen::Vector3f>      m_megPositions;
    std::vector<Eigen::Vector3f>      m_eegPositions;
    std::shared_ptr<Eigen::MatrixXf> m_megMapping;
    std::shared_ptr<Eigen::MatrixXf> m_eegMapping;
 
    float m_megVmax = 0.0f;      
    float m_eegVmax = 0.0f;      
};
 
#endif // SENSORFIELDMAPPER_H