inv_minimum_norm.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef INV_MINIMUM_NORM_H
#define INV_MINIMUM_NORM_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../inv_global.h"
 
#include <mne/mne_inverse_operator.h>
#include <mne/mne_mne_data.h>
#include "../inv_source_estimate.h"
#include <fs/fs_label.h>
 
#include <QSharedPointer>
 
//=============================================================================================================
// DEFINE NAMESPACE INVLIB
//=============================================================================================================
 
namespace INVLIB
{
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
class INVSHARED_EXPORT InvMinimumNorm
{
public:
    typedef QSharedPointer<InvMinimumNorm> SPtr;            
    typedef QSharedPointer<const InvMinimumNorm> ConstSPtr; 
 
    //=========================================================================================================
    explicit InvMinimumNorm(const MNELIB::MNEInverseOperator& p_inverseOperator, float lambda, const QString method);
 
    //=========================================================================================================
    explicit InvMinimumNorm(const MNELIB::MNEInverseOperator& p_inverseOperator, float lambda, bool dSPM, bool sLORETA);
 
    virtual ~InvMinimumNorm()
    {
    }
 
    //=========================================================================================================
    virtual InvSourceEstimate calculateInverse(const FIFFLIB::FiffEvoked& p_fiffEvoked, bool pick_normal = false);
 
    virtual InvSourceEstimate calculateInverse(const Eigen::MatrixXd& data, float tmin, float tstep, bool pick_normal = false) const;
 
    //=========================================================================================================
    MNELIB::MNEMneData mneData(const FIFFLIB::FiffEvoked& p_fiffEvoked, double snr = 0.0);
 
    //=========================================================================================================
    virtual void doInverseSetup(qint32 nave, bool pick_normal = false);
 
    //=========================================================================================================
    virtual const char* getName() const;
 
    //=========================================================================================================
    virtual const MNELIB::MNESourceSpaces& getSourceSpace() const;
 
    //=========================================================================================================
    inline MNELIB::MNEInverseOperator& getPreparedInverseOperator();
 
    //=========================================================================================================
    void setMethod(QString method);
 
    //=========================================================================================================
    void setMethod(bool dSPM, bool sLORETA, bool eLoreta = false);
 
    //=========================================================================================================
    void setRegularization(float lambda);
 
    //=========================================================================================================
    void setELoretaOptions(int maxIter = 20, double eps = 1e-6, bool forceEqual = false);
 
    //=========================================================================================================
    inline Eigen::MatrixXd& getKernel();
 
private:
    //=========================================================================================================
    void computeELoreta();
 
    MNELIB::MNEInverseOperator m_inverseOperator; 
    float m_fLambda;                              
    QString m_sMethod;                            
    bool m_bsLORETA;                              
    bool m_bdSPM;                                 
    bool m_beLoreta;                              
 
    // eLORETA parameters
    int m_iELoretaMaxIter;     
    double m_dELoretaEps;      
    bool m_bELoretaForceEqual; 
 
    bool inverseSetup;                      
    MNELIB::MNEInverseOperator inv;         
    Eigen::SparseMatrix<double> noise_norm; 
    QList<Eigen::VectorXi> vertno;          
    FSLIB::FsLabel label;                   
    Eigen::MatrixXd K;                      
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
inline Eigen::MatrixXd& InvMinimumNorm::getKernel()
{
    return K;
}
 
//=============================================================================================================
 
inline MNELIB::MNEInverseOperator& InvMinimumNorm::getPreparedInverseOperator()
{
    return inv;
}
} //NAMESPACE
 
#endif // INV_MINIMUM_NORM_H