mne.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef MNE_H
#define MNE_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "mne_global.h"
 
#include "mne_hemisphere.h"
#include "mne_source_spaces.h"
#include "mne_bem.h"
#include "mne_bem_surface.h"
#include "mne_epoch_data_list.h"
 
#include <fiff/fiff_constants.h>
#include <fiff/fiff_cov.h>
#include <fiff/fiff_proj.h>
#include <fiff/fiff_events.h>
#include <fiff/fiff_evoked_set.h>
#include <fiff/fiff_raw_data.h>
 
#include <math/linalg.h>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QMap>
#include <QList>
 
//=============================================================================================================
// DEFINE NAMESPACE MNELIB
//=============================================================================================================
 
namespace MNELIB
{
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
 
class MNESHARED_EXPORT MNE
{
public:
    //=========================================================================================================
    virtual ~MNE()
    {
    }
 
    //=========================================================================================================
    inline static Eigen::VectorXd combine_xyz(const Eigen::VectorXd& vec)
    {
        return UTILSLIB::Linalg::combine_xyz(vec);
    }
 
    //=========================================================================================================
    inline static qint32 find_source_space_hemi(MNEHemisphere& p_Hemisphere)
    {
        return p_Hemisphere.find_source_space_hemi();
    }
 
    //=========================================================================================================
    static inline qint32 get_current_comp(FIFFLIB::FiffInfo* info)
    {
        return info->get_current_comp();
    }
 
    //=========================================================================================================
    static inline Eigen::SparseMatrix<double> make_block_diag(const Eigen::MatrixXd& A, qint32 n)
    {
        return UTILSLIB::Linalg::make_block_diag(A, n);
    }
 
    //=========================================================================================================
    inline static bool make_compensator(const FIFFLIB::FiffInfo& info,
                                        FIFFLIB::fiff_int_t from,
                                        FIFFLIB::fiff_int_t to,
                                        FIFFLIB::FiffCtfComp& ctf_comp,
                                        bool exclude_comp_chs = false)
    {
        return info.make_compensator(from, to, ctf_comp, exclude_comp_chs);
    }
 
    //=========================================================================================================
    inline static FIFFLIB::fiff_int_t make_projector(const QList<FIFFLIB::FiffProj>& projs,
                                                     const QStringList& ch_names,
                                                     Eigen::MatrixXd& proj,
                                                     const QStringList& bads = FIFFLIB::defaultQStringList,
                                                     Eigen::MatrixXd& U = FIFFLIB::defaultMatrixXd)
    {
        return FIFFLIB::FiffProj::make_projector(projs,
                                                 ch_names,
                                                 proj,
                                                 bads,
                                                 U);
    }
 
    //=========================================================================================================
    static inline qint32 make_projector(FIFFLIB::FiffInfo& info,
                                        Eigen::MatrixXd& proj)
    {
        return info.make_projector(proj);
    }
 
    //=========================================================================================================
    static bool patch_info(MNEHemisphere& p_Hemisphere)
    {
        return p_Hemisphere.compute_patch_info();
    }
 
    inline static bool read_events(const QString& t_sEventName,
                                   const QString& t_fileRawName,
                                   Eigen::MatrixXi& events)
    {
        FIFFLIB::FiffEvents fiffEvents;
        if (!FIFFLIB::FiffEvents::read(t_sEventName, t_fileRawName, fiffEvents))
            return false;
        events = fiffEvents.events;
        return true;
    }
 
    //=========================================================================================================
    inline static bool read_events_from_fif(QIODevice& p_IODevice,
                                            Eigen::MatrixXi& eventlist)
    {
        FIFFLIB::FiffEvents fiffEvents;
        if (!FIFFLIB::FiffEvents::read_from_fif(p_IODevice, fiffEvents))
            return false;
        eventlist = fiffEvents.events;
        return true;
    }
 
    //=========================================================================================================
    inline static bool read_events_from_ascii(QIODevice& p_IODevice,
                                              Eigen::MatrixXi& eventlist)
    {
        FIFFLIB::FiffEvents fiffEvents;
        if (!FIFFLIB::FiffEvents::read_from_ascii(p_IODevice, fiffEvents))
            return false;
        eventlist = fiffEvents.events;
        return true;
    }
 
    //=========================================================================================================
    inline static bool write_events_to_fif(QIODevice& p_IODevice,
                                           const Eigen::MatrixXi& eventlist)
    {
        FIFFLIB::FiffEvents fiffEvents;
        fiffEvents.events = eventlist;
        return fiffEvents.write_to_fif(p_IODevice);
    }
 
    //=========================================================================================================
    inline static bool write_events_to_ascii(QIODevice& p_IODevice,
                                             const Eigen::MatrixXi& eventlist,
                                             float sfreq = 0.0f)
    {
        FIFFLIB::FiffEvents fiffEvents;
        fiffEvents.events = eventlist;
        return fiffEvents.write_to_ascii(p_IODevice, sfreq);
    }
 
    //=========================================================================================================
    inline static FIFFLIB::FiffCov compute_epoch_covariance(const FIFFLIB::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)
    {
        return FIFFLIB::FiffCov::compute_from_epochs(raw, events, eventCodes, tmin, tmax, bmin, bmax, doBaseline, removeMean);
    }
 
    //=========================================================================================================
    inline static QList<FIFFLIB::FiffProj> compute_proj(const FIFFLIB::FiffRawData& raw,
                                                        const Eigen::MatrixXi& events,
                                                        int eventCode,
                                                        float tmin,
                                                        float tmax,
                                                        int nGrad,
                                                        int nMag,
                                                        int nEeg,
                                                        const QMap<QString, double>& mapReject = QMap<QString, double>())
    {
        return FIFFLIB::FiffProj::compute_from_raw(raw, events, eventCode, tmin, tmax, nGrad, nMag, nEeg, mapReject);
    }
 
    //=========================================================================================================
    inline static bool save_raw(const FIFFLIB::FiffRawData& raw,
                                QIODevice& p_IODevice,
                                const Eigen::RowVectorXi& picks = Eigen::RowVectorXi(),
                                int decim = 1,
                                int from = -1,
                                int to = -1)
    {
        return raw.save(p_IODevice, picks, decim, from, to);
    }
 
    static void setup_compensators(FIFFLIB::FiffRawData& raw,
                                   FIFFLIB::fiff_int_t dest_comp,
                                   bool keep_comp);
 
    //=========================================================================================================
    inline static bool read_cov(FIFFLIB::FiffStream::SPtr& p_pStream,
                                const FIFFLIB::FiffDirNode::SPtr& p_Node,
                                FIFFLIB::fiff_int_t cov_kind,
                                FIFFLIB::FiffCov& p_covData)
    {
        return p_pStream->read_cov(p_Node,
                                   cov_kind,
                                   p_covData);
    }
 
    //=========================================================================================================
    static bool read_source_spaces(FIFFLIB::FiffStream::SPtr& p_pStream,
                                   bool add_geom,
                                   MNESourceSpaces& p_SourceSpace)
    {
        return MNESourceSpaces::readFromStream(p_pStream,
                                               add_geom,
                                               p_SourceSpace);
    }
 
    //ToDo FiffChInfoList Class
    //=========================================================================================================
    static QList<FIFFLIB::FiffChInfo> set_current_comp(QList<FIFFLIB::FiffChInfo>& chs,
                                                       FIFFLIB::fiff_int_t value)
    {
        return FIFFLIB::FiffInfo::set_current_comp(chs,
                                                   value);
    }
 
    //=========================================================================================================
    static inline bool transform_source_space_to(MNESourceSpaces& p_pMNESourceSpaces,
                                                 FIFFLIB::fiff_int_t dest,
                                                 FIFFLIB::FiffCoordTrans& trans)
    {
        return p_pMNESourceSpaces.transform_source_space_to(dest,
                                                            trans);
    }
 
    //=========================================================================================================
    static inline void transpose_named_matrix(FIFFLIB::FiffNamedMatrix& mat)
    {
        mat.transpose_named_matrix();
    }
};
} // NAMESPACE
 
#endif // MNE_H