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>
 
namespace DISP3DLIB
{
 
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; 
};
 
} // namespace DISP3DLIB
 
#endif // SENSORFIELDMAPPER_H