fiff_coord_trans.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef FIFF_COORD_TRANS_H
#define FIFF_COORD_TRANS_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "fiff_global.h"
#include "fiff_types.h"
#include "fiff_stream.h"
#include "fiff_dir_node.h"
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QIODevice>
#include <QSharedPointer>
 
#include <memory>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// DEFINE NAMESPACE FIFFLIB
//=============================================================================================================
 
namespace FIFFLIB
{
 
// Forward declaration
class FiffTag;
 
//=============================================================================================================
class FIFFSHARED_EXPORT FiffCoordTrans
{
public:
    using SPtr = QSharedPointer<FiffCoordTrans>;             
    using ConstSPtr = QSharedPointer<const FiffCoordTrans>;  
    using UPtr = std::unique_ptr<FiffCoordTrans>;            
    using ConstUPtr = std::unique_ptr<const FiffCoordTrans>; 
 
    //=========================================================================================================
    FiffCoordTrans();
 
    //=========================================================================================================
    FiffCoordTrans(QIODevice& p_IODevice);
 
    //=========================================================================================================
    FiffCoordTrans(const FiffCoordTrans& p_FiffCoordTrans);
 
    //=========================================================================================================
    FiffCoordTrans& operator=(const FiffCoordTrans& p_FiffCoordTrans) = default;
 
    //=========================================================================================================
    FiffCoordTrans(int from, int to, const Eigen::Matrix3f& rot, const Eigen::Vector3f& move);
 
    //=========================================================================================================
    FiffCoordTrans(int from, int to, const Eigen::Matrix4f& matTrans, bool bStandard = false);
 
    //=========================================================================================================
    ~FiffCoordTrans();
 
    //=========================================================================================================
    void clear();
 
    //=========================================================================================================
    bool invert_transform();
 
    //=========================================================================================================
    inline bool isEmpty() const
    {
        return this->from < 0;
    }
 
    //=========================================================================================================

    auto rot()
    {
        return trans.block<3, 3>(0, 0);
    }

    auto rot() const
    {
        return trans.block<3, 3>(0, 0);
    }

    auto move()
    {
        return trans.block<3, 1>(0, 3);
    }

    auto move() const
    {
        return trans.block<3, 1>(0, 3);
    }

    auto invrot()
    {
        return invtrans.block<3, 3>(0, 0);
    }

    auto invrot() const
    {
        return invtrans.block<3, 3>(0, 0);
    }

    auto invmove()
    {
        return invtrans.block<3, 1>(0, 3);
    }

    auto invmove() const
    {
        return invtrans.block<3, 1>(0, 3);
    }

 
    //=========================================================================================================
    static bool read(QIODevice& p_IODevice, FiffCoordTrans& p_Trans);
 
    //=========================================================================================================
    static FiffCoordTrans readTransform(const QString& name, int from, int to);
 
    //=========================================================================================================
    static FiffCoordTrans readMriTransform(const QString& name);
 
    //=========================================================================================================
    static FiffCoordTrans readMeasTransform(const QString& name);
 
    //=========================================================================================================
    static FiffCoordTrans readTransformAscii(const QString& name, int from, int to);
 
    //=========================================================================================================
    static FiffCoordTrans readFShead2mriTransform(const QString& name);
 
    //=========================================================================================================
    Eigen::MatrixX3f apply_trans(const Eigen::MatrixX3f& rr, bool do_move = true) const;
 
    //=========================================================================================================
    Eigen::MatrixX3f apply_inverse_trans(const Eigen::MatrixX3f& rr, bool do_move = true) const;
 
    //=========================================================================================================
    static void apply_trans(float r[3], const FiffCoordTrans& t, bool do_move);
 
    //=========================================================================================================
    static void apply_inverse_trans(float r[3], const FiffCoordTrans& t, bool do_move);
 
    //=========================================================================================================
    static QString frame_name(int frame);
 
    //=========================================================================================================
    static FiffCoordTrans identity(int from, int to);
 
    //=========================================================================================================
    FiffCoordTrans inverted() const;
 
    //=========================================================================================================
    static FiffCoordTrans combine(int from, int to, const FiffCoordTrans& t1, const FiffCoordTrans& t2);
 
    //=========================================================================================================
    static FiffCoordTrans fromCardinalPoints(int from, int to, const float* rL, const float* rN, const float* rR);
 
    //=========================================================================================================
    static bool addInverse(FiffCoordTrans& t);
 
    //=========================================================================================================
    void print() const;
 
    //=========================================================================================================
    bool write(QIODevice& p_IODevice);
 
    //=========================================================================================================
    void writeToStream(FiffStream* p_pStream);
 
    //=========================================================================================================
    inline static qint32 storageSize();
 
    //========================================================================================================
    friend bool operator==(const FiffCoordTrans& a, const FiffCoordTrans& b);
 
    //========================================================================================================
    float angleTo(Eigen::MatrixX4f mTransDest);
 
    //========================================================================================================
    float translationTo(Eigen::MatrixX4f mTransDest);
 
    //========================================================================================================
    static FiffCoordTrans readFromTag(const std::unique_ptr<FiffTag>& tag);
 
    //========================================================================================================
    static FiffCoordTrans readTransformFromNode(FiffStream::SPtr& stream,
                                                const FiffDirNode::SPtr& node,
                                                int from, int to);
 
    //========================================================================================================
    static FiffCoordTrans procrustesAlign(int from_frame, int to_frame,
                                          const Eigen::MatrixXf& fromp,
                                          const Eigen::MatrixXf& top,
                                          const Eigen::VectorXf& w,
                                          float max_diff);
 
public:
    fiff_int_t from;                                       
    fiff_int_t to;                                         
    Eigen::Matrix<float, 4, 4, Eigen::DontAlign> trans;    
    Eigen::Matrix<float, 4, 4, Eigen::DontAlign> invtrans; 
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
 
inline qint32 FiffCoordTrans::storageSize()
{
    // On-disk layout: from, to, rot[3][3], move[3], invrot[3][3], invmove[3]
    // (C++ class uses Matrix4f but on-disk stores 3x3 rot + 3-vec separately)
    return 2 * sizeof(fiff_int_t) + 2 * 12 * sizeof(fiff_float_t);
}
 
//=============================================================================================================
 
inline bool operator==(const FiffCoordTrans& a, const FiffCoordTrans& b)
{
    return (a.from == b.from &&
            a.to == b.to &&
            a.trans.isApprox(b.trans, 0.0001f) &&
            a.invtrans.isApprox(b.invtrans, 0.0001f));
}
} // NAMESPACE
 
#ifndef metatype_fiffcoordtrans
#define metatype_fiffcoordtrans
Q_DECLARE_METATYPE(FIFFLIB::FiffCoordTrans); 
#endif
 
#ifndef metatype_fiffcoordtrans_sptr
#define metatype_fiffcoordtrans_sptr
Q_DECLARE_METATYPE(FIFFLIB::FiffCoordTrans::SPtr); 
#endif
 
#endif // FIFF_COORD_TRANS_H