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();    
    int            sketch = 0;  
 
    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;   
    int   transparent = 0;      
 
    int   show_aux_data = 0;        
 
    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,
                                     int do_all, int 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