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>
#include <memory>
 
//=============================================================================================================
// DEFINE NAMESPACE MNELIB
//=============================================================================================================
 
namespace FIFFLIB
{
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
class FiffRawData;
struct RejectionParams;
 
//=============================================================================================================
class FIFFSHARED_EXPORT FiffCov : public QSharedData
{
public:
    using SPtr = QSharedPointer<FiffCov>;             
    using ConstSPtr = QSharedPointer<const FiffCov>;  
    using UPtr = std::unique_ptr<FiffCov>;            
    using ConstUPtr = std::unique_ptr<const FiffCov>; 
    using SDPtr = QSharedDataPointer<FiffCov>;        
 
    //=========================================================================================================
    FiffCov();
 
    //=========================================================================================================
    FiffCov(QIODevice& p_IODevice);
 
    //=========================================================================================================
    static bool read(QIODevice& p_IODevice, FiffCov& p_cov);
 
    //=========================================================================================================
    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;
 
    //=========================================================================================================
    static FiffCov compute_from_epochs(const FiffRawData& raw,
                                       const Eigen::MatrixXi& events,
                                       const QList<int>& eventCodes,
                                       float tmin,
                                       float tmax,
                                       float bmin = 0.0f,
                                       float bmax = 0.0f,
                                       bool doBaseline = false,
                                       bool removeMean = true,
                                       unsigned int ignoreMask = 0,
                                       float delay = 0.0f,
                                       const RejectionParams* rej = nullptr);
 
    //=========================================================================================================
    static FiffCov compute_from_epochs(const QList<QList<Eigen::MatrixXd>>& epochs,
                                       const FiffInfo& info,
                                       bool removeMean = true);
 
    //=========================================================================================================
    bool save(const QString& fileName) const;
 
    //=========================================================================================================
    static FiffCov computeGrandAverage(const QList<FiffCov>& covs);
 
    //=========================================================================================================
    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;  
};
 
//=============================================================================================================
// 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