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_sourcespace.h"
#include "mne_surface.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 <utils/mnemath.h>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QMap>
 
//=============================================================================================================
// 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 MNESourceSpace::find_source_space_hemi(p_Hemisphere);
    }
 
    //=========================================================================================================
    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 MNESourceSpace::patch_info(p_Hemisphere);
    }
 
    //=========================================================================================================
    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);
    }
 
    static bool read_events(QString t_sEventName,
                            QString t_fileRawName,
                            Eigen::MatrixXi& events);
 
// ToDo Eventlist Class??
    //=========================================================================================================
    static bool read_events_from_fif(QIODevice &p_IODevice,
                                     Eigen::MatrixXi& eventlist);
 
    //=========================================================================================================
    static bool read_events_from_ascii(QIODevice &p_IODevice,
                                       Eigen::MatrixXi& eventlist);
 
    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,
                                   MNESourceSpace& p_SourceSpace)
    {
        return MNESourceSpace::readFromStream(p_pStream,
                                              add_geom,
                                              p_SourceSpace);
    }
 
    //=========================================================================================================
    static bool read_bem_surface(FIFFLIB::FiffStream::SPtr& p_pStream,
                                 bool add_geom,
                                 FIFFLIB::FiffDirNode::SPtr& p_Tree,
                                 QList<MNESurface::SPtr>& p_Surfaces)
    {
        return MNESurface::read(p_pStream,
                                add_geom,
                                p_Tree,
                                p_Surfaces);
    }
 
    //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(MNESourceSpace& p_pMNESourceSpace,
                                                 FIFFLIB::fiff_int_t dest,
                                                 FIFFLIB::FiffCoordTrans& trans)
    {
        return p_pMNESourceSpace.transform_source_space_to(dest,
                                                           trans);
    }
 
    //=========================================================================================================
    static inline void transpose_named_matrix(FIFFLIB::FiffNamedMatrix& mat)
    {
        mat.transpose_named_matrix();
    }
};
} // NAMESPACE
 
#endif // MNE_H