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_source_space.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>
#include <vector>
 
//=============================================================================================================
// DEFINE NAMESPACE MNELIB
//=============================================================================================================
 
namespace MNELIB
{
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
class MNESHARED_EXPORT MNEHemisphere : public MNESourceSpace
{
public:
    using SPtr = std::shared_ptr<MNEHemisphere>;             
    using ConstSPtr = std::shared_ptr<const MNEHemisphere>;  
 
    //=========================================================================================================
    MNEHemisphere();
 
    //=========================================================================================================
    MNEHemisphere(const MNEHemisphere& p_MNEHemisphere);
 
    //=========================================================================================================
    ~MNEHemisphere() override;
 
    //=========================================================================================================
    MNESourceSpace::SPtr clone() const override;
 
    //=========================================================================================================
    bool add_geometry_info();
 
    //=========================================================================================================
    bool complete_source_space_info();
 
    //=========================================================================================================
    bool compute_patch_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);
 
    //=========================================================================================================
    MNEHemisphere& operator=(const MNEHemisphere& other);
 
    //ToDo write(IODevice &)

    friend bool operator== (const MNEHemisphere &a, const MNEHemisphere &b);
 
public:
    // --- Fields inherited from MNESurfaceOrVolume via MNESourceSpace ---
    // type, id, np, ntri, coord_frame, rr, nn, nuse, inuse, vertno,
    // nuse_tri, dist_limit, dist, nearest, neighbor_tri, neighbor_vert
    // are all available through the base class.
    // Use nearestVertIdx() / nearestDistVec() accessors for VectorXi/VectorXd views.
 
    // --- Shadowing fields (different type from base — TODO: unify in Phase 2) ---
    // tris / use_tris removed: now use inherited itris / use_itris (TrianglesT, row-major)
    // nearest / nearest_dist removed: now use inherited vector<MNENearest> nearest
    //   + nearestVertIdx() / nearestDistVec() accessors
    // dist removed: now use inherited FiffSparseMatrix dist + toEigenSparse() / fromEigenSparse()
    QList<Eigen::VectorXi> pinfo;       
    Eigen::VectorXi patch_inds;         
 
    // --- MNEHemisphere-specific fields ---
    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;       
 
    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.itris.isApprox(b.itris) &&
            a.nuse == b.nuse &&
            a.inuse.isApprox(b.inuse) &&
            a.vertno.isApprox(b.vertno) &&
            a.nuse_tri == b.nuse_tri &&
            a.use_itris.isApprox(b.use_itris) &&
            a.nearestVertIdx().isApprox(b.nearestVertIdx()) &&
            a.nearestDistVec().isApprox(b.nearestDistVec(), 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, &b]() {
                const auto& sa = a.dist.eigen();
                const auto& sb = b.dist.eigen();
                if (sa.rows() == 0 && sb.rows() == 0 && sa.cols() == 0 && sb.cols() == 0)
                    return true;
                return sa.toDense().isApprox(sb.toDense(), 0.0001f);
            }() &&
            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, &b]() {
                if (a.neighbor_tri.size() != b.neighbor_tri.size()) return false;
                for (size_t i = 0; i < a.neighbor_tri.size(); ++i) {
                    if (a.neighbor_tri[i].size() != b.neighbor_tri[i].size()) return false;
                    if (a.neighbor_tri[i].size() > 0 && !(a.neighbor_tri[i].array() == b.neighbor_tri[i].array()).all()) return false;
                }
                return true;
            }() &&
            [&a, &b]() {
                if (a.neighbor_vert.size() != b.neighbor_vert.size()) return false;
                for (size_t i = 0; i < a.neighbor_vert.size(); ++i) {
                    if (a.neighbor_vert[i].size() != b.neighbor_vert[i].size()) return false;
                    if (a.neighbor_vert[i].size() > 0 && !(a.neighbor_vert[i].array() == b.neighbor_vert[i].array()).all()) return false;
                }
                return true;
            }() &&
            a.cluster_info == b.cluster_info &&
            a.m_TriCoords.isApprox(b.m_TriCoords, 0.0001f));
}
} // NAMESPACE
 
#endif // MNE_HEMISPHERE_H