mne_msh_display_surface.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef MNEMSHDISPLAYSURFACE_H
#define MNEMSHDISPLAYSURFACE_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "mne_global.h"
#include "mne_types.h"
#include "mne_surface.h"
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QSharedPointer>
#include <QString>
 
//=============================================================================================================
// STL INCLUDES
//=============================================================================================================
 
#include <memory>
#include <vector>
 
//=============================================================================================================
// DEFINE NAMESPACE MNELIB
//=============================================================================================================
 
namespace MNELIB
{
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
class MNEMorphMap;
class MNEMshPicked;
class MNEMshColorScaleDef;
 
} // NAMESPACE MNELIB
 
namespace FIFFLIB
{
class FiffDigitizerData;
}
 
namespace MNELIB
{
 
//=============================================================================================================
class MNESHARED_EXPORT MNEMshDisplaySurface : public MNESurface
{
public:
    typedef QSharedPointer<MNEMshDisplaySurface> SPtr;            
    typedef QSharedPointer<const MNEMshDisplaySurface> ConstSPtr; 
 
    //=========================================================================================================
    MNEMshDisplaySurface();
 
    //=========================================================================================================
    ~MNEMshDisplaySurface();
 
public:
    QString filename;                               
    time_t time_loaded = 0;                         
    QString subj;                                   
    QString surf_name;                              
    Eigen::Vector3f eye{1.0f, 0.0f, 0.0f};          
    Eigen::Vector3f up{0.0f, 0.0f, 1.0f};           
    Eigen::Vector3f rot = Eigen::Vector3f::Zero();  
    Eigen::Vector3f move = Eigen::Vector3f::Zero(); 
 
    float fov = 2.0f;                                        
    float fov_scale = 1.0f;                                  
    Eigen::Vector3f minv = Eigen::Vector3f::Constant(-1.0f); 
    Eigen::Vector3f maxv = Eigen::Vector3f::Constant(1.0f);  
    Eigen::Matrix4f trans = Eigen::Matrix4f::Identity();     
    bool sketch = false;                                     
 
    std::vector<std::unique_ptr<MNELIB::MNEMorphMap>> maps; 
 
    int overlay_type = 0;               
    Eigen::VectorXf overlay_values;     
    int alt_overlay_type = 0;           
    Eigen::VectorXf alt_overlay_values; 
    Eigen::VectorXf marker_values;      
 
    Eigen::VectorXf vertex_colors;                               
    std::unique_ptr<MNELIB::MNEMshColorScaleDef> color_scale;    
    int nvertex_colors = 3;                                      
    Eigen::Vector4f even_vertex_color = Eigen::Vector4f::Zero(); 
 
    Eigen::VectorXf marker_colors;                          
    int nmarker_colors = 3;                                 
    Eigen::MatrixXi marker_tri;                             
    Eigen::VectorXi marker_tri_no;                          
    int nmarker_tri = 0;                                    
    Eigen::Vector4f marker_color = Eigen::Vector4f::Zero(); 
    int curvature_color_mode = 0;                           
 
    int overlay_color_mode = 0; 
    bool transparent = false;   
 
    bool show_aux_data = false; 
 
    std::vector<MNELIB::MNEMshPicked> picked; 
 
    void* user_data = nullptr;                
    mneUserFreeFunc user_data_free = nullptr; 
 
    //=========================================================================================================
    // Alignment functions (moved from MNESurfaceOrVolume)
    //=========================================================================================================

    int align_fiducials(FIFFLIB::FiffDigitizerData& head_dig,
                        const FIFFLIB::FiffDigitizerData& mri_dig,
                        int niter,
                        int scale_head,
                        float omit_dist,
                        Eigen::Vector3f& scales);

    void get_head_scale(FIFFLIB::FiffDigitizerData& dig,
                        const Eigen::Matrix<float, 3, 3, Eigen::RowMajor>& mri_fid,
                        Eigen::Vector3f& scales);

    int discard_outlier_digitizer_points(FIFFLIB::FiffDigitizerData& d,
                                         float maxdist) const;

    void calculate_digitizer_distances(FIFFLIB::FiffDigitizerData& dig,
                                       bool do_all, bool do_approx) const;

    int iterate_alignment_once(FIFFLIB::FiffDigitizerData& dig,
                               int nasion_weight,
                               const std::optional<Eigen::Vector3f>& nasion_mri,
                               int last_step) const;

    float rms_digitizer_distance(FIFFLIB::FiffDigitizerData& dig) const;

    void scale(const Eigen::Vector3f& scales);

    void decide_surface_extent(const QString& tag);

    void decide_curv_display(const QString& name);

    void setup_curvature_colors();
 
    // ### OLD STRUCT ###
    //    typedef struct {      /* Display surface properties */
    //      char           *filename;   /* Where did this surface come from? */
    //      time_t         time_loaded; /* When was the surface loaded */
    //      char           *subj;       /* The name of the subject in SUBJECTS_DIR */
    //      char           *surf_name;  /* The name of the surface */
    //      MNELIB::MNESurface*     s;      /* This is the surface */
    //      float          eye[3];  /* Eye position for viewing */
    //      float          up[3];       /* Up vector for viewing */
    //      float          rot[3];        /* Rotation angles of the MRI (in radians) */
    //      float          move[3]; /* Possibly move the origin, too */
 
    //      float          fov;     /* Field of view (extent of the surface) */
    //      float          fov_scale;   /* How much space to leave */
    //      float          minv[3]; /* Minimum values along the three coordinate axes */
    //      float          maxv[3]; /* Maximum values along the three coordinate axes */
    //      float          *trans;  /* Extra transformation for this surface */
    //      int            sketch;  /* Use sketch mode if decimated triangulation is available? */
 
    //      morphMap       *maps;       /* Morphing maps from other surfaces to this */
    //      int            nmap;        /* Normally just one */
 
    //      int   overlay_type;         /* What are the overlay values? */
    //      float *overlay_values;  /* Overlay value array */
    //      int   alt_overlay_type; /* A second choice for overlay */
    //      float *alt_overlay_values;
    //      float *marker_values;       /* Marker values (will be shown in shades of marker color) */
 
    //      float *vertex_colors;       /* Vertex color array */
    //      mshColorScaleDef* color_scale; /* Color scale used to define these colors */
    //      int   nvertex_colors;       /* How many components? */
    //      float even_vertex_color[4]; /* This is going to be employed in case of uniform coloring */
 
    //      float *marker_colors;       /* Vertex color array (for the markers) */
    //      int   nmarker_colors;       /* How many components? */
    //      int   **marker_tri;         /* Triangles containing markers */
    //      int   *marker_tri_no;       /* Numbers of the marker triangles */
    //      int   nmarker_tri;      /* How many */
    //      float marker_color[4];  /* Marker color */
    //      int   curvature_color_mode; /* How to show curvature */
 
    //      int   overlay_color_mode;   /* How to show overlay data */
    //      int   transparent;      /* Is this surface going to be transparent? */
 
    //      int   show_aux_data;        /* Show auxilliary data related to this surface */
 
    //      mshPicked* picked;      /* Picked locations in world coordinates */
    //      int       npicked;      /* How many */
 
    //      void              *user_data;       /* Can be used to store whatever */
    //      mneUserFreeFunc*   user_data_free;   /* Function to free the above */
    //    } *mshDisplaySurface,mshDisplaySurfaceRec;
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
} // NAMESPACE MNELIB
 
#endif // MNEMSHDISPLAYSURFACE_H