rtaveraging.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef RTAVERAGING_RTPROCESSING_H
#define RTAVERAGING_RTPROCESSING_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "rtprocessing_global.h"
 
#include <fiff/fiff_evoked_set.h>
#include <fiff/fiff_info.h>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QThread>
#include <QSharedPointer>
#include <QObject>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
// DEFINE NAMESPACE RTPROCESSINGLIB
//=============================================================================================================
 
namespace RTPROCESSINGLIB
{
 
//=============================================================================================================
// RTPROCESSINGLIB FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
class RTPROCESINGSHARED_EXPORT RtAveragingWorker : public QObject
{
    Q_OBJECT
 
public:
    //=========================================================================================================
    RtAveragingWorker(quint32 numAverages,
                      quint32 iPreStimSamples,
                      quint32 iPostStimSamples,
                      quint32 iBaselineFromMSecs,
                      quint32 iBaselineToMSecs,
                      quint32 iTriggerIndex,
                      FIFFLIB::FiffInfo::SPtr pFiffInfo);
 
    //=========================================================================================================
    void doWork(const Eigen::MatrixXd& matData);
 
    //=========================================================================================================
    void setAverageNumber(qint32 numAve);
 
    //=========================================================================================================
    void setPreStim(qint32 samples,
                    qint32 secs);
 
    //=========================================================================================================
    void setPostStim(qint32 samples,
                     qint32 secs);
 
    //=========================================================================================================
    void setTriggerChIndx(qint32 idx);
 
    //=========================================================================================================
    void setArtifactReduction(const QMap<QString, double> &mapThresholds);
 
    //=========================================================================================================
    void setBaselineActive(bool activate);
 
    //=========================================================================================================
    void setBaselineFrom(int fromSamp,
                         int fromMSec);
 
    //=========================================================================================================
    void setBaselineTo(int toSamp,
                       int toMSec);
 
    //=========================================================================================================
    void reset();
 
protected:
    //=========================================================================================================
    void doAveraging(const Eigen::MatrixXd& rawSegment);
 
    //=========================================================================================================
    void fillFrontBuffer(const Eigen::MatrixXd& data,
                         double dTriggerType);
 
    void emitEvoked(double dTriggerType,
                    QStringList& lResponsibleTriggerTypes);
 
    //=========================================================================================================
    void fillBackBuffer(const Eigen::MatrixXd& data,
                        double dTriggerType);
 
    //=========================================================================================================
    void mergeData(double dTriggerType);
 
    //=========================================================================================================
    void generateEvoked(double dTriggerType);
 
    //=========================================================================================================
    inline bool controlValuesChanged();
 
    qint32                                          m_iNumAverages;             
 
    qint32                                          m_iPreStimSamples;          
    qint32                                          m_iNewPreStimSamples;       
 
    qint32                                          m_iPostStimSamples;         
    qint32                                          m_iNewPostStimSamples;      
 
    qint32                                          m_iTriggerChIndex;          
    qint32                                          m_iNewTriggerIndex;         
 
    float                                           m_fTriggerThreshold;        
 
    bool                                            m_bActivateThreshold;       
 
    bool                                            m_bDoBaselineCorrection;    
 
    QPair<float,float>                              m_pairBaselineSec;          
    QPair<float,float>                              m_pairBaselineSamp;         
 
    FIFFLIB::FiffInfo::SPtr                         m_pFiffInfo;                
    FIFFLIB::FiffEvokedSet                          m_stimEvokedSet;            
 
    QMap<QString,double>                            m_mapThresholds;            
    QMap<double,QList<Eigen::MatrixXd> >            m_mapStimAve;               
    QMap<double,Eigen::MatrixXd>                    m_mapDataPre;               
    QMap<double,Eigen::MatrixXd>                    m_mapDataPost;              
    QMap<double,qint32>                             m_mapMatDataPostIdx;        
    QMap<double,bool>                               m_mapFillingBackBuffer;     
 
signals:
    //=========================================================================================================
    void resultReady(const FIFFLIB::FiffEvokedSet& evokedStimSet,
                     const QStringList& lResponsibleTriggerTypes);
};
 
//=============================================================================================================
class RTPROCESINGSHARED_EXPORT RtAveraging : public QObject
{
    Q_OBJECT
 
public:
    typedef QSharedPointer<RtAveraging> SPtr;             
    typedef QSharedPointer<const RtAveraging> ConstSPtr;  
 
    //=========================================================================================================
    explicit RtAveraging(quint32 numAverages,
                         quint32 iPreStimSamples,
                         quint32 iPostStimSamples,
                         quint32 iBaselineFromSecs,
                         quint32 iBaselineToSecs,
                         quint32 iTriggerIndex,
                         FIFFLIB::FiffInfo::SPtr pFiffInfo,
                         QObject *parent = 0);
 
    //=========================================================================================================
    ~RtAveraging();
 
    //=========================================================================================================
    void append(const Eigen::MatrixXd &data);
 
    //=========================================================================================================
    void restart(quint32 numAverages,
                 quint32 iPreStimSamples,
                 quint32 iPostStimSamples,
                 quint32 iBaselineFromSecs,
                 quint32 iBaselineToSecs,
                 quint32 iTriggerIndex,
                 FIFFLIB::FiffInfo::SPtr pFiffInfo);
 
    //=========================================================================================================
    void stop();
 
    //=========================================================================================================
    void setAverageNumber(qint32 numAve);
 
    //=========================================================================================================
    void setPreStim(qint32 samples,
                    qint32 secs);
 
    //=========================================================================================================
    void setPostStim(qint32 samples,
                     qint32 secs);
 
    //=========================================================================================================
    void setTriggerChIndx(qint32 idx);
 
    //=========================================================================================================
    void setArtifactReduction(const QMap<QString, double> &mapThresholds);
 
    //=========================================================================================================
    void setBaselineActive(bool activate);
 
    //=========================================================================================================
    void setBaselineFrom(int fromSamp,
                         int fromMSec);
 
    //=========================================================================================================
    void setBaselineTo(int toSamp,
                       int toMSec);
 
    //=========================================================================================================
    void reset();
 
protected:
    //=========================================================================================================
    void handleResults(const FIFFLIB::FiffEvokedSet& evokedStimSet,
                       const QStringList& lResponsibleTriggerTypes);
 
    QThread             m_workerThread;         
 
signals:
    void evokedStim(const FIFFLIB::FiffEvokedSet& evokedStimSet,
                    const QStringList& lResponsibleTriggerTypes);
    void operate(const Eigen::MatrixXd& matData);
    void averageNumberChanged(qint32 numAve);
    void averagePreStimChanged(qint32 samples,
                               qint32 secs);
    void averagePostStimChanged(qint32 samples,
                                qint32 secs);
    void averageTriggerChIdxChanged(qint32 idx);
    void averageArtifactReductionChanged(const QMap<QString, double> &mapThresholds);
    void averageBaselineActiveChanged(bool activate);
    void averageBaselineFromChanged(int fromSamp,
                                    int fromMSec);
    void averageBaselineToChanged(int toSamp,
                                  int toMSec);
    void averageResetRequested();
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
inline bool RtAveragingWorker::controlValuesChanged()
{
    bool result = false;
 
    if(m_iNewPreStimSamples != m_iPreStimSamples
       || m_iNewPostStimSamples != m_iPostStimSamples
       || m_iNewTriggerIndex != m_iTriggerChIndex) {
        result = true;
    }
 
    return result;
}
} // NAMESPACE
 
#endif // RTAVERAGING_RTPROCESSING_H