fiff_sparse_matrix.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef FIFFSPARSEMATRIX_H
#define FIFFSPARSEMATRIX_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "fiff_global.h"
#include "fiff_types.h"
#include "fiff_tag.h"
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
#include <Eigen/SparseCore>
 
//=============================================================================================================
// STL INCLUDES
//=============================================================================================================
 
#include <memory>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QSharedPointer>
#include <QDebug>
 
//=============================================================================================================
// DEFINE NAMESPACE FIFFLIB
//=============================================================================================================
 
namespace FIFFLIB
{
 
//=============================================================================================================
class FIFFSHARED_EXPORT FiffSparseMatrix
{
public:
    using SPtr = QSharedPointer<FiffSparseMatrix>;             
    using ConstSPtr = QSharedPointer<const FiffSparseMatrix>;  
    using UPtr = std::unique_ptr<FiffSparseMatrix>;            
    using ConstUPtr = std::unique_ptr<const FiffSparseMatrix>; 
 
    //=========================================================================================================
    FiffSparseMatrix();
 
    //=========================================================================================================
    explicit FiffSparseMatrix(Eigen::SparseMatrix<float>&& mat,
                              FIFFLIB::fiff_int_t coding = FIFFTS_MC_RCS);
 
    //=========================================================================================================
    FiffSparseMatrix(const FiffSparseMatrix& mat) = default;
 
    //=========================================================================================================
    FiffSparseMatrix(FiffSparseMatrix&& mat) = default;
 
    //=========================================================================================================
    FiffSparseMatrix& operator=(const FiffSparseMatrix&) = default;
 
    //=========================================================================================================
    FiffSparseMatrix& operator=(FiffSparseMatrix&&) = default;
 
    //=========================================================================================================
    ~FiffSparseMatrix() = default;
 
    //============================= Eigen access =============================

    inline Eigen::SparseMatrix<float>& eigen()
    {
        return m_eigen;
    }

    inline const Eigen::SparseMatrix<float>& eigen() const
    {
        return m_eigen;
    }

    inline operator const Eigen::SparseMatrix<float>&() const
    {
        return m_eigen;
    }

    inline int rows() const
    {
        return static_cast<int>(m_eigen.rows());
    }

    inline int cols() const
    {
        return static_cast<int>(m_eigen.cols());
    }

    inline int nonZeros() const
    {
        return static_cast<int>(m_eigen.nonZeros());
    }
 
    //============================= fiff_sparse.c =============================

    static std::vector<int> fiff_get_matrix_sparse_dims(const FIFFLIB::FiffTag::UPtr& tag);

    static FiffSparseMatrix::UPtr fiff_get_float_sparse_matrix(const FIFFLIB::FiffTag::UPtr& tag);
 
    //============================= mne_sparse_matop.c =============================

    static FiffSparseMatrix::UPtr create_sparse_rcs(int nrow,
                                                    int ncol,
                                                    int* nnz,
                                                    int** colindex,
                                                    float** vals);

    FiffSparseMatrix::UPtr mne_add_upper_triangle_rcs();

    FiffSparseMatrix::UPtr pickLowerTriangleRcs() const;

    inline bool is_empty() const;

    inline Eigen::SparseMatrix<double> toEigenSparse() const;

    static FiffSparseMatrix fromEigenSparse(const Eigen::SparseMatrix<double>& mat);

    static FiffSparseMatrix fromEigenSparse(const Eigen::SparseMatrix<float>& mat);
 
public:
    FIFFLIB::fiff_int_t coding; 
 
private:
    Eigen::SparseMatrix<float> m_eigen; 
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
inline bool FiffSparseMatrix::is_empty() const
{
    return m_eigen.nonZeros() <= 0;
}
 
inline Eigen::SparseMatrix<double> FiffSparseMatrix::toEigenSparse() const
{
    return m_eigen.cast<double>();
}
 
} // NAMESPACE FIFFLIB
 
#endif // FIFFSPARSEMATRIX_H