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 <rtprocessing/helpers/filterkernel.h>
 
#include <events/eventmanager.h>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QAbstractTableModel>
#include <QSharedPointer>
#include <QColor>
 
//=============================================================================================================
// 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<RTPROCESSINGLIB::FilterKernel> filterData);
 
    //=========================================================================================================
    void setFilterActive(bool state);
 
    //=========================================================================================================
    void setBackgroundColor(const QColor& color);
 
    //=========================================================================================================
    void setFilterChannelType(const QString &channelType);
 
    //=========================================================================================================
    void createFilterChannelList(QStringList channelNames);
 
    //=========================================================================================================
    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;
 
    //=========================================================================================================
    double getMaxValueFromRawViewModel(int row) const;
 
    //=========================================================================================================
    void addEvent(int iSample);
 
    //=========================================================================================================
    std::unique_ptr<std::vector<EVENTSLIB::Event> > getEventsToDisplay(int iBegin, int iEnd) const;
 
private:
    //=========================================================================================================
    void initSphara();
 
    static void doFilterPerChannelRTMSA(QPair<QList<RTPROCESSINGLIB::FilterKernel>,QPair<int,Eigen::RowVectorXd> > &channelDataTime);
 
    //=========================================================================================================
    void filterDataBlock();
 
    //=========================================================================================================
    void filterDataBlock(const Eigen::MatrixXd &data, int iDataIndex);
 
    //=========================================================================================================
    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;                        
    qint32                              m_iResidual;                                
    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<RTPROCESSINGLIB::FilterKernel>m_filterKernel;                             
    QStringList                         m_filterChannelList;                        
    QStringList                         m_visibleChannelList;                       
    QMap<qint32,qint32>                 m_qMapIdxRowSelection;                      
    QColor                              m_colBackground;                            
    static EVENTSLIB::EventManager      m_EventManager;                             
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