fiff.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef FIFF_H
#define FIFF_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "fiff_global.h"
#include "fiff_constants.h"
#include "fiff_coord_trans.h"
#include "fiff_dir_node.h"
#include "fiff_dir_entry.h"
#include "fiff_named_matrix.h"
#include "fiff_tag.h"
#include "fiff_types.h"
#include "fiff_proj.h"
#include "fiff_ctf_comp.h"
#include "fiff_info.h"
#include "fiff_raw_data.h"
#include "fiff_raw_dir.h"
#include "fiff_stream.h"
#include "fiff_evoked_set.h"
#include "fiff_events.h"
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QIODevice>
#include <QList>
#include <QStringList>
 
//=============================================================================================================
// DEFINE NAMESPACE FIFFLIB
//=============================================================================================================
 
namespace FIFFLIB
{
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
class FIFFSHARED_EXPORT Fiff
{
public:
    //=========================================================================================================
    virtual ~Fiff()
    {
    }
 
    //Alphabetic ordered MNE Toolbox fiff_function
    //=========================================================================================================
    inline static bool copy_tree(FiffStream::SPtr p_pStreamIn, const FiffId& in_id, const QList<FiffDirNode::SPtr>& p_Nodes, FiffStream::SPtr& p_pStreamOut)
    {
        return FiffDirNode::copy_tree(p_pStreamIn, in_id, p_Nodes, p_pStreamOut);
    }
 
    //=========================================================================================================
    inline static void end_block(FiffStream* p_pStream, fiff_int_t kind)
    {
        p_pStream->end_block(kind);
    }
 
    //=========================================================================================================
    inline static void end_file(FiffStream* p_pStream)
    {
        p_pStream->end_file();
    }
 
    //=========================================================================================================
    inline static void finish_writing_raw(FiffStream* p_pStream)
    {
        p_pStream->finish_writing_raw();
    }
 
    //=========================================================================================================
    inline static QList<FiffDirNode::SPtr> dir_tree_find(const FiffDirNode::SPtr& p_Node, fiff_int_t p_kind)
    {
        return p_Node->dir_tree_find(p_kind);
    }
 
    //=========================================================================================================
    inline static bool invert_transform(FiffCoordTrans& p_Transform)
    {
        return p_Transform.invert_transform();
    }
 
    //=========================================================================================================
    static bool open(QIODevice& p_IODevice, FiffStream::SPtr& p_pStream)
    {
        p_pStream = FiffStream::SPtr(new FiffStream(&p_IODevice));
 
        return p_pStream->open();
    }
 
    //=========================================================================================================
    inline static Eigen::RowVectorXi pick_channels(QStringList& ch_names,
                                                   const QStringList& include = defaultQStringList,
                                                   const QStringList& exclude = defaultQStringList)
    {
        return FiffInfo::pick_channels(ch_names, include, exclude);
    }
 
    //=========================================================================================================
    inline static FiffEvokedSet pick_channels(FiffEvokedSet& orig,
                                              const QStringList& include = defaultQStringList,
                                              const QStringList& exclude = defaultQStringList)
    {
        return orig.pick_channels(include, exclude);
    }
 
    //=========================================================================================================
    inline static bool find_evoked(FiffEvokedSet& orig)
    {
        return orig.find_evoked(orig);
    }
 
    //=========================================================================================================
    inline static FiffInfo pick_info(const FiffInfo& info,
                                     const Eigen::RowVectorXi& sel = defaultVectorXi)
    {
        return info.pick_info(sel);
    }
 
    //=========================================================================================================
    inline static Eigen::RowVectorXi pick_types(FiffInfo& info,
                                                bool meg,
                                                bool eeg = false,
                                                bool stim = false,
                                                const QStringList& include = defaultQStringList,
                                                const QStringList& exclude = defaultQStringList)
    {
        return info.pick_types(meg, eeg, stim, include, exclude);
    }
 
    //=========================================================================================================
    static inline QStringList read_bad_channels(FiffStream::SPtr& p_pStream,
                                                FiffDirNode::SPtr& p_Node)
    {
        return p_pStream->read_bad_channels(p_Node);
    }
 
    //=========================================================================================================
    static inline QList<FiffCtfComp> read_ctf_comp(FiffStream::SPtr& p_pStream,
                                                   const FiffDirNode::SPtr& p_Node,
                                                   const QList<FiffChInfo>& p_Chs)
    {
        return p_pStream->read_ctf_comp(p_Node, p_Chs);
    }
 
    //=========================================================================================================
    static inline bool read_evoked(QIODevice& p_IODevice,
                                   FiffEvoked& data,
                                   QVariant setno = 0,
                                   QPair<float, float> baseline = defaultFloatPair,
                                   bool proj = true,
                                   fiff_int_t p_aspect_kind = FIFFV_ASPECT_AVERAGE)
    {
        return FiffEvoked::read(p_IODevice, data, setno, baseline, proj, p_aspect_kind);
    }
 
    //=========================================================================================================
    static inline bool read_evoked_set(QIODevice& p_IODevice, FiffEvokedSet& data)
    {
        return FiffEvokedSet::read(p_IODevice, data);
    }
 
    //=========================================================================================================
    static inline bool read_meas_info(FiffStream::SPtr& p_pStream, const FiffDirNode::SPtr& p_Node, FiffInfo& p_Info, FiffDirNode::SPtr& p_NodeInfo)
    {
        return p_pStream->read_meas_info(p_Node, p_Info, p_NodeInfo);
    }
 
    //=========================================================================================================
    static inline bool read_named_matrix(FiffStream::SPtr& p_pStream, const FiffDirNode::SPtr& p_Node, fiff_int_t matkind, FiffNamedMatrix& mat)
    {
        return p_pStream->read_named_matrix(p_Node, matkind, mat);
    }
 
    //=========================================================================================================
    static inline QList<FiffProj> read_proj(FiffStream::SPtr& p_pStream, const FiffDirNode::SPtr& p_Node)
    {
        return p_pStream->read_proj(p_Node);
    }
 
    //=========================================================================================================
    inline static bool read_raw_segment(FiffRawData& raw,
                                        Eigen::MatrixXd& data,
                                        Eigen::MatrixXd& times,
                                        fiff_int_t from = -1,
                                        fiff_int_t to = -1,
                                        Eigen::MatrixXi sel = defaultMatrixXi)
    {
        return raw.read_raw_segment(data, times, from, to, sel);
    }

    inline static bool read_raw_segment(FiffRawData& raw,
                                        Eigen::MatrixXd& data,
                                        Eigen::MatrixXd& times,
                                        Eigen::SparseMatrix<double>& mult,
                                        fiff_int_t from = -1,
                                        fiff_int_t to = -1,
                                        Eigen::MatrixXi sel = defaultMatrixXi)
    {
        return raw.read_raw_segment(data, times, mult, from, to, sel);
    }
 
    //=========================================================================================================
    inline static bool read_tag(FiffStream::SPtr& p_pStream, FiffTag::UPtr& p_pTag, qint64 pos = -1)
    {
        return p_pStream->read_tag(p_pTag, pos);
    }
 
    //=========================================================================================================
    static inline bool read_tag_info(FiffStream::SPtr& p_pStream, FiffTag::UPtr& p_pTag)
    {
        return p_pStream->read_tag_info(p_pTag);
    }
 
    //=========================================================================================================
    inline static bool setup_read_raw(QIODevice& p_IODevice, FiffRawData& data, bool allow_maxshield = false)
    {
        return FiffStream::setup_read_raw(p_IODevice, data, allow_maxshield);
    }
 
    //=========================================================================================================
    inline static QStringList split_name_list(QString p_sNameList)
    {
        return FiffStream::split_name_list(p_sNameList);
    }
 
    //=========================================================================================================
    inline static void start_block(FiffStream* p_pStream, fiff_int_t kind)
    {
        p_pStream->start_block(kind);
    }
 
    //=========================================================================================================
    inline static FiffStream::SPtr start_file(QIODevice& p_IODevice)
    {
        return FiffStream::start_file(p_IODevice);
    }
 
    //=========================================================================================================
    inline static FiffStream::SPtr start_writing_raw(QIODevice& p_IODevice,
                                                     const FiffInfo& info,
                                                     Eigen::RowVectorXd& cals,
                                                     Eigen::MatrixXi sel = defaultMatrixXi)
    {
        return FiffStream::start_writing_raw(p_IODevice, info, cals, sel);
    }
 
    //=========================================================================================================
    inline static void write_ch_info(FiffStream* p_pStream, const FiffChInfo& ch)
    {
        p_pStream->write_ch_info(ch);
    }
 
    //=========================================================================================================
    inline static void write_coord_trans(FiffStream* p_pStream, FiffCoordTrans& trans)
    {
        p_pStream->write_coord_trans(trans);
    }
 
    //=========================================================================================================
    inline static void write_ctf_comp(FiffStream* p_pStream, QList<FiffCtfComp>& comps)
    {
        p_pStream->write_ctf_comp(comps);
    }
 
    //=========================================================================================================
    inline static void write_dig_point(FiffStream* p_pStream, FiffDigPoint& dig)
    {
        p_pStream->write_dig_point(dig);
    }
 
    //=========================================================================================================
    inline static void write_id(FiffStream* p_pStream, fiff_int_t kind, FiffId& id = FiffId::getDefault())
    {
        p_pStream->write_id(kind, id);
    }
 
    //=========================================================================================================
    inline static void write_int(FiffStream* p_pStream, fiff_int_t kind, const fiff_int_t* data, fiff_int_t nel = 1)
    {
        p_pStream->write_int(kind, data, nel);
    }
 
    //=========================================================================================================
    inline static void write_float(FiffStream* p_pStream, fiff_int_t kind, float* data, fiff_int_t nel = 1)
    {
        p_pStream->write_float(kind, data, nel);
    }
 
    //=========================================================================================================
    inline static void write_float_matrix(FiffStream* p_pStream, fiff_int_t kind, Eigen::MatrixXf& mat)
    {
        p_pStream->write_float_matrix(kind, mat);
    }
 
    //=========================================================================================================
    inline static void write_name_list(FiffStream* p_pStream, fiff_int_t kind, QStringList& data)
    {
        p_pStream->write_name_list(kind, data);
    }
 
    //=========================================================================================================
    inline static void write_named_matrix(FiffStream* p_pStream, fiff_int_t kind, FiffNamedMatrix& mat)
    {
        p_pStream->write_named_matrix(kind, mat);
    }
 
    //=========================================================================================================
    inline static void write_proj(FiffStream* p_pStream, QList<FiffProj>& projs)
    {
        p_pStream->write_proj(projs);
    }
 
    //=========================================================================================================
    inline static bool write_raw_buffer(FiffStream* p_pStream, const Eigen::MatrixXd& buf, const Eigen::MatrixXd& cals)
    {
        return p_pStream->write_raw_buffer(buf, cals);
    }
 
    //=========================================================================================================
    inline static void write_string(FiffStream* p_pStream, fiff_int_t kind, QString& data)
    {
        p_pStream->write_string(kind, data);
    }
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
} // NAMESPACE
 
#endif // FIFF_H