mne_inverse_operator.h

//=============================================================================================================
#ifndef MNE_INVERSE_OPERATOR_H
#define MNE_INVERSE_OPERATOR_H

//=============================================================================================================
// INCLUDES
//=============================================================================================================

#include "mne_global.h"
#include "mne_sourcespace.h"
#include "mne_forwardsolution.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>

#include <utils/mnemath.h>

//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================

#include <Eigen/Core>

//=============================================================================================================
// QT INCLUDES
//=============================================================================================================

#include <QList>

//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================

namespace FSLIB
{
    class Label;
}

//=============================================================================================================
// 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
    {
        QString t_sDistMeasure;
         if(sDistMeasure.isEmpty())
             t_sDistMeasure = QString("cityblock");
         else
             t_sDistMeasure = sDistMeasure;

        // Kmeans Reduction
        RegionMTOut p_RegionMTOut;

        UTILSLIB::KMeans t_kMeans(t_sDistMeasure, QString("sample"), 5);

        t_kMeans.calculate(this->matRoiMT, this->nClusters, p_RegionMTOut.roiIdx, p_RegionMTOut.ctrs, p_RegionMTOut.sumd, p_RegionMTOut.D);

        p_RegionMTOut.iLabelIdxOut = this->iLabelIdxIn;

        return p_RegionMTOut;
    }
};

//=============================================================================================================
class MNESHARED_EXPORT MNEInverseOperator
{
public:
    typedef QSharedPointer<MNEInverseOperator> SPtr;            
    typedef QSharedPointer<const MNEInverseOperator> ConstSPtr; 
    //=========================================================================================================
    MNEInverseOperator();

    //=========================================================================================================
    MNEInverseOperator(QIODevice& p_IODevice);

    //=========================================================================================================
    MNEInverseOperator(const FIFFLIB::FiffInfo &info,
                       const MNEForwardSolution& forward,
                       const FIFFLIB::FiffCov& p_noise_cov,
                       float loose = 0.2f,
                       float depth = 0.8f,
                       bool fixed = false,
                       bool limit_depth_chs = true);

    //=========================================================================================================
    MNEInverseOperator(const MNEInverseOperator &p_MNEInverseOperator);

    //=========================================================================================================
    ~MNEInverseOperator();

    //=========================================================================================================
    bool assemble_kernel(const FSLIB::Label &label,
                         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::AnnotationSet &p_AnnotationSet,
                                   qint32 p_iClusterSize,
                                   Eigen::MatrixXd& p_D,
                                   QString p_sMethod = "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& p_noise_cov,
                                                    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);

    //=========================================================================================================
    void write(QIODevice &p_IODevice);

    //=========================================================================================================
    void writeToStream(FIFFLIB::FiffStream* p_pStream);

    //=========================================================================================================
    friend std::ostream& operator<<(std::ostream& out, const MNELIB::MNEInverseOperator &p_MNEInverseOperator);

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;                
    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;             
    MNESourceSpace 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 MNELIB::MNEInverseOperator &p_MNEInverseOperator)
{
    out << "#### MNE Inverse Operator ####\n";

    out << "\n methods: " << p_MNEInverseOperator.methods << std::endl;
    out << "\n source_ori: " << p_MNEInverseOperator.source_ori << std::endl;
    out << "\n nsource: " << p_MNEInverseOperator.nsource << std::endl;
    out << "\n nchan: " << p_MNEInverseOperator.nchan << std::endl;
    out << "\n coord_frame:\n\t" << p_MNEInverseOperator.coord_frame << std::endl;

    out << "\n eigen_leads: " << p_MNEInverseOperator.eigen_leads << std::endl;
    out << "\n eigen_fields:\n\t" << p_MNEInverseOperator.eigen_fields << std::endl;

    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