mne_hemisphere.h

Go to the documentation of this file.

//=============================================================================================================
#ifndef MNE_HEMISPHERE_H
#define MNE_HEMISPHERE_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "mne_global.h"
#include "mne_cluster_info.h"
 
#include <fiff/fiff_types.h>
#include <fiff/fiff.h>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
#include <Eigen/SparseCore>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QList>
 
//=============================================================================================================
// DEFINE NAMESPACE MNELIB
//=============================================================================================================
 
namespace MNELIB
{
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
class MNESHARED_EXPORT MNEHemisphere
{
public:
    typedef QSharedPointer<MNEHemisphere> SPtr;             
    typedef QSharedPointer<const MNEHemisphere> ConstSPtr;  
    //=========================================================================================================
    MNEHemisphere();
 
    //=========================================================================================================
    MNEHemisphere(const MNEHemisphere& p_MNEHemisphere);
 
    //=========================================================================================================
    ~MNEHemisphere();
 
    //=========================================================================================================
    bool add_geometry_info();
 
    //=========================================================================================================
    void clear();
 
    //=========================================================================================================
    Eigen::MatrixXf& getTriCoords(float p_fScaling = 1.0f);
 
    //=========================================================================================================
    inline bool isClustered() const;
 
    //=========================================================================================================
    bool transform_hemisphere_to(FIFFLIB::fiff_int_t dest, const FIFFLIB::FiffCoordTrans &p_Trans);
 
    //=========================================================================================================
    void writeToStream(FIFFLIB::FiffStream* p_pStream);
 
    //ToDo write(IODevice &)
 
    friend bool operator== (const MNEHemisphere &a, const MNEHemisphere &b);
 
public:
    FIFFLIB::fiff_int_t type;           
    FIFFLIB::fiff_int_t id;             
    FIFFLIB::fiff_int_t np;             
    FIFFLIB::fiff_int_t ntri;           
    FIFFLIB::fiff_int_t coord_frame;    
    Eigen::MatrixX3f rr;                
    Eigen::MatrixX3f nn;                
    Eigen::MatrixX3i tris;              
    FIFFLIB::fiff_int_t nuse;           
    Eigen::VectorXi inuse;              
    Eigen::VectorXi vertno;             
    qint32 nuse_tri;                    
    Eigen::MatrixX3i use_tris;          
    Eigen::VectorXi nearest;            
    Eigen::VectorXd nearest_dist;       
    QList<Eigen::VectorXi> pinfo;       
    Eigen::VectorXi patch_inds;         
    float dist_limit;                   
    Eigen::SparseMatrix<double> dist;   
    Eigen::MatrixX3d tri_cent;          
    Eigen::MatrixX3d tri_nn;            
    Eigen::VectorXd tri_area;           
    Eigen::MatrixX3d use_tri_cent;      
    Eigen::MatrixX3d use_tri_nn;        
    Eigen::VectorXd use_tri_area;       
    QVector<QVector<int> > neighbor_tri;           
    QVector<QVector<int> > neighbor_vert;          
    MNEClusterInfo cluster_info; 
private:
    // Newly added
    Eigen::MatrixXf m_TriCoords; 
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
inline bool MNEHemisphere::isClustered() const
{
    return !cluster_info.isEmpty();
}
 
//=============================================================================================================
 
inline bool operator== (const MNEHemisphere &a, const MNEHemisphere &b)
{
    if(a.pinfo.size() == b.pinfo.size()) {
        for(int i = 0; i < a.pinfo.size(); ++i) {
            if(!a.pinfo.at(i).isApprox(b.pinfo.at(i))) {
                return false;
            }
        }
    } else {
        return false;
    }
 
    return (a.type == b.type &&
            a.id == b.id &&
            a.np == b.np &&
            a.ntri == b.ntri &&
            a.coord_frame == b.coord_frame &&
            a.rr.isApprox(b.rr, 0.0001f) &&
            a.nn.isApprox(b.nn, 0.0001f) &&
            a.tris.isApprox(b.tris) &&
            a.nuse == b.nuse &&
            a.inuse.isApprox(b.inuse) &&
            a.vertno.isApprox(b.vertno) &&
            a.nuse_tri == b.nuse_tri &&
            a.use_tris.isApprox(b.use_tris) &&
            a.nearest.isApprox(b.nearest) &&
            a.nearest_dist.isApprox(b.nearest_dist, 0.0001) &&
            a.patch_inds.isApprox(b.patch_inds) &&
            //a.dist_limit == b.dist_limit && //TODO: We still not sure if dist_limit can also be a matrix. This needs to be debugged
            a.dist.isApprox(b.dist, 0.0001) &&
            a.tri_cent.isApprox(b.tri_cent, 0.0001) &&
            a.tri_nn.isApprox(b.tri_nn, 0.0001) &&
            a.tri_area.isApprox(b.tri_area, 0.0001) &&
            a.use_tri_cent.isApprox(b.use_tri_cent, 0.0001) &&
            a.use_tri_nn.isApprox(b.use_tri_nn, 0.0001) &&
            a.use_tri_area.isApprox(b.use_tri_area, 0.0001) &&
            a.neighbor_tri == b.neighbor_tri &&
            a.neighbor_vert == b.neighbor_vert &&
            a.cluster_info == b.cluster_info &&
            a.m_TriCoords.isApprox(b.m_TriCoords, 0.0001f));
}
} // NAMESPACE
 
#endif // MNE_HEMISPHERE_H