fiff_stream.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef FIFF_STREAM_H
#define FIFF_STREAM_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "fiff_global.h"
#include "fiff_types.h"
#include "fiff_id.h"
 
#include "fiff_dir_node.h"
#include "fiff_dir_entry.h"
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
#include <Eigen/SparseCore>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QByteArray>
#include <QDataStream>
#include <QIODevice>
#include <QList>
#include <QSharedPointer>
#include <QString>
#include <QStringList>
#include <memory>
 
//=============================================================================================================
// DEFINE NAMESPACE FIFFLIB
//=============================================================================================================
 
namespace FIFFLIB
{
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
class FiffStream;
class FiffTag;
class FiffCtfComp;
class FiffRawData;
class FiffInfo;
class FiffInfoBase;
class FiffCov;
class FiffProj;
class FiffEvokedSet;
class FiffNamedMatrix;
class FiffDigPoint;
class FiffChInfo;
class FiffChPos;
class FiffCoordTrans;
class FiffDigitizerData;
 
//=============================================================================================================
 
class FIFFSHARED_EXPORT FiffStream : public QDataStream
{
public:
    using SPtr = QSharedPointer<FiffStream>;             
    using ConstSPtr = QSharedPointer<const FiffStream>;  
    using UPtr = std::unique_ptr<FiffStream>;            
    using ConstUPtr = std::unique_ptr<const FiffStream>; 
 
    //=========================================================================================================
    explicit FiffStream(QIODevice* p_pIODevice);
 
    //=========================================================================================================
    explicit FiffStream(QByteArray* a, QIODevice::OpenMode mode);
 
    //=========================================================================================================
    QString streamName();
 
    //=========================================================================================================
    FiffId id() const;
 
    //=========================================================================================================
    QList<FiffDirEntry::SPtr>& dir();
 
    //=========================================================================================================
    const QList<FiffDirEntry::SPtr>& dir() const;
 
    //=========================================================================================================
    int nent() const;
 
    //=========================================================================================================
    const FiffDirNode::SPtr& dirtree() const;
 
    //=========================================================================================================
    fiff_long_t end_block(fiff_int_t kind, fiff_int_t next = FIFFV_NEXT_SEQ);
 
    //=========================================================================================================
    void end_file();
 
    //=========================================================================================================
    void finish_writing_raw();
 
    //=========================================================================================================
    bool get_evoked_entries(const QList<FiffDirNode::SPtr>& evoked_node, QStringList& comments, QList<fiff_int_t>& aspect_kinds, QString& t);
 
    //=========================================================================================================
    //    using QFile::open;
 
    //=========================================================================================================
    bool open(QIODevice::OpenModeFlag mode = QIODevice::ReadOnly);
 
    //=========================================================================================================
    bool close();
 
    //=========================================================================================================
    FiffDirNode::SPtr make_subtree(QList<FiffDirEntry::SPtr>& dentry);
 
    //=========================================================================================================
    QStringList read_bad_channels(const FiffDirNode::SPtr& p_Node);
 
    //=========================================================================================================
    void write_bad_channels(const QStringList& bads);
 
    //=========================================================================================================
    bool attach_env(const QString& workingDir, const QString& command);
 
    //=========================================================================================================
    bool read_cov(const FiffDirNode::SPtr& p_Node, fiff_int_t cov_kind, FiffCov& p_covData);
 
    //=========================================================================================================
    QList<FiffCtfComp> read_ctf_comp(const FiffDirNode::SPtr& p_Node, const QList<FiffChInfo>& p_Chs);
 
    //=========================================================================================================
    bool read_digitizer_data(const FiffDirNode::SPtr& p_Node, FiffDigitizerData& p_digData);
 
    //=========================================================================================================
    bool read_meas_info(const FiffDirNode::SPtr& p_Node, FiffInfo& p_Info, FiffDirNode::SPtr& p_NodeInfo);
 
    //=========================================================================================================
    bool read_meas_info_base(const FiffDirNode::SPtr& p_Node, FiffInfoBase& p_InfoForward);
 
    //=========================================================================================================
    bool read_named_matrix(const FiffDirNode::SPtr& p_Node, fiff_int_t matkind, FiffNamedMatrix& mat);
 
    //=========================================================================================================
    QList<FiffProj> read_proj(const FiffDirNode::SPtr& p_Node);
 
    //=========================================================================================================
    bool read_tag_data(std::unique_ptr<FiffTag>& p_pTag, fiff_long_t pos = -1);
 
    //=========================================================================================================
    fiff_long_t read_tag_info(std::unique_ptr<FiffTag>& p_pTag, bool p_bDoSkip = true);
 
    //=========================================================================================================
    bool read_rt_tag(std::unique_ptr<FiffTag>& p_pTag);
 
    //=========================================================================================================
    bool read_tag(std::unique_ptr<FiffTag>& p_pTag,
                  fiff_long_t pos = -1);
 
    //=========================================================================================================
    static bool setup_read_raw(QIODevice& p_IODevice,
                               FiffRawData& data,
                               bool allow_maxshield = true,
                               bool is_littleEndian = false);
 
    //=========================================================================================================
    static QStringList split_name_list(QString p_sNameList);
 
    //=========================================================================================================
    fiff_long_t start_block(fiff_int_t kind);
 
    //=========================================================================================================
    static FiffStream::SPtr start_file(QIODevice& p_IODevice);
 
    //=========================================================================================================
    static FiffStream::SPtr open_update(QIODevice& p_IODevice);
 
    //=========================================================================================================
    static FiffStream::SPtr start_writing_raw(QIODevice& p_IODevice,
                                              const FiffInfo& info,
                                              Eigen::RowVectorXd& cals,
                                              Eigen::MatrixXi sel = defaultMatrixXi,
                                              bool bResetRange = true);
 
    //=========================================================================================================
    fiff_long_t write_tag(const std::unique_ptr<FiffTag>& p_pTag, fiff_long_t pos = -1);
 
    //=========================================================================================================
    fiff_long_t write_ch_info(const FiffChInfo& ch);
 
    //=========================================================================================================
    fiff_long_t write_ch_pos(const FiffChPos& chpos);
 
    //=========================================================================================================
    fiff_long_t write_coord_trans(const FiffCoordTrans& trans);
 
    //=========================================================================================================
    fiff_long_t write_cov(const FiffCov& p_FiffCov);
 
    //=========================================================================================================
    fiff_long_t write_ctf_comp(const QList<FiffCtfComp>& comps);
 
    //=========================================================================================================
    fiff_long_t write_dig_point(const FiffDigPoint& dig);
 
    //=========================================================================================================
    fiff_long_t write_dir_pointer(fiff_int_t dirpos, fiff_long_t pos = -1, fiff_int_t next = FIFFV_NEXT_SEQ);
 
    //=========================================================================================================
    fiff_long_t write_dir_entries(const QList<FiffDirEntry::SPtr>& dir, fiff_long_t pos = -1);
 
    //=========================================================================================================
    fiff_long_t write_double(fiff_int_t kind, const double* data, fiff_int_t nel = 1);
 
    //=========================================================================================================
    fiff_long_t write_id(fiff_int_t kind, const FiffId& id = FiffId::getDefault());
 
    //=========================================================================================================
    fiff_long_t write_info_base(const FiffInfoBase& p_FiffInfoBase);
 
    //=========================================================================================================
    fiff_long_t write_int(fiff_int_t kind, const fiff_int_t* data, fiff_int_t nel = 1, fiff_int_t next = FIFFV_NEXT_SEQ);
 
    //=========================================================================================================
    fiff_long_t write_int_matrix(fiff_int_t kind, const Eigen::MatrixXi& mat);
 
    //=========================================================================================================
    fiff_long_t write_float(fiff_int_t kind, const float* data, fiff_int_t nel = 1);
 
    //=========================================================================================================
    fiff_long_t write_float_matrix(fiff_int_t kind, const Eigen::MatrixXf& mat);
 
    //=========================================================================================================
    fiff_long_t write_float_sparse_ccs(fiff_int_t kind, const Eigen::SparseMatrix<float>& mat);
 
    //=========================================================================================================
    fiff_long_t write_float_sparse_rcs(fiff_int_t kind, const Eigen::SparseMatrix<float>& mat);
 
    //=========================================================================================================
    fiff_long_t write_name_list(fiff_int_t kind, const QStringList& data);
 
    //=========================================================================================================
    fiff_long_t write_named_matrix(fiff_int_t kind, const FiffNamedMatrix& mat);
 
    //=========================================================================================================
    fiff_long_t write_evoked_set(const FiffEvokedSet& p_FiffEvokedSet);
 
    //=========================================================================================================
    fiff_long_t write_proj(const QList<FiffProj>& projs);
 
    //=========================================================================================================
    bool write_raw_buffer(const Eigen::MatrixXd& buf, const Eigen::RowVectorXd& cals);
 
    //=========================================================================================================
    bool write_raw_buffer(const Eigen::MatrixXd& buf, const Eigen::SparseMatrix<double>& mult);
 
    //=========================================================================================================
    bool write_raw_buffer(const Eigen::MatrixXd& buf);
 
    //=========================================================================================================
    fiff_long_t write_string(fiff_int_t kind, const QString& data);
 
    //=========================================================================================================
    void write_rt_command(fiff_int_t command, const QString& data);
 
    //=========================================================================================================
    static bool copyProcessingHistory(const QString& fromPath, const QString& toPath);
 
private:
    //=========================================================================================================
    bool check_beginning(std::unique_ptr<FiffTag>& p_pTag);
 
    //=========================================================================================================
    QList<FiffDirEntry::SPtr> make_dir(bool* ok = nullptr);
 
private:
    //    char         *file_name;    /**< Name of the file. */ -> Use streamName() instead
    //    FILE         *fd;           /**< The normal file descriptor. */ -> file descitpion is part of the stream: stream->device()
    FiffId m_id;                     
    QList<FiffDirEntry::SPtr> m_dir; 
                                     //    int         nent;           /**< How many entries? */ -> Use nent() instead
    FiffDirNode::SPtr m_dirtree;     
    //    char        *ext_file_name; /**< Name of the file holding the external data. */
    //    FILE        *ext_fd;        /**< The file descriptor of the above file if open . */
};
} // NAMESPACE
 
#endif // FIFF_STREAM_H