fiff_cov.h

Go to the documentation of this file.

//=============================================================================================================
#ifndef FIFF_COV_H
#define FIFF_COV_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "fiff_global.h"
#include "fiff_proj.h"
#include "fiff_types.h"
#include "fiff_info.h"
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QSharedDataPointer>
#include <QSharedPointer>
#include <QString>
#include <QStringList>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// DEFINE NAMESPACE MNELIB
//=============================================================================================================
 
namespace FIFFLIB
{
 
//=============================================================================================================
class FIFFSHARED_EXPORT FiffCov : public QSharedData
{
public:
    typedef QSharedPointer<FiffCov> SPtr;               
    typedef QSharedPointer<const FiffCov> ConstSPtr;    
    typedef QSharedDataPointer<FiffCov> SDPtr;       
    //=========================================================================================================
    FiffCov();
 
    //=========================================================================================================
    FiffCov(QIODevice &p_IODevice);
 
    //=========================================================================================================
    FiffCov(const FiffCov &p_FiffCov);
 
    //=========================================================================================================
    ~FiffCov();
 
    //=========================================================================================================
    void clear();
 
    //=========================================================================================================
    inline bool isEmpty() const;
 
    //=========================================================================================================
    FiffCov pick_channels(const QStringList &p_include = defaultQStringList, const QStringList &p_exclude = defaultQStringList);
 
    //=========================================================================================================
    FiffCov prepare_noise_cov(const FiffInfo& p_info, const QStringList& p_chNames) const;
 
    //=========================================================================================================
    FiffCov regularize(const FiffInfo& p_info, double p_fMag = 0.1, double p_fGrad = 0.1, double p_fEeg = 0.1, bool p_bProj = true, QStringList p_exclude = defaultQStringList) const;
 
    //=========================================================================================================
    FiffCov& operator= (const FiffCov &rhs);
 
    //=========================================================================================================
    friend std::ostream& operator<<(std::ostream& out, const FIFFLIB::FiffCov &p_FiffCov);
 
public:
    fiff_int_t  kind;       
    Eigen::VectorXi chClass;
    bool diag;              
    fiff_int_t dim;         
    QStringList names;      
    Eigen::MatrixXd data;   
    QList<FiffProj> projs;  
    QStringList bads;       
    fiff_int_t nfree;       
    Eigen::VectorXd eig;    
    Eigen::MatrixXd eigvec; 
// ### OLD STRUCT ###
// typedef struct {     /* Covariance matrix storage */
//    int        kind;      /* Sensor or source covariance */
//    int        ncov;      /* Dimension */
//    int        nfree;     /* Number of degrees of freedom */
//    int        nproj;     /* Number of dimensions projected out */
//    int        nzero;     /* Number of zero or small eigenvalues */
//    char       **names;       /* Names of the entries (optional) */
//    double     *cov;      /* Covariance matrix in packed representation (lower triangle) */
//    double     *cov_diag;     /* Diagonal covariance matrix */
//    mneSparseMatrix cov_sparse;   /* A sparse covariance matrix
//         * (Note: data are floats in this which is an inconsistency) */
//    double     *lambda;       /* Eigenvalues of cov */
//    double     *inv_lambda;   /* Inverses of the square roots of the eigenvalues of cov */
//    float      **eigen;       /* Eigenvectors of cov */
//    double     *chol;     /* Cholesky decomposition */
//    mneProjOp  proj;      /* The projection which was active when this matrix was computed */
//    mneSssData sss;       /* The SSS data present in the associated raw data file */
//    int        *ch_class;     /* This will allow grouping of channels for regularization (MEG [T/m], MEG [T], EEG [V] */
//    char       **bads;        /* Which channels were designated bad when this noise covariance matrix was computed? */
//    int        nbad;      /* How many of them */
// } *mneCovMatrix,mneCovMatrixRec;
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
inline bool FiffCov::isEmpty() const
{
    return this->dim <= -1;
}
 
//=============================================================================================================
 
inline std::ostream& operator<<(std::ostream& out, const FIFFLIB::FiffCov &p_FiffCov)
{
    bool t_bIsShort = true;
    out << "#### Fiff Covariance ####\n";
    out << "\tKind: " << p_FiffCov.kind << std::endl;
    out << "\tdiag: " << p_FiffCov.diag << std::endl;
    out << "\tdim: " << p_FiffCov.dim << std::endl;
    out << "\tnames " << p_FiffCov.names.size() << ":\n\t";
 
    if(t_bIsShort)
    {
        qint32 nchan = p_FiffCov.names.size() > 6 ? 6 : p_FiffCov.names.size();
        for(qint32 i = 0; i < nchan/2; ++i)
            out << p_FiffCov.names[i].toUtf8().constData() << " ";
        out << "... ";
        for(qint32 i = p_FiffCov.names.size() - nchan/2; i < p_FiffCov.names.size(); ++i)
            out << p_FiffCov.names[i].toUtf8().constData() << " ";
        out << std::endl;
    }
 
    out << "\tdata " << p_FiffCov.data.rows() << " x " << p_FiffCov.data.cols() << ":\n\t";
    if(t_bIsShort)
    {
        qint32 nrows = p_FiffCov.data.rows() > 6 ? 6 : p_FiffCov.data.rows();
        qint32 ncols = p_FiffCov.data.cols() > 6 ? 6 : p_FiffCov.data.cols();
        for(qint32 i = 0; i < nrows/2; ++i)
        {
            for(qint32 j = 0; j < ncols/2; ++j)
                out << p_FiffCov.data(i,j) << " ";
            out << "... ";
            for(qint32 j = p_FiffCov.data.cols() - ncols/2; j < p_FiffCov.data.cols(); ++j)
                out << p_FiffCov.data(i,j) << " ";
            out << "\n\t";
        }
        out << "...\n\t";
        for(qint32 i = p_FiffCov.data.rows()-nrows/2; i < p_FiffCov.data.rows(); ++i)
        {
            for(qint32 j = 0; j < ncols/2; ++j)
                out << p_FiffCov.data(i,j) << " ";
            out << "... ";
            for(qint32 j = p_FiffCov.data.cols() - ncols/2; j < p_FiffCov.data.cols(); ++j)
                out << p_FiffCov.data(i,j) << " ";
            out << "\n\t";
        }
        out << "\n";
    }
    //Projectors
    out << "\tprojectors " << p_FiffCov.projs.size() << ":\n";
    for(qint32 i = 0; i < p_FiffCov.projs.size(); ++i)
        out << "\t" << p_FiffCov.projs[i];
 
    //Bads
    out << "\tbads " << p_FiffCov.bads.size() << ":\n\t";
    for(qint32 i = 0; i < p_FiffCov.bads.size(); ++i)
        out << p_FiffCov.bads[i].toUtf8().constData() << " ";
 
    out << "\n\tfree: " << p_FiffCov.nfree << std::endl;
 
    out << "\teig " << p_FiffCov.eig.size() << ":\n\t";
    if(t_bIsShort)
    {
        qint32 nrows = p_FiffCov.eig.size() > 6 ? 6 : p_FiffCov.eig.size();
        for(qint32 i = 0; i < nrows/2; ++i)
            out << p_FiffCov.eig[i] << " ";
        out << "... ";
        for(qint32 i = p_FiffCov.eig.size() - nrows/2; i < p_FiffCov.eig.size(); ++i)
            out << p_FiffCov.eig[i] << " ";
        out << "\n\t";
    }
 
    out << "\n\teigvec " << p_FiffCov.eigvec.rows() << " x " << p_FiffCov.eigvec.cols() << ":\n\t";
    if(t_bIsShort)
    {
        qint32 nrows = p_FiffCov.eigvec.rows() > 6 ? 6 : p_FiffCov.eigvec.rows();
        qint32 ncols = p_FiffCov.eigvec.cols() > 6 ? 6 : p_FiffCov.eigvec.cols();
        for(qint32 i = 0; i < nrows/2; ++i)
        {
            for(qint32 j = 0; j < ncols/2; ++j)
                out << p_FiffCov.eigvec(i,j) << " ";
            out << "... ";
            for(qint32 j = p_FiffCov.eigvec.cols() - ncols/2; j < p_FiffCov.eigvec.cols(); ++j)
                out << p_FiffCov.eigvec(i,j) << " ";
            out << "\n\t";
        }
        out << "...\n\t";
        for(qint32 i = p_FiffCov.eigvec.rows() - nrows/2; i < p_FiffCov.eigvec.rows(); ++i)
        {
            for(qint32 j = 0; j < ncols/2; ++j)
                out << p_FiffCov.eigvec(i,j) << " ";
            out << "... ";
            for(qint32 j = p_FiffCov.eigvec.cols() - ncols/2; j < p_FiffCov.eigvec.cols(); ++j)
                out << p_FiffCov.eigvec(i,j) << " ";
            out << "\n\t";
        }
        out << "\n";
    }
    return out;
}
} // NAMESPACE
 
#ifndef metatype_fiffcovsptr
#define metatype_fiffcovsptr
Q_DECLARE_METATYPE(QSharedPointer<FIFFLIB::FiffCov>); 
#endif
 
#ifndef metatype_fiffcov
#define metatype_fiffcov
Q_DECLARE_METATYPE(FIFFLIB::FiffCov); 
#endif
 
#endif // FIFF_COV_H