mne_raw_info.cpp

Go to the documentation of this file.

//=============================================================================================================
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "mne_raw_info.h"
 
#include <fiff/fiff_tag.h>
 
#include <Eigen/Core>
 
#include <QFile>
#include <QDebug>
 
//=============================================================================================================
// USED NAMESPACES
//=============================================================================================================
 
using namespace Eigen;
using namespace FIFFLIB;
using namespace MNELIB;
 
//=============================================================================================================
// DEFINE MEMBER METHODS
//=============================================================================================================
 
MNERawInfo::MNERawInfo()
: nchan(0)
, coord_frame(0)
, sfreq(0.0f)
, lowpass(0.0f)
, highpass(0.0f)
, buf_size(0)
, maxshield_data(0)
, ndir(0)
{
}
 
//=============================================================================================================
 
MNERawInfo::~MNERawInfo()
{
}
 
//=============================================================================================================
 
FiffDirNode::SPtr MNERawInfo::find_meas(const FiffDirNode::SPtr &node)
{
    FiffDirNode::SPtr empty_node;
    FiffDirNode::SPtr tmp_node = node;
 
    while (tmp_node->type != FIFFB_MEAS) {
        if (tmp_node->parent == nullptr)
            return empty_node;
        tmp_node = tmp_node->parent;
    }
    return tmp_node;
}
 
//=============================================================================================================
 
FiffDirNode::SPtr MNERawInfo::find_meas_info(const FiffDirNode::SPtr &node)
{
    int k;
    FiffDirNode::SPtr empty_node;
    FiffDirNode::SPtr tmp_node = node;
 
    while (tmp_node->type != FIFFB_MEAS) {
        if (tmp_node->parent == nullptr)
            return empty_node;
        tmp_node = tmp_node->parent;
    }
    for (k = 0; k < tmp_node->nchild(); k++)
        if (tmp_node->children[k]->type == FIFFB_MEAS_INFO)
            return (tmp_node->children[k]);
    return empty_node;
}
 
//=============================================================================================================
 
FiffDirNode::SPtr MNERawInfo::find_raw(const FiffDirNode::SPtr &node)
{
    FiffDirNode::SPtr raw;
    QList<FiffDirNode::SPtr> temp;
    temp = node->dir_tree_find(FIFFB_RAW_DATA);
    if (temp.size() == 0) {
        temp = node->dir_tree_find(FIFFB_CONTINUOUS_DATA);
        if (temp.size() > 0)
            raw = temp[0];
    }
    else
        raw = temp[0];
    return raw;
}
 
//=============================================================================================================
 
FiffDirNode::SPtr MNERawInfo::find_maxshield(const FiffDirNode::SPtr &node)
 
{
    FiffDirNode::SPtr raw;
    QList<FiffDirNode::SPtr> temp;
    temp = node->dir_tree_find(FIFFB_SMSH_RAW_DATA);
    if (temp.size() > 0)
        raw = temp[0];
    return (raw);
}
 
//=============================================================================================================
 
int MNERawInfo::get_meas_info(FiffStream::SPtr &stream,
                              FiffDirNode::SPtr &node,
                              std::unique_ptr<FiffId>& id,
                              int *nchan,
                              float *sfreq,
                              float *highpass,
                              float *lowpass,
                              QList<FiffChInfo>& chp,
                              FiffCoordTrans& trans)
{
    FiffTime dummy;
    return get_meas_info(stream, node, id, nchan, sfreq, highpass, lowpass, chp, trans, dummy);
}
 
//=============================================================================================================
 
int MNERawInfo::get_meas_info(FiffStream::SPtr &stream,
                              FiffDirNode::SPtr &node,
                              std::unique_ptr<FiffId>& id,
                              int *nchan,
                              float *sfreq,
                              float *highpass,
                              float *lowpass,
                              QList<FiffChInfo>& chp,
                              FiffCoordTrans& trans,
                              FiffTime& start_time)
{
    FiffTag::UPtr t_pTag;
    QList<FiffChInfo> ch;
    FiffChInfo this_ch;
    FiffCoordTrans t;
    int j,k;
    int to_find = 4;
    QList<FiffDirNode::SPtr> hpi;
    FiffDirNode::SPtr meas;
    FiffDirNode::SPtr meas_info;
    fiff_int_t kind, pos;
    bool found_meas_date = false;
 
     trans      = FiffCoordTrans();
     id.reset();
     start_time = FiffTime();
    /*
        * Find desired parents
        */
    if (!(meas = find_meas(node))) {
        qCritical ("Meas. block not found!");
        return (-1);
    }
 
    if (!(meas_info = find_meas_info(node))) {
        qCritical ("Meas. info not found!");
        return (-1);
    }
    /*
       * Is there a block id is in the FIFFB_MEAS node?
       */
    if (!meas->id.isEmpty()) {
        id = std::make_unique<FiffId>();
        id->version = meas->id.version;
        id->machid[0] = meas->id.machid[0];
        id->machid[1] = meas->id.machid[1];
        id->time = meas->id.time;
    }
    /*
       * Others from FIFFB_MEAS_INFO
       */
     *lowpass  = -1;
     *highpass = -1;
    for (k = 0; k < meas_info->nent(); k++) {
        kind = meas_info->dir[k]->kind;
        pos  = meas_info->dir[k]->pos;
        switch (kind) {
 
        case FIFF_NCHAN :
            if (!stream->read_tag(t_pTag,pos))
                return (-1);
            *nchan = *t_pTag->toInt();
 
            for (j = 0; j < *nchan; j++) {
                ch.append(FiffChInfo());
                ch[j].scanNo = -1;
            }
            to_find = to_find + *nchan - 1;
            break;
 
        case FIFF_SFREQ :
            if (!stream->read_tag(t_pTag,pos))
                return (-1);
            *sfreq = *t_pTag->toFloat();
            to_find--;
            break;
 
        case FIFF_LOWPASS :
            if (!stream->read_tag(t_pTag,pos))
                return (-1);
            *lowpass = *t_pTag->toFloat();
            to_find--;
            break;
 
        case FIFF_HIGHPASS :
            if (!stream->read_tag(t_pTag,pos))
                return (-1);
            *highpass = *t_pTag->toFloat();
            to_find--;
            break;
 
        case FIFF_CH_INFO :
            if (!stream->read_tag(t_pTag,pos))
                return (-1);
 
            this_ch = t_pTag->toChInfo();
            if (this_ch.scanNo <= 0 || this_ch.scanNo > *nchan) {
                qCritical ("FIFF_CH_INFO : scan # out of range!");
                return (-1);
            }
            else
                ch[this_ch.scanNo-1] = this_ch;
            to_find--;
            break;
 
        case FIFF_MEAS_DATE :
            if (!stream->read_tag(t_pTag,pos))
                return (-1);
            {
                const FiffTime* pTime = reinterpret_cast<const FiffTime*>(t_pTag->data());
                start_time = FiffTime(pTime->secs, pTime->usecs);
                found_meas_date = true;
            }
            break;
 
        case FIFF_COORD_TRANS :
            if (!stream->read_tag(t_pTag,pos))
                return (-1);
            t = FiffCoordTrans::readFromTag( t_pTag );
            /*
                * Require this particular transform!
                */
            if (t.from == FIFFV_COORD_DEVICE && t.to == FIFFV_COORD_HEAD) {
                trans = t;
                break;
            }
        }
    }
    /*
        * Search for the coordinate transformation from
        * HPI_RESULT block if it was not previously found
        */
    hpi = meas_info->dir_tree_find(FIFFB_HPI_RESULT);
 
    if (hpi.size() > 0 && trans.isEmpty())
        for (k = 0; k < hpi[0]->nent(); k++)
            if (hpi[0]->dir[k]->kind ==  FIFF_COORD_TRANS) {
                if (!stream->read_tag(t_pTag,hpi[0]->dir[k]->pos))
                    return (-1);
                t = FiffCoordTrans::readFromTag( t_pTag );
                if (t.from == FIFFV_COORD_DEVICE && t.to == FIFFV_COORD_HEAD) {
                    trans = t;
                    break;
                }
            }
    if (to_find < 3) {
        if (*lowpass < 0) {
            *lowpass = *sfreq/2.0;
            to_find--;
        }
        if (*highpass < 0) {
            *highpass = 0.0;
            to_find--;
        }
    }
    if (to_find != 0) {
        qCritical ("Not all essential tags were found!");
        return (-1);
    }
    chp = ch;
    /*
     * Resolve the measurement start time using the best available source
     */
    if (!found_meas_date) {
        if (id)
            start_time = id->time;
        else
            start_time = FiffTime();
    }
    return (0);
}
 
//=============================================================================================================
 
int MNERawInfo::load(const QString& name, int allow_maxshield, std::unique_ptr<MNERawInfo>& infop)
{
    QFile file(name);
    FiffStream::SPtr stream(new FiffStream(&file));
 
    int            res      = FIFF_FAIL;
    QList<FiffChInfo> chs;  /* Channel info */
    FiffCoordTrans trans;       /* The coordinate transformation */
    std::unique_ptr<FiffId> id; /* Measurement id */
    QList<FiffDirEntry::SPtr>   rawDir; /* Directory of raw data tags */
    std::unique_ptr<MNERawInfo> info;
    int            nchan    = 0;        /* Number of channels */
    float          sfreq    = 0.0;  /* Sampling frequency */
    float          highpass;        /* Highpass filter frequency */
    float          lowpass;     /* Lowpass filter frequency */
    FiffDirNode::SPtr    raw;
    FiffTime       start_time;
    int            k;
    int            maxshield_data = false;
    /*
       * Open file
       */
    if(!stream->open()) {
        stream->close(); return FIFF_FAIL;
    }
    raw = find_raw(stream->dirtree());
    if (raw->isEmpty()) {
        if (allow_maxshield) {
            raw = find_maxshield(stream->dirtree());
            if (raw->isEmpty()) {
                qCritical("No raw data in this file.");
                stream->close(); return FIFF_FAIL;
            }
            maxshield_data = true;
        }
        else {
            qCritical("No raw data in this file.");
            stream->close(); return FIFF_FAIL;
        }
    }
    /*
       * Get the essential measurement information
       */
    if (get_meas_info (stream,
                       raw,
                       id,
                       &nchan,
                       &sfreq,
                       &highpass,
                       &lowpass,
                       chs,
                       trans,
                       start_time) < 0) {
        stream->close(); return FIFF_FAIL;
    }
    /*
        * Get the raw directory
        */
    rawDir = raw->dir;
    /*
       * Ready to put everything together
       */
    info = std::make_unique<MNERawInfo>();
    info->filename       = name;
    info->nchan          = nchan;
    info->chInfo         = chs;
    info->coord_frame    = FIFFV_COORD_DEVICE;
    info->trans          = std::make_unique<FiffCoordTrans>(trans);
    info->sfreq          = sfreq;
    info->lowpass        = lowpass;
    info->highpass       = highpass;
    info->maxshield_data = maxshield_data;
    if (id) {
        info->id = std::make_unique<FiffId>(*id);
    }
    /*
       * Getting starting time from measurement ID is not too accurate...
       */
    info->start_time = start_time;
    info->buf_size   = 0;
    for (k = 0; k < raw->nent(); k++) {
        if (raw->dir[k]->kind == FIFF_DATA_BUFFER) {
            if (raw->dir[k]->type == FIFFT_DAU_PACK16 || raw->dir[k]->type == FIFFT_SHORT)
                info->buf_size = raw->dir[k]->size/(nchan*sizeof(fiff_short_t));
            else if (raw->dir[k]->type == FIFFT_FLOAT)
                info->buf_size = raw->dir[k]->size/(nchan*sizeof(fiff_float_t));
            else if (raw->dir[k]->type == FIFFT_INT)
                info->buf_size = raw->dir[k]->size/(nchan*sizeof(fiff_int_t));
            else {
                qCritical("We are not prepared to handle raw data type: %d",raw->dir[k]->type);
                stream->close(); return FIFF_FAIL;
            }
            break;
        }
    }
    if (info->buf_size <= 0) {
        qCritical("No raw data buffers available.");
        stream->close(); return FIFF_FAIL;
    }
    info->rawDir     = rawDir;
    info->ndir       = raw->nent();
    infop = std::move(info);
    res = FIFF_OK;
 
    stream->close();
    return res;
}