AwChannel.h

// 
//                 Université d’Aix Marseille (AMU) - 
//                 Institut National de la Santé et de la Recherche Médicale (INSERM)
//                 Copyright © 2013 AMU, INSERM
// 
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 3 of the License, or (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//
//
//    Author: Bruno Colombet – Laboratoire UMR INS INSERM 1106 - Bruno.Colombet@univ-amu.fr
//
#ifndef AWCHANNEL_H
#define AWCHANNEL_H
#include <QStringList>
#include <QUuid>
#include <QVariant>
#include <QSemaphore>
#include <QVector>
class AwProcess;

class AwChannel 
{
public:
    enum ChannelType {EEG = 0, SEEG = 1, MEG = 2, EMG = 3, ECG = 4, Reference = 5, Trigger = 6, Other = 7};
    enum SourceType { Real, Virtual };      
    
    AwChannel();
    AwChannel(AwChannel *chan);
    virtual ~AwChannel();

    virtual AwChannel* duplicate();

    static QStringList types(); 

    float *newData(int length);
    void clearData();

    inline SourceType sourceType() { return m_sourceType; }
    inline float gain() { return m_gain; }
    inline float samplingRate() { return m_samplingRate; }
    inline QString& name() {return m_name; } 

    inline int ID() { return m_ID; }

    inline int dataSize() { return m_dataSize; }

    inline float *data() { return m_data; }         

    inline QString& unit() { return m_unit; }

    inline double x() { return m_x; }
    inline double y() { return m_y; }
    inline double z() { return m_z; }

    inline double ox() { return m_ox; }
    inline double oy() { return m_oy; }
    inline double oz() { return m_oz; }

    void xyz(double *x, double *y, double *z);

    void orientationXyz(double *ox, double *oy, double *oz);

    inline bool isBad() { return m_bad; }

    inline int type() { return m_type; }

    inline QString& referenceName() { return m_referenceName; }

    inline QList<AwChannel *>& references() { return m_references; }        

    inline bool isVisible() { return m_visible; }

    inline QString& color() { return m_color; }

    inline float highFilter() { return m_highFilter; }

    inline float notch() { return m_notch; }

    inline bool hasReferences() { return !m_referenceName.isEmpty(); }

    inline float lowFilter() { return m_lowFilter; }

    inline AwChannel *parent() { return m_parent; }

    inline QString& displayPluginName() { return m_registeredDisplayPlugin; }

    inline bool hasCoordinates() { return m_hasCoordinates; }

    inline bool isEEG() { return m_type == AwChannel::EEG; }
    inline bool isMEG() { return m_type == AwChannel::MEG; }
    inline bool isReference() { return m_type == AwChannel::Reference; }
    inline bool isECG() { return m_type == AwChannel::ECG; }
    inline bool isTrigger() { return m_type == AwChannel::Trigger; }
    inline bool isOther() { return m_type == AwChannel::Other; }
    inline bool isEMG() { return m_type == AwChannel::EMG; }
    inline bool isSEEG() { return m_type == AwChannel::SEEG; }
    inline bool isVirtual() { return m_sourceType == AwChannel::Virtual; }

    bool isDataReady(); 

    inline bool isSelected() { return m_isSelected; }

    inline QVariantList& customData() { return m_customData; }

    // SET

    void addRef(AwChannel *ref);
    void clearRefChannels();
    void clearRefName();
    void setParent(AwChannel *parent);

    void setDisplayPluginName(const QString& name);

    void setUnit(const char *u);
    void setUnit(const QString& u);

    void setGain(float factor);
    void setSamplingRate(float rate);
    void setName(const QString& Name);
    void setColor(const QString& col); 

    void setID(quint32 id);

    void setXYZ(double x, double y, double z);
    void setOrientationXYZ(double ox, double oy, double oz);
    void setBad(bool flag);
    void setType(int t);

    void setVisible(bool flag);         

    void setReferenceName(const QString& ref);  

    void setHighFilter(float val);
    void setLowFilter(float val);

    void setNotch(float val);       
    void setCustomData(const QVariantList& data) { m_customData = data; }

    void setSourceType(SourceType stype);
                                            
    void addProcess(AwProcess *process);

    static int stringToType(const QString& s);

    static QString typeToString(int t);

    void setDataReady(bool flag = true);

    void setSelected(bool flag);

protected:
    quint32 m_ID;                   
    bool m_dataReady;
    float m_gain;                   
    float m_samplingRate;   
    QString m_name; 
    float *m_data;

    int m_dataSize;
    QString m_unit;         // Unité du signal (µV, fT, etc.)
    // xyz coordinates
    double m_x;             
    double m_y;
    double m_z;
    // orientation vector
    double m_ox;                
    double m_oy;
    double m_oz;

    bool m_bad;             
    bool m_isSelected;
    int m_type;
    bool m_hasCoordinates;  
    SourceType m_sourceType;
    QString m_registeredDisplayPlugin;      // Optional name of a Display Plugin that will display the channel. 
                                            // If empty, AnyWave will use the default plugin to render signals.
    AwChannel *m_parent;
    QString m_referenceName;                    
    QList<AwChannel *> m_references;    
    bool m_visible;
    QString m_color;
    float m_lowFilter;   
    float m_highFilter;   
    float m_notch;
    QList<AwProcess *> m_processes;         // list of process that might be linked to the channel
    QVariantList m_customData;              // Custom data associated with the channel.
};

typedef QList<AwChannel *> AwChannelList;  
Q_DECLARE_METATYPE(AwChannelList)

class AwVirtualChannel : public AwChannel
{
public:
    AwVirtualChannel() : AwChannel() { m_sourceType = AwChannel::Virtual; /*m_isDataAvailable = false;*/ }
    AwVirtualChannel(AwChannel *chan) : AwChannel(chan) { m_sourceType = AwChannel::Virtual; }
    AwVirtualChannel(AwVirtualChannel *chan);
    virtual ~AwVirtualChannel();
    AwChannelList& connectedChannels() { return m_connectedChannels; }
    void connectChannels(const AwChannelList& channels);

    // overide setDataReady from AwChannel
    void setDataReady(bool f = true) { m_dataReady = f; update(); }
    
    virtual void compute() {}   // overide this method to compute data for the channel. Default implementation does nothing.
    virtual void update() {}    // overide this method to update the data content for the channel. Called each time data are set to the channel.
    virtual AwVirtualChannel *duplicate() { return new AwVirtualChannel(this); }
protected:
    AwChannelList m_connectedChannels;  // may be empty
};

#endif