mne_epoch_data.cpp

Go to the documentation of this file.

//=============================================================================================================
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "mne_epoch_data.h"
 
#include <cmath>
 
#include <math/numerics.h>
 
//=============================================================================================================
// USED NAMESPACES
//=============================================================================================================
 
using namespace MNELIB;
using namespace Eigen;
using namespace UTILSLIB;
 
//=============================================================================================================
// DEFINE MEMBER METHODS
//=============================================================================================================
 
MNEEpochData::MNEEpochData()
: event(-1)
, eventSample(-1)
, tmin(-1)
, tmax(-1)
, bReject(false)
, bUserReject(false)
{
}
 
//=============================================================================================================
 
MNEEpochData::MNEEpochData(const MNEEpochData& p_MNEEpochData)
: epoch(p_MNEEpochData.epoch)
, event(p_MNEEpochData.event)
, eventSample(p_MNEEpochData.eventSample)
, tmin(p_MNEEpochData.tmin)
, tmax(p_MNEEpochData.tmax)
, bReject(p_MNEEpochData.bReject)
, bUserReject(p_MNEEpochData.bUserReject)
{
}
 
//=============================================================================================================
 
MNEEpochData::~MNEEpochData()
{
}
 
//=============================================================================================================
 
void MNEEpochData::applyBaselineCorrection(const QPair<float, float>& baseline)
{
    // Times on whole sample offsets: an interpolated float grid puts the stimulus sample just after 0
    const Eigen::Index n = this->epoch.cols();
    const double step = n > 1 ? (static_cast<double>(this->tmax) - this->tmin) / static_cast<double>(n - 1) : 1.0;
    const double first = std::round(this->tmin / step);
    RowVectorXf times(n);
    for (Eigen::Index i = 0; i < n; ++i)
        times(i) = static_cast<float>((first + static_cast<double>(i)) * step);
    this->epoch = Numerics::rescale(this->epoch, times, baseline, QString("mean"));
}
 
//=============================================================================================================
 
void MNEEpochData::pick_channels(const RowVectorXi& sel)
{
    if (sel.cols() == 0) {
        qWarning("MNEEpochData::pick_channels - Warning : No channels were provided.\n");
        return;
    }
 
    // Reduce data set
    MatrixXd selBlock(1, 1);
 
    if (selBlock.rows() != sel.cols() || selBlock.cols() != epoch.cols()) {
        selBlock.resize(sel.cols(), epoch.cols());
    }
 
    for (qint32 l = 0; l < sel.cols(); ++l) {
        if (sel(l) <= epoch.rows()) {
            selBlock.row(l) = epoch.row(sel(0, l));
        } else {
            qWarning("FiffEvoked::pick_channels - Warning : Selected channel index out of bound.\n");
        }
    }
 
    epoch = selBlock;
}