minimumnorm.h

Go to the documentation of this file.

//=============================================================================================================
#ifndef MINIMUMNORM_H
#define MINIMUMNORM_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../inverse_global.h"
#include "../IInverseAlgorithm.h"
 
#include <mne/mne_inverse_operator.h>
#include <fs/label.h>
 
#include <QSharedPointer>
 
//=============================================================================================================
// DEFINE NAMESPACE INVERSELIB
//=============================================================================================================
 
namespace INVERSELIB
{
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
class INVERSESHARED_EXPORT MinimumNorm : public IInverseAlgorithm
{
public:
    typedef QSharedPointer<MinimumNorm> SPtr;             
    typedef QSharedPointer<const MinimumNorm> ConstSPtr;  
    //=========================================================================================================
    explicit MinimumNorm(const MNELIB::MNEInverseOperator &p_inverseOperator, float lambda, const QString method);
 
    //=========================================================================================================
    explicit MinimumNorm(const MNELIB::MNEInverseOperator &p_inverseOperator, float lambda, bool dSPM, bool sLORETA);
 
    virtual ~MinimumNorm(){}
 
    //=========================================================================================================
    virtual MNELIB::MNESourceEstimate calculateInverse(const FIFFLIB::FiffEvoked &p_fiffEvoked, bool pick_normal = false);
 
    virtual MNELIB::MNESourceEstimate 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::MNESourceSpace& getSourceSpace() const;
 
    //=========================================================================================================
    inline MNELIB::MNEInverseOperator& getPreparedInverseOperator();
 
    //=========================================================================================================
    void setMethod(QString method);
 
    //=========================================================================================================
    void setMethod(bool dSPM, bool sLORETA);
 
    //=========================================================================================================
    void setRegularization(float lambda);
 
    //=========================================================================================================
    inline Eigen::MatrixXd& getKernel();
 
private:
    MNELIB::MNEInverseOperator m_inverseOperator;   
    float m_fLambda;                                
    QString m_sMethod;                              
    bool m_bsLORETA;                                
    bool m_bdSPM;                                   
    bool inverseSetup;                              
    MNELIB::MNEInverseOperator inv;                 
    Eigen::SparseMatrix<double> noise_norm;         
    QList<Eigen::VectorXi> vertno;                  
    FSLIB::Label label;                             
    Eigen::MatrixXd K;                              
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
inline Eigen::MatrixXd& MinimumNorm::getKernel()
{
    return K;
}
 
//=============================================================================================================
 
inline MNELIB::MNEInverseOperator& MinimumNorm::getPreparedInverseOperator()
{
    return inv;
}
} //NAMESPACE
 
#endif // MINIMUMNORM_H