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