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 "../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;
 
    //=========================================================================================================
    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