rtfiffrawviewmodel.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef RTFIFFRAWVIEWMODEL_H
#define RTFIFFRAWVIEWMODEL_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../../disp_global.h"
 
#include <fiff/fiff_types.h>
#include <fiff/fiff_proj.h>
 
#include <dsp/filterkernel.h>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QAbstractTableModel>
#include <QSharedPointer>
#include <QColor>
 
#include <functional>
#include <vector>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
#include <Eigen/SparseCore>
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
namespace FIFFLIB
{
class FiffInfo;
}
 
//=============================================================================================================
// DEFINE NAMESPACE DISPLIB
//=============================================================================================================
 
namespace DISPLIB
{
 
//=============================================================================================================
// DISPLIB FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
// DEFINE TYPEDEFS
//=============================================================================================================
 
typedef QPair<const double*, qint32> RowVectorPair;
typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> MatrixXdR;
 
//=============================================================================================================
class DISPSHARED_EXPORT RtFiffRawViewModel : public QAbstractTableModel
{
    Q_OBJECT
 
public:
    typedef QSharedPointer<RtFiffRawViewModel> SPtr;            
    typedef QSharedPointer<const RtFiffRawViewModel> ConstSPtr; 
 
    //=========================================================================================================
    RtFiffRawViewModel(QObject* parent = 0);
 
    //=========================================================================================================
 
    ~RtFiffRawViewModel();
    //=========================================================================================================
    virtual int rowCount(const QModelIndex& parent = QModelIndex()) const;
 
    //=========================================================================================================
    virtual int columnCount(const QModelIndex& parent = QModelIndex()) const;
 
    //=========================================================================================================
    virtual QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
 
    //=========================================================================================================
    virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
 
    //=========================================================================================================
    void setFiffInfo(QSharedPointer<FIFFLIB::FiffInfo>& p_pFiffInfo);
 
    //=========================================================================================================
    void setSamplingInfo(float sps, int T, bool bSetZero = false);
 
    //=========================================================================================================
    Eigen::MatrixXd getLastBlock();
 
    //=========================================================================================================
    void addData(const QList<Eigen::MatrixXd>& data);
 
    //=========================================================================================================
    FIFFLIB::fiff_int_t getKind(qint32 row) const;
 
    //=========================================================================================================
    FIFFLIB::fiff_int_t getUnit(qint32 row) const;
 
    //=========================================================================================================
    FIFFLIB::fiff_int_t getCoil(qint32 row) const;
 
    //=========================================================================================================
    inline qint32 getMaxSamples() const;
 
    //=========================================================================================================
    inline qint32 getCurrentSampleIndex() const;
 
    //=========================================================================================================
    inline double getLastBlockFirstValue(int row) const;
 
    //=========================================================================================================
    inline const QMap<qint32, qint32>& getIdxSelMap() const;
 
    //=========================================================================================================
    void selectRows(const QList<qint32>& selection);
 
    //=========================================================================================================
    void hideRows(const QList<qint32>& selection);
 
    //=========================================================================================================
    void resetSelection();
 
    //=========================================================================================================
    void toggleFreeze(const QModelIndex& index);
 
    //=========================================================================================================
    void setScaling(const QMap<qint32, float>& p_qMapChScaling);
 
    //=========================================================================================================
    void updateProjection(const QList<FIFFLIB::FiffProj>& projs);
 
    //=========================================================================================================
    void updateCompensator(int to);
 
    //=========================================================================================================
    void updateSpharaActivation(bool state);
 
    //=========================================================================================================
    void updateSpharaOptions(const QString& sSytemType, int nBaseFctsFirst, int nBaseFctsSecond);
 
    //=========================================================================================================
    void setFilter(QList<UTILSLIB::FilterKernel> filterData);
 
    //=========================================================================================================
    void setFilterActive(bool state);
 
    //=========================================================================================================
    void setBackgroundColor(const QColor& color);
 
    //=========================================================================================================
    void setFilterChannelType(const QString& channelType);
 
    //=========================================================================================================
    void markChBad(QModelIndex ch, bool status);
 
    //=========================================================================================================
    void markChBad(QModelIndexList chlist, bool status);
 
    //=========================================================================================================
    void triggerInfoChanged(const QMap<double, QColor>& colorMap, bool active, QString triggerCh, double threshold);
 
    //=========================================================================================================
    void distanceTimeSpacerChanged(int value);
 
    //=========================================================================================================
    void resetTriggerCounter();
 
    //=========================================================================================================
    inline qint32 numVLines() const;
 
    //=========================================================================================================
    inline bool isFreezed() const;
 
    //=========================================================================================================
    inline const QMap<qint32, float>& getScaling() const;
 
    //=========================================================================================================
    inline QList<QPair<int, double>> getDetectedTriggers() const;
 
    //=========================================================================================================
    inline QList<QPair<int, double>> getDetectedTriggersOld() const;
 
    //=========================================================================================================
    inline QMap<double, QColor> getTriggerColor() const;
 
    //=========================================================================================================
    inline int getNumberOfTimeSpacers() const;
 
    //=========================================================================================================
    inline double getTriggerThreshold() const;
 
    //=========================================================================================================
    inline QString getTriggerName() const;
 
    //=========================================================================================================
    inline int getCurrentTriggerIndex() const;
 
    //=========================================================================================================
    inline bool triggerDetectionActive() const;
 
    //=========================================================================================================
    inline int getCurrentOverlapAddDelay() const;
 
    //=========================================================================================================
    inline int getFirstSampleOffset() const;
 
    //=========================================================================================================
    int getSampleAtColumn(int iColumn) const;
 
    //=========================================================================================================
    double getValueAtColumn(int iRow, int iColumn) const;
 
    //=========================================================================================================
    double getMaxValueFromRawViewModel(int row) const;
 
    //=========================================================================================================
    void addEvent(int iSample);
 
    //=========================================================================================================
    std::vector<int> getEventsToDisplay(int iBegin, int iEnd) const;
 
    //=========================================================================================================
    void setEventCallbacks(std::function<void(int)> addFn,
                           std::function<std::vector<int>(int, int)> getFn);
 
private:
    //=========================================================================================================
    void initSphara();
 
    static void doFilterPerChannelRTMSA(QPair<QList<UTILSLIB::FilterKernel>, QPair<int, Eigen::RowVectorXd>>& channelDataTime);
 
    //=========================================================================================================
    void filterDataBlock(const Eigen::MatrixXd& data, int iDataIndex);
 
    //=========================================================================================================
    void startNewSweep();
 
    //=========================================================================================================
    void clearModel();
 
    bool m_bProjActivated;           
    bool m_bCompActivated;           
    bool m_bSpharaActivated;         
    bool m_bIsFreezed;               
    bool m_bDrawFilterFront;         
    bool m_bPerformFiltering;        
    bool m_bTriggerDetectionActive;  
    float m_fSps;                    
    double m_dTriggerThreshold;      
    qint32 m_iT;                     
    qint32 m_iDownsampling;          
    qint32 m_iMaxSamples;            
    qint32 m_iCurrentSample;         
    qint32 m_iCurrentStartingSample; 
    qint32 m_iCurrentSampleFreeze;   
    qint32 m_iMaxFilterLength;       
    qint32 m_iCurrentBlockSize;      
    int m_iCurrentTriggerChIndex;    
    int m_iDistanceTimerSpacer;      
    int m_iDetectedTriggers;         
 
    QString m_sCurrentTriggerCh;  
    QString m_sFilterChannelType; 
 
    QSharedPointer<FIFFLIB::FiffInfo> m_pFiffInfo; 
 
    Eigen::RowVectorXi m_vecBadIdcs;                   
    Eigen::VectorXd m_vecLastBlockFirstValuesFiltered; 
    Eigen::VectorXd m_vecLastBlockFirstValuesRaw;      
 
    MatrixXdR m_matDataRaw;            
    MatrixXdR m_matDataFiltered;       
    MatrixXdR m_matDataRawFreeze;      
    MatrixXdR m_matDataFilteredFreeze; 
    Eigen::MatrixXd m_matOverlap;      
 
    Eigen::VectorXi m_vecIndicesFirstVV;       
    Eigen::VectorXi m_vecIndicesSecondVV;      
    Eigen::VectorXi m_vecIndicesFirstBabyMEG;  
    Eigen::VectorXi m_vecIndicesSecondBabyMEG; 
    Eigen::VectorXi m_vecIndicesFirstEEG;      
 
    Eigen::SparseMatrix<double> m_matSparseSpharaMult;   
    Eigen::SparseMatrix<double> m_matSparseProjCompMult; 
    Eigen::SparseMatrix<double> m_matSparseProjMult;     
    Eigen::SparseMatrix<double> m_matSparseCompMult;     
 
    Eigen::MatrixXd m_matProj; 
    Eigen::MatrixXd m_matComp; 
 
    Eigen::MatrixXd m_matSpharaVVGradLoaded;       
    Eigen::MatrixXd m_matSpharaVVMagLoaded;        
    Eigen::MatrixXd m_matSpharaBabyMEGInnerLoaded; 
    Eigen::MatrixXd m_matSpharaBabyMEGOuterLoaded; 
    Eigen::MatrixXd m_matSpharaEEGLoaded;          
 
    QMap<double, QColor> m_qMapTriggerColor;                             
    QMap<int, QList<QPair<int, double>>> m_qMapDetectedTrigger;          
    QList<int> m_lTriggerChannelIndices;                                 
    QMap<int, QList<QPair<int, double>>> m_qMapDetectedTriggerFreeze;    
    QMap<int, QList<QPair<int, double>>> m_qMapDetectedTriggerOld;       
    QMap<int, QList<QPair<int, double>>> m_qMapDetectedTriggerOldFreeze; 
    QMap<qint32, float> m_qMapChScaling;                                 
    QList<UTILSLIB::FilterKernel> m_filterKernel;                        
    QStringList m_filterChannelList;                                     
    QMap<qint32, qint32> m_qMapIdxRowSelection;                          
 
    QColor m_colBackground; 
 
    std::function<void(int)> m_fnAddEvent;                         
    std::function<std::vector<int>(int, int)> m_fnGetEventSamples; 
 
signals:
    //=========================================================================================================
    void newSelection(const QList<qint32>& selection);
 
    //=========================================================================================================
    void windowSizeChanged(int windowSize);
 
    //=========================================================================================================
    void triggerDetected(int numberDetectedTriggers, const QMap<int, QList<QPair<int, double>>>& mapDetectedTriggers);
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
inline qint32 RtFiffRawViewModel::getMaxSamples() const
{
    return m_iMaxSamples;
}
 
//=============================================================================================================
 
inline qint32 RtFiffRawViewModel::getCurrentSampleIndex() const
{
    if (m_bIsFreezed) {
        return m_iCurrentSampleFreeze;
    }
 
    if (!m_filterKernel.isEmpty() && m_bPerformFiltering) {
        return m_iCurrentSample - m_iMaxFilterLength / 2;
    }
 
    return m_iCurrentSample;
}
 
//=============================================================================================================
 
inline double RtFiffRawViewModel::getLastBlockFirstValue(int row) const
{
    if (row > m_vecLastBlockFirstValuesFiltered.rows() || row > m_vecLastBlockFirstValuesRaw.rows())
        return 0;
 
    if (!m_filterKernel.isEmpty())
        return m_vecLastBlockFirstValuesFiltered[row];
 
    return m_vecLastBlockFirstValuesRaw[row];
}
 
//=============================================================================================================
 
inline const QMap<qint32, qint32>& RtFiffRawViewModel::getIdxSelMap() const
{
    return m_qMapIdxRowSelection;
}
 
//=============================================================================================================
 
inline qint32 RtFiffRawViewModel::numVLines() const
{
    return (m_iT - 1);
}
 
//=============================================================================================================
 
inline bool RtFiffRawViewModel::isFreezed() const
{
    return m_bIsFreezed;
}
 
//=============================================================================================================
 
inline const QMap<qint32, float>& RtFiffRawViewModel::getScaling() const
{
    return m_qMapChScaling;
}
 
//=============================================================================================================
 
inline QMap<double, QColor> RtFiffRawViewModel::getTriggerColor() const
{
    if (m_bTriggerDetectionActive) {
        return m_qMapTriggerColor;
    }
 
    QMap<double, QColor> map;
    return map;
}
 
//=============================================================================================================
 
inline QList<QPair<int, double>> RtFiffRawViewModel::getDetectedTriggers() const
{
    QList<QPair<int, double>> triggerIndices;
 
    if (m_bIsFreezed)
        return m_qMapDetectedTriggerFreeze[m_iCurrentTriggerChIndex];
 
    if (m_bTriggerDetectionActive) {
        return m_qMapDetectedTrigger[m_iCurrentTriggerChIndex];
    } else
        return triggerIndices;
}
 
//=============================================================================================================
 
inline QList<QPair<int, double>> RtFiffRawViewModel::getDetectedTriggersOld() const
{
    QList<QPair<int, double>> triggerIndices;
 
    if (m_bIsFreezed)
        return m_qMapDetectedTriggerOldFreeze[m_iCurrentTriggerChIndex];
 
    if (m_bTriggerDetectionActive) {
        return m_qMapDetectedTriggerOld[m_iCurrentTriggerChIndex];
    } else
        return triggerIndices;
}
 
//=============================================================================================================
 
inline int RtFiffRawViewModel::getNumberOfTimeSpacers() const
{
    //qDebug()<<((m_iT*1000)/m_iDistanceTimerSpacer)-1;
    return ((1000) / m_iDistanceTimerSpacer) - 1;
}
 
//=============================================================================================================
 
inline double RtFiffRawViewModel::getTriggerThreshold() const
{
    return m_dTriggerThreshold;
}
 
//=============================================================================================================
 
inline QString RtFiffRawViewModel::getTriggerName() const
{
    return m_sCurrentTriggerCh;
}
 
//=============================================================================================================
 
inline int RtFiffRawViewModel::getCurrentTriggerIndex() const
{
    return m_iCurrentTriggerChIndex;
}
 
//=============================================================================================================
 
inline bool RtFiffRawViewModel::triggerDetectionActive() const
{
    return m_bTriggerDetectionActive;
}
 
//=============================================================================================================
 
inline int RtFiffRawViewModel::getCurrentOverlapAddDelay() const
{
    if (!m_filterKernel.isEmpty())
        return m_iMaxFilterLength / 2;
    else
        return 0;
}
 
//=============================================================================================================
 
inline int RtFiffRawViewModel::getFirstSampleOffset() const
{
    return m_iCurrentStartingSample;
}
} // NAMESPACE
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
#ifndef metatype_rowvectorpair
#define metatype_rowvectorpair
Q_DECLARE_METATYPE(DISPLIB::RowVectorPair);
#endif
#endif
 
#endif // RTFIFFRAWVIEWMODEL_H