mne_cov_matrix.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef MNECOVMATRIX_H
#define MNECOVMATRIX_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "mne_global.h"
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// STL INCLUDES
//=============================================================================================================
 
#include <memory>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QSharedPointer>
#include <QStringList>

#define MNE_COV_CH_UNKNOWN  -1  
#define MNE_COV_CH_MEG_MAG   0  
#define MNE_COV_CH_MEG_GRAD  1  
#define MNE_COV_CH_EEG       2  
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
namespace FIFFLIB
{
    class FiffSparseMatrix;
    class FiffChInfo;
}
 
//=============================================================================================================
// DEFINE NAMESPACE MNELIB
//=============================================================================================================
 
namespace MNELIB
{
 
//=============================================================================================================
// MNELIB FORWARD DECLARATIONS
//=============================================================================================================
 
class MNEProjOp;
class MNESssData;
 
//=============================================================================================================
class MNESHARED_EXPORT MNECovMatrix
{
public:
    typedef QSharedPointer<MNECovMatrix> SPtr;              
    typedef QSharedPointer<const MNECovMatrix> ConstSPtr;   
 
    //=========================================================================================================
    MNECovMatrix(int p_kind, int p_ncov, const QStringList& p_names, const Eigen::VectorXd& p_cov, const Eigen::VectorXd& p_cov_diag, FIFFLIB::FiffSparseMatrix* p_cov_sparse);
 
    //=========================================================================================================
    ~MNECovMatrix();
 
    //=========================================================================================================
    std::unique_ptr<MNECovMatrix> dup() const;
 
    //=========================================================================================================
    static std::unique_ptr<MNECovMatrix> create_dense(int    kind,
                                   int    ncov,
                                   const QStringList& names,
                                   const Eigen::VectorXd& cov)
    {
        return std::unique_ptr<MNECovMatrix>(new MNECovMatrix(kind,ncov,names,cov,Eigen::VectorXd(),nullptr));
    }
 
    //=========================================================================================================
    static std::unique_ptr<MNECovMatrix> create_diag(int    kind,
                                  int    ncov,
                                  const QStringList& names,
                                  const Eigen::VectorXd& cov_diag)
    {
        return std::unique_ptr<MNECovMatrix>(new MNECovMatrix(kind,ncov,names,Eigen::VectorXd(),cov_diag,nullptr));
    }
 
    //=========================================================================================================
    static std::unique_ptr<MNECovMatrix> create_sparse(    int kind,
                                                int ncov,
                                                const QStringList& names,
                                                FIFFLIB::FiffSparseMatrix* cov_sparse)
    {
        return std::unique_ptr<MNECovMatrix>(new MNECovMatrix(kind,ncov,names,Eigen::VectorXd(),Eigen::VectorXd(),cov_sparse));
    }
 
    //=========================================================================================================
    static std::unique_ptr<MNECovMatrix> create(   int kind,
                                        int ncov,
                                        const QStringList& names,
                                        const Eigen::VectorXd& cov,
                                        const Eigen::VectorXd& cov_diag)
    {
        return std::unique_ptr<MNECovMatrix>(new MNECovMatrix(kind,ncov,names,cov,cov_diag,nullptr));
    }
 
    //=========================================================================================================
    static std::unique_ptr<MNECovMatrix> read(const QString& name, int kind);
 
    //=========================================================================================================
    int is_diag() const;
 
    //=========================================================================================================
    int add_inv();
 
    //=========================================================================================================
    int condition(float rank_threshold, int use_rank);
 
    //=========================================================================================================
    int decompose_eigen_small(float p_small, int use_rank);
 
    //=========================================================================================================
    int decompose_eigen();
 
    //=========================================================================================================
    static int lt_packed_index(int j, int k);
 
    //=========================================================================================================
    int classify_channels(const QList<FIFFLIB::FiffChInfo>& chs, int nchan);
 
    //=========================================================================================================
    int whiten_vector(Eigen::Ref<Eigen::VectorXf> data, Eigen::Ref<Eigen::VectorXf> whitened_data, int nchan) const;
 
    //=========================================================================================================
    void regularize(const Eigen::Vector3f& regs);
 
    //=========================================================================================================
    void revert_to_diag();
 
    //=========================================================================================================
    std::unique_ptr<MNECovMatrix> pick_chs_omit(const QStringList& new_names,
                                                int new_ncov,
                                                int omit_meg_eeg,
                                                const QList<FIFFLIB::FiffChInfo>& chs) const;
 
    int         kind;                           
    int         ncov;                           
    int         nfree;                          
    int         nproj;                          
    int         nzero;                          
    QStringList names;                          
    Eigen::VectorXd cov;                        
    Eigen::VectorXd cov_diag;                   
    std::unique_ptr<FIFFLIB::FiffSparseMatrix> cov_sparse;   
    Eigen::VectorXd lambda;                     
    Eigen::VectorXd inv_lambda;                 
    Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> eigen;  
    std::unique_ptr<MNEProjOp> proj;            
    std::unique_ptr<MNESssData> sss;            
    Eigen::VectorXi ch_class;                   
    QStringList bads;                           
    int         nbad;                           
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
} // NAMESPACE MNELIB
 
#endif // MNECOVMATRIX_H