fiff_io.cpp

Go to the documentation of this file.

//=============================================================================================================
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "fiff_io.h"
#include "fiff.h"
#include "fiff_evoked_set.h"
#include "fiff_stream.h"
 
//=============================================================================================================
// STL INCLUDES
//=============================================================================================================
 
#include <iostream>
#include <stdexcept>
#include <QDebug>
 
//=============================================================================================================
// USED NAMESPACES
//=============================================================================================================
 
using namespace FIFFLIB;
using namespace Eigen;
 
//=============================================================================================================
// DEFINE MEMBER METHODS
//=============================================================================================================
 
FiffIO::FiffIO()
{
}
 
//=============================================================================================================
 
FiffIO::~FiffIO()
{
}
 
//=============================================================================================================
 
FiffIO::FiffIO(QIODevice& pIODevice)
{
    // execute read method
    FiffIO::read(pIODevice);
}
 
//=============================================================================================================
 
FiffIO::FiffIO(QList<QIODevice*>& p_qlistIODevices)
{
    QList<QIODevice*>::iterator i;
    for (i = p_qlistIODevices.begin(); i != p_qlistIODevices.end(); ++i) {
        FiffIO::read((**i));
    }
}
 
//=============================================================================================================
 
bool FiffIO::setup_read(QIODevice& pIODevice,
                        FiffInfo& info,
                        FiffDirNode::SPtr& dirTree)
{
    //Open the file
    FiffStream::SPtr p_pStream(new FiffStream(&pIODevice));
    QString t_sFileName = p_pStream->streamName();
 
    qInfo("Opening fiff data %s...\n", t_sFileName.toUtf8().constData());
 
    if (!p_pStream->open())
        return false;
 
    //Read the measurement info
    if (!p_pStream->read_meas_info(p_pStream->dirtree(), info, dirTree))
        return false;
 
    return true;
}
 
//=============================================================================================================
 
bool FiffIO::read(QIODevice& pIODevice)
{
    //Read dirTree from fiff data (raw,evoked,fwds,cov)
    FiffInfo t_fiffInfo;
    FiffDirNode::SPtr t_dirTree;
    bool hasRaw = false;
    bool hasEvoked = false; // hasFwds=false;
 
    FiffIO::setup_read(pIODevice, t_fiffInfo, t_dirTree);
    pIODevice.close(); //file can be closed, since IODevice is already read
 
    if (!t_dirTree) {
        qWarning() << "[FiffIO::read] Dir tree could not be read";
        return false;
    }
 
    //Search dirTree for specific data types
    if (t_dirTree->has_kind(FIFFB_EVOKED)) {
        hasEvoked = true;
    }
 
    if (t_dirTree->has_kind(FIFFB_RAW_DATA) ||
        t_dirTree->has_kind(FIFFB_PROCESSED_DATA) ||
        t_dirTree->has_kind(FIFFB_CONTINUOUS_DATA) ||
        t_dirTree->has_kind(FIFFB_SMSH_RAW_DATA)) {
        hasRaw = true;
    }
 
    // if(t_Tree.has_kind(FIFFB_MNE_FORWARD_SOLUTION))
    //     hasFwds = true;
 
    //Read all sort of types
    //raw data
    if (hasRaw) {
        try {
            QSharedPointer<FiffRawData> p_fiffRawData(new FiffRawData(pIODevice));
            pIODevice.close();
 
            //append to corresponding member qlist
            m_qlistRaw.append(p_fiffRawData);
 
            qInfo("Finished reading raw data!\n");
        } catch (const std::exception& e) {
            qWarning() << "[FiffIO::read] Could not read raw data:" << e.what();
            pIODevice.close();
        }
    }
 
    //evoked data + projections
    if (hasEvoked) {
        try {
            FiffEvokedSet p_fiffEvokedSet(pIODevice);
            pIODevice.close();
 
            //append to corresponding member qlist
            for (qint32 i = 0; i < p_fiffEvokedSet.evoked.size(); ++i) {
                m_qlistEvoked.append(QSharedPointer<FiffEvoked>(new FiffEvoked(p_fiffEvokedSet.evoked[i])));
            }
        } catch (const std::exception& e) {
            qWarning() << "[FiffIO::read] Could not read evoked data:" << e.what();
            pIODevice.close();
        }
    }
 
    //    //forward solutions
    //    if(hasFwds) {
    //        MNEForwardSolution p_forwardSolution(pIODevice);
 
    //        //append to corresponding member qlist
    //        m_qlistFwd.append(QSharedPointer<MNEForwardSolution>(&p_forwardSolution));
    //    }
 
    //print summary
    //std::cout << *this << std::endl;
 
    return true;
}
 
//=============================================================================================================
 
bool FiffIO::write(QIODevice& pIODevice,
                   const fiff_int_t type,
                   const fiff_int_t idx) const
{
    switch (type) {
        case FIFFB_RAW_DATA: {
            FiffIO::write_raw(pIODevice, idx);
            qDebug() << "Finished writing single raw data with index" << idx << ".";
        }
        case FIFFB_EVOKED:
            //ToDo: write evoked set to file
            ;
    }
 
    return true;
}
 
//=============================================================================================================
 
bool FiffIO::write(QFile& p_QFile,
                   const fiff_int_t type,
                   const fiff_int_t idx) const
{
    qInfo("------------------------ Writing fiff data ------------------------");
 
    switch (type) {
        case FIFFB_RAW_DATA: {
            QString t_nameoftype = "raw";
 
            if (idx == -1) {
                for (qint32 i = 0; i < m_qlistRaw.size(); ++i) {
                    QString t_fname;
                    //insert
                    qint32 p = p_QFile.fileName().indexOf(".fif");
                    t_fname = p_QFile.fileName().insert(p, QString("_" + t_nameoftype + "-" + QString::number(i)));
 
                    //assign new file name
                    qInfo("\nWriting set with index %i to file %s ...\n", i, t_fname.toUtf8().constData());
                    QFile t_file(t_fname);
 
                    FiffIO::write_raw(t_file, i);
                }
            } else {
                FiffIO::write_raw(p_QFile, idx);
            }
            qInfo("\nFinished Writing %lld raw data sets!\n", static_cast<long long>(m_qlistRaw.size()));
        }
        case FIFFB_EVOKED:
 
            //ToDo: write evoked set to file
            ;
    }
 
    return true;
}
 
//=============================================================================================================
 
bool FiffIO::write_raw(QIODevice& pIODevice,
                       const fiff_int_t idx) const
{
    RowVectorXd cals;
    SparseMatrix<double> mult;
    RowVectorXi sel;
    FiffStream::SPtr outfid = FiffStream::start_writing_raw(pIODevice, this->m_qlistRaw[idx]->info, cals);
    if (!outfid) {
        return false;
    }
 
    //Setup reading parameters
    fiff_int_t from = m_qlistRaw[idx]->first_samp;
    fiff_int_t to = m_qlistRaw[idx]->last_samp;
    float quantum_sec = 30.0f; //read and write in 30 sec junks
    fiff_int_t quantum = ceil(quantum_sec * m_qlistRaw[idx]->info.sfreq);
 
    // Uncomment to read the whole file at once. Warning Matrix may be none-initialisable because its huge
    //quantum = to - from + 1;
 
    // Read and write all the data
    bool first_buffer = true;
 
    fiff_int_t first, last;
    MatrixXd data;
    MatrixXd times;
 
    for (first = from; first < to; first += quantum) {
        last = first + quantum - 1;
        if (last > to)
            last = to;
 
        if (!m_qlistRaw[idx]->read_raw_segment(data, times, mult, first, last, sel)) {
            qWarning("error during read_raw_segment\n");
            return false;
        }
 
        qInfo("Writing...");
        if (first_buffer) {
            if (first > 0)
                outfid->write_int(FIFF_FIRST_SAMPLE, &first);
            first_buffer = false;
        }
        outfid->write_raw_buffer(data, cals);
        qInfo("[done]\n");
    }
 
    outfid->finish_writing_raw();
 
    return true;
}