fiff_events.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef FIFF_EVENTS_H
#define FIFF_EVENTS_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "fiff_global.h"
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QString>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
#include <QList>
#include <QMap>
 
#include <optional>
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
class QIODevice;
 
//=============================================================================================================
// DEFINE NAMESPACE FIFFLIB
//=============================================================================================================
 
namespace FIFFLIB
{
 
// Forward declaration
class FiffRawData;
struct AverageCategory;
 
//=============================================================================================================
class FIFFSHARED_EXPORT FiffEvents
{
public:
    //=========================================================================================================
    FiffEvents();
 
    //=========================================================================================================
    explicit FiffEvents(QIODevice& p_IODevice);
 
    //=========================================================================================================
    static bool read(const QString& t_sEventName,
                     const QString& t_fileRawName,
                     FiffEvents& p_Events);
 
    //=========================================================================================================
    static bool read_from_fif(QIODevice& p_IODevice,
                              FiffEvents& p_Events);
 
    //=========================================================================================================
    static bool read_from_ascii(QIODevice& p_IODevice,
                                FiffEvents& p_Events);
 
    //=========================================================================================================
    bool write_to_fif(QIODevice& p_IODevice) const;
 
    //=========================================================================================================
    bool write_to_ascii(QIODevice& p_IODevice,
                        float sfreq = 0.0f) const;
 
    //=========================================================================================================
    static bool detect_from_raw(const FiffRawData& raw,
                                FiffEvents& p_Events,
                                const QString& triggerCh = QString("STI 014"),
                                unsigned int triggerMask = 0xFFFFFFFF,
                                bool leadingEdge = true);
 
    //=========================================================================================================
    inline int num_events() const;
 
    //=========================================================================================================
    inline bool is_empty() const;
 
    //=========================================================================================================
    static bool matchEvent(const AverageCategory& cat,
                           const Eigen::MatrixXi& events,
                           int eventIdx);
 
    //=========================================================================================================
    FiffEvents pick(const QList<int>& include, const QList<int>& exclude = {}, bool step = false) const;
 
    //=========================================================================================================
    FiffEvents merge(const QList<int>& ids, int newId, bool replaceEvents = true) const;
 
    //=========================================================================================================
    QMap<int, int> count(const QList<int>& ids = {}) const;
 
    //=========================================================================================================
    static FiffEvents concatenate(const QList<FiffEvents>& events, const QList<int>& firstSamps, const QList<int>& lastSamps);
 
    //=========================================================================================================
    static FiffEvents find_stim_steps(const Eigen::MatrixXi& stimData,
                                      int firstSamp,
                                      std::optional<int> padStart = std::nullopt,
                                      std::optional<int> padStop = std::nullopt,
                                      int merge = 0);
 
    //=========================================================================================================
    static FiffEvents make_fixed_length(const FiffRawData& raw,
                                        int id = 1,
                                        double start = 0.0,
                                        double stop = -1.0,
                                        double duration = 1.0,
                                        bool firstSamp = true,
                                        double overlap = 0.0);
 
    Eigen::MatrixXi events; 
};
 
} // NAMESPACE
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
inline int FIFFLIB::FiffEvents::num_events() const
{
    return static_cast<int>(events.rows());
}
 
//=============================================================================================================
 
inline bool FIFFLIB::FiffEvents::is_empty() const
{
    return events.rows() == 0;
}
 
#endif // FIFF_EVENTS_H