mne.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef MNE_H
#define MNE_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "mne_global.h"
 
#include "mne_inverse_operator.h"
#include "mne_forwardsolution.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 <utils/mnemath.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::MNEMath::combine_xyz(vec);
    }
 
    //=========================================================================================================
    //    static inline Eigen::MatrixXd extract_block_diag(MatrixXd& A, qint32 n);
 
    //=========================================================================================================
    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();
    }
 
    //ToDo Why is make_block_diag part of MNEForwardSolution - restructure this
    //=========================================================================================================
    static inline Eigen::SparseMatrix<double>* make_block_diag(const Eigen::MatrixXd &A, qint32 n)
    {
        return UTILSLIB::MNEMath::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 MNEInverseOperator prepare_inverse_operator(MNEInverseOperator& orig,
                                                              qint32 nave,
                                                              float lambda2,
                                                              bool dSPM,
                                                              bool sLORETA = false)
    {
        return orig.prepare_inverse_operator(nave, lambda2, dSPM, sLORETA);
    }
 
    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_inverse_operator(QIODevice& p_pIODevice,
                                      MNEInverseOperator& inv)
    {
        return MNEInverseOperator::read_inverse_operator(p_pIODevice,
                                                         inv);
    }
 
    //=========================================================================================================
    static inline bool read_forward_solution(QIODevice& p_IODevice,
                                             MNEForwardSolution& fwd,
                                             bool force_fixed = false,
                                             bool surf_ori = false,
                                             const QStringList& include = FIFFLIB::defaultQStringList,
                                             const QStringList& exclude = FIFFLIB::defaultQStringList)
    {
        return MNEForwardSolution::read(p_IODevice,
                                        fwd,
                                        force_fixed,
                                        surf_ori,
                                        include,
                                        exclude);
    }
 
    //=========================================================================================================
    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