mne_source_spaces.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef MNE_SOURCE_SPACES_H
#define MNE_SOURCE_SPACES_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "mne_global.h"
#include "mne_hemisphere.h"
 
#include <fiff/fiff_types.h>
#include <fiff/fiff_dir_node.h>
#include <fiff/fiff.h>
 
#include <algorithm>
#include <vector>
#include <memory>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QList>
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
namespace FSLIB
{
    class FsLabel;
}
 
//=============================================================================================================
// DEFINE NAMESPACE MNELIB
//=============================================================================================================
 
namespace MNELIB
{
 
//=============================================================================================================
// MNELIB FORWARD DECLARATIONS
//=============================================================================================================
 
//=============================================================================================================
class MNESHARED_EXPORT MNESourceSpaces
{
public:
    using SPtr = std::shared_ptr<MNESourceSpaces>;            
    using ConstSPtr = std::shared_ptr<const MNESourceSpaces>; 
 
    //=========================================================================================================
    MNESourceSpaces();
 
    //=========================================================================================================
    MNESourceSpaces(const MNESourceSpaces &p_MNESourceSpaces);
 
    //=========================================================================================================
    ~MNESourceSpaces();
 
    //=========================================================================================================
    void clear();
 
    //=========================================================================================================
    inline bool isEmpty() const;
 
    //=========================================================================================================
    static qint32 find_source_space_hemi(MNESourceSpace& p_SourceSpace);
 
    //=========================================================================================================
    QList<Eigen::VectorXi> get_vertno() const;
 
    //=========================================================================================================
    QList<Eigen::VectorXi> label_src_vertno_sel(const FSLIB::FsLabel &p_label, Eigen::VectorXi &src_sel) const;
 
    //=========================================================================================================
    static bool patch_info(MNEHemisphere &p_Hemisphere);//VectorXi& nearest, QList<VectorXi>& pinfo);@param[in] nearest   The nearest vector of the source space.@param[in, out] pinfo    The requested patch information.
 
    //=========================================================================================================
    MNESourceSpaces pick_regions(const QList<FSLIB::FsLabel> &p_qListLabels) const;
 
    //=========================================================================================================
    static bool readFromStream(FIFFLIB::FiffStream::SPtr& p_pStream,
                               bool add_geom,
                               MNESourceSpaces& p_SourceSpace);
 
    //=========================================================================================================
    inline qint32 size() const;
 
    //=========================================================================================================
    bool transform_source_space_to(FIFFLIB::fiff_int_t dest,
                                   FIFFLIB::FiffCoordTrans& trans);
 
    //=========================================================================================================
    void writeToStream(FIFFLIB::FiffStream* p_pStream);
 
    //=========================================================================================================
    void append(const MNESourceSpace& space);
 
    //=========================================================================================================
    MNESourceSpace& operator[] (qint32 idx);
 
    //=========================================================================================================
    const MNESourceSpace& operator[] (qint32 idx) const;
 
    //=========================================================================================================
    MNESourceSpace& operator[] (QString idt);
 
    //=========================================================================================================
    const MNESourceSpace& operator[] (QString idt) const;
 
    //=========================================================================================================
    MNEHemisphere* hemisphereAt(qint32 idx);
 
    //=========================================================================================================
    const MNEHemisphere* hemisphereAt(qint32 idx) const;
 
    //=========================================================================================================
    std::shared_ptr<MNESourceSpace>& at(qint32 idx);
 
    //=========================================================================================================
    const std::shared_ptr<MNESourceSpace>& at(qint32 idx) const;

    friend bool operator== (const MNESourceSpaces &a, const MNESourceSpaces &b);
 
private:
 
    //=========================================================================================================
    static bool complete_source_space_info(MNEHemisphere& p_Hemisphere);
 
    //=========================================================================================================
    static bool read_source_space(FIFFLIB::FiffStream::SPtr& p_pStream,
                                  const FIFFLIB::FiffDirNode::SPtr& p_Tree,
                                  MNEHemisphere& p_Hemisphere);
 
private:
    std::vector<std::shared_ptr<MNESourceSpace>> m_sourceSpaces;    
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
inline bool MNESourceSpaces::isEmpty() const
{
    return m_sourceSpaces.empty();
}
 
//=============================================================================================================
 
inline qint32 MNESourceSpaces::size() const
{
    return static_cast<qint32>(m_sourceSpaces.size());
}
 
//=============================================================================================================
 
inline bool operator== (const MNESourceSpaces &a, const MNESourceSpaces &b)
{
    if (a.size() != b.size())
        return false;
    for (qint32 i = 0; i < a.size(); ++i) {
        // Compare as hemispheres if both elements are hemispheres
        auto* ha = dynamic_cast<const MNEHemisphere*>(&a[i]);
        auto* hb = dynamic_cast<const MNEHemisphere*>(&b[i]);
        if (ha && hb) {
            if (!(*ha == *hb))
                return false;
        } else {
            // Fallback: compare base-class identity (pointer equality or basic fields)
            // For now, require both to be hemispheres for equality
            return false;
        }
    }
    return true;
}
 
} // NAMESPACE
 
#endif // MNE_SOURCE_SPACES_H