mne_inverse_operator.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef MNE_INVERSE_OPERATOR_H
#define MNE_INVERSE_OPERATOR_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "mne_global.h"
#include "mne_source_spaces.h"
#include "mne_forward_solution.h"
 
#include <fiff/fiff_types.h>
#include <fiff/fiff_named_matrix.h>
#include <fiff/fiff_proj.h>
#include <fiff/fiff_cov.h>
#include <fiff/fiff_info.h>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QList>
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
namespace FSLIB
{
class FsLabel;
}
 
//=============================================================================================================
// DEFINE NAMESPACE MNELIB
//=============================================================================================================
 
namespace MNELIB
{
 
//=========================================================================================================
struct RegionMTOut
{
    Eigen::VectorXi roiIdx; 
    Eigen::MatrixXd ctrs;   
    Eigen::VectorXd sumd;   
    Eigen::MatrixXd D;      
    qint32 iLabelIdxOut;    
};
 
//=========================================================================================================
struct RegionMT
{
    Eigen::MatrixXd matRoiMT;     
    Eigen::MatrixXd matRoiMTOrig; 
    qint32 nClusters;             
    Eigen::VectorXi idcs;         
    qint32 iLabelIdxIn;           
    QString sDistMeasure;         

    RegionMTOut cluster() const
    {
        const QString distMeasure = sDistMeasure.isEmpty()
            ? QStringLiteral("cityblock")
            : sDistMeasure;
 
        RegionMTOut out;
        UTILSLIB::KMeans kMeans(distMeasure, QStringLiteral("sample"), 5);
        kMeans.calculate(matRoiMT, nClusters,
                         out.roiIdx, out.ctrs, out.sumd, out.D);
        out.iLabelIdxOut = iLabelIdxIn;
        return out;
    }
};
 
//=============================================================================================================
class MNESHARED_EXPORT MNEInverseOperator
{
public:
    typedef QSharedPointer<MNEInverseOperator> SPtr;            
    typedef QSharedPointer<const MNEInverseOperator> ConstSPtr; 
 
    //=========================================================================================================
    MNEInverseOperator();
 
    //=========================================================================================================
    explicit MNEInverseOperator(QIODevice& p_IODevice);
 
    //=========================================================================================================
    MNEInverseOperator(const FIFFLIB::FiffInfo& info,
                       const MNEForwardSolution& forward,
                       const FIFFLIB::FiffCov& noiseCov,
                       float loose = 0.2f,
                       float depth = 0.8f,
                       bool fixed = false,
                       bool limit_depth_chs = true);
 
    //=========================================================================================================
    MNEInverseOperator(const MNEInverseOperator& other);
 
    //=========================================================================================================
    MNEInverseOperator& operator=(const MNEInverseOperator& other) = default;
 
    //=========================================================================================================
    ~MNEInverseOperator();
 
    //=========================================================================================================
    bool assemble_kernel(const FSLIB::FsLabel& label,
                         const QString& method,
                         bool pick_normal,
                         Eigen::MatrixXd& K,
                         Eigen::SparseMatrix<double>& noise_norm,
                         QList<Eigen::VectorXi>& vertno);
 
    //=========================================================================================================
    bool check_ch_names(const FIFFLIB::FiffInfo& info) const;
 
    //=========================================================================================================
    Eigen::MatrixXd cluster_kernel(const FSLIB::FsAnnotationSet& annotationSet,
                                   qint32 clusterSize,
                                   Eigen::MatrixXd& D,
                                   const QString& method = QStringLiteral("cityblock")) const;
 
    //=========================================================================================================
    inline Eigen::MatrixXd& getKernel();
 
    //=========================================================================================================
    inline Eigen::MatrixXd getKernel() const;
 
    //=========================================================================================================
    inline bool isFixedOrient() const;
 
    //=========================================================================================================
    static MNEInverseOperator make_inverse_operator(const FIFFLIB::FiffInfo& info,
                                                    MNEForwardSolution forward,
                                                    const FIFFLIB::FiffCov& noiseCov,
                                                    float loose = 0.2f,
                                                    float depth = 0.8f,
                                                    bool fixed = false,
                                                    bool limit_depth_chs = true);
 
    //=========================================================================================================
    MNEInverseOperator prepare_inverse_operator(qint32 nave,
                                                float lambda2,
                                                bool dSPM,
                                                bool sLORETA = false) const;
 
    //=========================================================================================================
    static bool read_inverse_operator(QIODevice& p_IODevice, MNEInverseOperator& inv);
 
    //=========================================================================================================
    bool write(QIODevice& p_IODevice);
 
    //=========================================================================================================
    void writeToStream(FIFFLIB::FiffStream* p_pStream);
 
    //=========================================================================================================
    friend std::ostream& operator<<(std::ostream& out, const MNEInverseOperator& inv);
 
public:
    FIFFLIB::FiffInfoBase info;                   
    FIFFLIB::fiff_int_t methods;                  
    FIFFLIB::fiff_int_t source_ori;               
    FIFFLIB::fiff_int_t nsource;                  
    FIFFLIB::fiff_int_t nchan;                    
    FIFFLIB::fiff_int_t coord_frame;              
    FIFFLIB::fiff_int_t units;                    
    Eigen::MatrixXf source_nn;                    
    Eigen::VectorXd sing;                         
    bool eigen_leads_weighted;                    
    FIFFLIB::FiffNamedMatrix::SDPtr eigen_leads;  
    FIFFLIB::FiffNamedMatrix::SDPtr eigen_fields; 
    FIFFLIB::FiffCov::SDPtr noise_cov;            
    FIFFLIB::FiffCov::SDPtr source_cov;           
    FIFFLIB::FiffCov::SDPtr orient_prior;         
    FIFFLIB::FiffCov::SDPtr depth_prior;          
    FIFFLIB::FiffCov::SDPtr fmri_prior;           
    MNESourceSpaces src;                          
    FIFFLIB::FiffCoordTrans mri_head_t;           
    FIFFLIB::fiff_int_t nave;                     
    QList<FIFFLIB::FiffProj> projs;               
    Eigen::MatrixXd proj;                         
    Eigen::MatrixXd whitener;                     
    Eigen::VectorXd reginv;                       
    Eigen::SparseMatrix<double> noisenorm;        
 
private:
    Eigen::MatrixXd m_K; 
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
inline Eigen::MatrixXd& MNEInverseOperator::getKernel()
{
    return m_K;
}
 
//=============================================================================================================
 
inline Eigen::MatrixXd MNEInverseOperator::getKernel() const
{
    return m_K;
}
 
//=============================================================================================================
 
inline bool MNEInverseOperator::isFixedOrient() const
{
    return this->source_ori == FIFFV_MNE_FIXED_ORI;
}
 
//=============================================================================================================
 
inline std::ostream& operator<<(std::ostream& out, const MNEInverseOperator& inv)
{
    out << "#### MNE Inverse Operator ####\n"
        << "  methods:     " << inv.methods << '\n'
        << "  source_ori:  " << inv.source_ori << '\n'
        << "  nsource:     " << inv.nsource << '\n'
        << "  nchan:       " << inv.nchan << '\n'
        << "  coord_frame: " << inv.coord_frame << '\n'
        << "  eigen_leads: " << *inv.eigen_leads << '\n'
        << "  eigen_fields:" << *inv.eigen_fields << '\n';
    return out;
}
} // NAMESPACE
 
#ifndef metatype_mneinverseoperatorsptr
#define metatype_mneinverseoperatorsptr
Q_DECLARE_METATYPE(QSharedPointer<MNELIB::MNEInverseOperator>); 
#endif
 
#ifndef metatype_mneinverseoperators
#define metatype_mneinverseoperators
Q_DECLARE_METATYPE(MNELIB::MNEInverseOperator); 
#endif
 
#endif // MNE_INVERSE_OPERATOR_H