hpifit.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef HPIFIT_H
#define HPIFIT_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../inverse_global.h"
#include "fiff/fiff_ch_info.h"
#include "sensorset.h"
#include "signalmodel.h"
#include <fiff/fiff_dig_point_set.h>
#include <fiff/fiff_dig_point.h>
#include <fiff/fiff_coord_trans.h>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QSharedPointer>
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
namespace FWDLIB{
    class FwdCoil;
    class FwdCoilSet;
}
 
namespace FIFFLIB{
    class FiffInfo;
    class FiffCoordTrans;
    class FiffDigPointSet;
}
 
//=============================================================================================================
// DEFINE NAMESPACE INVERSELIB
//=============================================================================================================
 
namespace INVERSELIB
{
    class SensorSet;
    class SignalModel;
    class HpiModelParameters;
//=============================================================================================================
// Declare all structures to be used
//=============================================================================================================

struct CoilParam {
    Eigen::MatrixXd pos;
    Eigen::MatrixXd mom;
    Eigen::VectorXd dpfiterror;
    Eigen::VectorXd dpfitnumitr;
 
    CoilParam(int iNumCoils)
        : pos(Eigen::MatrixXd(iNumCoils,3)),
          mom(Eigen::MatrixXd::Zero(iNumCoils,3)),
          dpfiterror(Eigen::VectorXd::Zero(iNumCoils)),
          dpfitnumitr(Eigen::VectorXd::Zero(iNumCoils))
    {}
};

struct HpiFitResult {
    QVector<int>                hpiFreqs;
    FIFFLIB::FiffDigPointSet    fittedCoils;
    FIFFLIB::FiffCoordTrans     devHeadTrans;
    QVector<double>             errorDistances;
    Eigen::VectorXd             GoF;
    QString                     sFilePathDigitzers;
    bool                        bIsLargeHeadMovement;
    float                       fHeadMovementDistance;
    float                       fHeadMovementAngle;
};
 
//=============================================================================================================
// INVERSELIB FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
class INVERSESHARED_EXPORT HPIFit
{
 
public:
    typedef QSharedPointer<HPIFit> SPtr;             
    typedef QSharedPointer<const HPIFit> ConstSPtr;  
 
    //=========================================================================================================
    explicit HPIFit();
 
    //=========================================================================================================
    explicit HPIFit(const SensorSet& sensorSet);
 
    //=========================================================================================================
    void checkForUpdate(const SensorSet& sensorSet);
 
    //=========================================================================================================
    void fit(const Eigen::MatrixXd& matProjectedData,
             const Eigen::MatrixXd& matProjectors,
             const HpiModelParameters& hpiModelParameters,
             const Eigen::MatrixXd& matCoilsHead,
             HpiFitResult& hpiFitResult);
 
    void fit(const Eigen::MatrixXd& matProjectedData,
             const Eigen::MatrixXd& matProjectors,
             const HpiModelParameters& hpiModelParameters,
             const Eigen::MatrixXd& matCoilsHead,
             const bool bOrderFrequencies,
             HpiFitResult& hpiFitResult);
 
    //=========================================================================================================
    static void storeHeadPosition(float fTime,
                                  const Eigen::MatrixXf& matTransDevHead,
                                  Eigen::MatrixXd& matPosition,
                                  const Eigen::VectorXd& vecGoF,
                                  const QVector<double>& vecError);
 
private:
 
    //=========================================================================================================
    Eigen::MatrixXd computeAmplitudes(const Eigen::MatrixXd& matProjectedData,
                                      const HpiModelParameters& hpiModelParameters);
 
    //=========================================================================================================
    Eigen::MatrixXd computeSeedPoints(const Eigen::MatrixXd& matAmplitudes,
                                      const FIFFLIB::FiffCoordTrans& transDevHead,
                                      const QVector<double>& vecError,
                                      const Eigen::MatrixXd& matCoilsHead);
 
    //=========================================================================================================
    CoilParam dipfit(const Eigen::MatrixXd matCoilsSeed,
                     const SensorSet& sensors,
                     const Eigen::MatrixXd &matData,
                     const int iNumCoils,
                     const Eigen::MatrixXd &t_matProjectors,
                     const int iMaxIterations,
                     const float fAbortError);
 
    //=========================================================================================================
    Eigen::VectorXd computeGoF(const Eigen::VectorXd& vecDipFitError);
 
    //=========================================================================================================
    FIFFLIB::FiffCoordTrans computeDeviceHeadTransformation(const Eigen::MatrixXd& matCoilsDev,
                                                            const Eigen::MatrixXd& matCoilsHead);
 
    //=========================================================================================================
    QVector<double> computeEstimationError(const Eigen::MatrixXd& matCoilsDev,
                                           const Eigen::MatrixXd& matCoilsHead,
                                           const FIFFLIB::FiffCoordTrans& transDevHead);
 
    //=========================================================================================================
    FIFFLIB::FiffDigPointSet getFittedPointSet(const Eigen::MatrixXd& matCoilsDev);
 
    //=========================================================================================================
    Eigen::Matrix4d computeTransformation(Eigen::MatrixXd matNH,
                                          Eigen::MatrixXd matBT);
 
    //=========================================================================================================
    std::vector<int> findCoilOrder(const Eigen::MatrixXd& matCoilsDev,
                                   const Eigen::MatrixXd& matCoilsHead);
 
    //=========================================================================================================
    Eigen::MatrixXd order(const std::vector<int>& vecOrder,
                          const Eigen::MatrixXd& matToOrder);
 
    QVector<int> order(const std::vector<int>& vecOrder,
                       const QVector<int>& vecToOrder);
 
    //=========================================================================================================
    double objectTrans(const Eigen::MatrixXd& matHeadCoil,
                       const Eigen::MatrixXd& matCoilsDev,
                       const Eigen::MatrixXd& matTrans);
 
    SensorSet m_sensors;            
    SignalModel m_signalModel;      
 
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
} //NAMESPACE
 
#ifndef metatype_HpiFitResult
#define metatype_HpiFitResult
Q_DECLARE_METATYPE(INVERSELIB::HpiFitResult)
#endif
 
#endif // HPIFIT_H