brainsurface.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef BRAINSURFACE_H
#define BRAINSURFACE_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../disp3D_global.h"
 
#include "../core/rendertypes.h"
 
#include <QVector>
#include <QVector3D>
#include <QColor>
#include <memory>
#include <vector>
#include <fs/fs_surface.h>
#include <fs/fs_annotation.h>
#include <mne/mne_bem.h>
 
#include <Eigen/Core>
 
// Forward-declare QRhi types so that this header stays QRhi-free
class QRhi;
class QRhiBuffer;
class QRhiResourceUpdateBatch;
 
//=============================================================================================================
// STRUCTS
//=============================================================================================================

struct VertexData {
    QVector3D pos;
    QVector3D norm;
    uint32_t color;           // curvature / base / STC color  (ABGR packed)
    uint32_t colorAnnotation; // annotation region color       (ABGR packed)
    float surfaceId = 0.0f;  // WORKAROUND(QRhi-GLES2): surface ID for merged
                             // single-drawIndexed on WASM.  Always 0 for
                             // individual surfaces; set by merged path.
};
 
//=============================================================================================================
class DISP3DSHARED_EXPORT BrainSurface
{
public:
    //=========================================================================================================
    BrainSurface();
 
    //=========================================================================================================
    ~BrainSurface();
 
    // VisualizationMode is defined in core/rendertypes.h for lightweight inclusion.
    // These aliases preserve backward compatibility.
    using VisualizationMode = ::VisualizationMode;
    static constexpr VisualizationMode ModeSurface        = ::ModeSurface;
    static constexpr VisualizationMode ModeAnnotation     = ::ModeAnnotation;
    static constexpr VisualizationMode ModeScientific     = ::ModeScientific;
    static constexpr VisualizationMode ModeSourceEstimate = ::ModeSourceEstimate;
 
    enum TissueType {
        TissueUnknown = 0,
        TissueBrain = 1,
        TissueSkin = 2,       // Head/Scalp surface
        TissueOuterSkull = 3, // Outer skull bone
        TissueInnerSkull = 4  // Inner skull bone
    };
 
    //=========================================================================================================
    void setVisible(bool visible);
 
    //=========================================================================================================
    bool isVisible() const { return m_visible; }
    
    //=========================================================================================================
    void setHemi(int hemi) { m_hemi = hemi; }
 
    //=========================================================================================================
    void setTissueType(TissueType type) { m_tissueType = type; }
 
    //=========================================================================================================
    TissueType tissueType() const { return m_tissueType; }
 
    //=========================================================================================================
    int hemi() const { return m_hemi; }
 
    //=========================================================================================================
    void fromSurface(const FSLIB::FsSurface &surf);
 
    //=========================================================================================================
    void fromBemSurface(const MNELIB::MNEBemSurface &surf, const QColor &color = Qt::white);
 
    //=========================================================================================================
    void createFromData(const Eigen::MatrixX3f &vertices, const Eigen::MatrixX3i &triangles, const QColor &color);
 
    //=========================================================================================================
    void createFromData(const Eigen::MatrixX3f &vertices, const Eigen::MatrixX3f &normals, const Eigen::MatrixX3i &triangles, const QColor &color);
 
    //=========================================================================================================
    bool loadAnnotation(const QString &path);
 
    //=========================================================================================================
    void addAnnotation(const FSLIB::FsAnnotation &annotation);
 
    //=========================================================================================================
    void setVisualizationMode(VisualizationMode mode);
 
    //=========================================================================================================
    void applySourceEstimateColors(const QVector<uint32_t> &colors);

    void clearSourceEstimateColors();
    
    //=========================================================================================================
    void updateBuffers(QRhi *rhi, QRhiResourceUpdateBatch *u);
 
    QRhiBuffer* vertexBuffer() const;
    QRhiBuffer* indexBuffer() const;
    uint32_t indexCount() const { return m_indexCount; }
    uint32_t vertexCount() const { return m_vertexData.size(); }
 
    //=========================================================================================================
    Eigen::MatrixX3f vertexPositions() const;
 
    //=========================================================================================================
    Eigen::MatrixX3f vertexNormals() const;
 
    //=========================================================================================================
    QVector<uint32_t> triangleIndices() const { return m_indexData; }

    const QVector<VertexData>& vertexDataRef() const { return m_vertexData; }
    const QVector<uint32_t>& indexDataRef() const { return m_indexData; }

    quint64 vertexGeneration() const { return m_vertexGeneration; }
    
    //=========================================================================================================
    float minX() const;
 
    //=========================================================================================================
    float maxX() const;
 
    //=========================================================================================================
    void boundingBox(QVector3D &min, QVector3D &max) const;
 
    //=========================================================================================================
    bool intersects(const QVector3D &rayOrigin, const QVector3D &rayDir, float &dist, int &vertexIdx) const;
 
    //=========================================================================================================
    QString getAnnotationLabel(int vertexIdx) const;
    int getAnnotationLabelId(int vertexIdx) const;
 
    //=========================================================================================================
    void setSelectedRegion(int regionId);
    void translateX(float offset);
 
    //=========================================================================================================
    void transform(const QMatrix4x4 &m);
 
    //=========================================================================================================
    void applyTransform(const QMatrix4x4 &m);
 
    //=========================================================================================================
    std::vector<Eigen::VectorXi> computeNeighbors() const;
 
    //=========================================================================================================
    Eigen::MatrixX3f verticesAsMatrix() const;
    
    //=========================================================================================================
    void setUseDefaultColor(bool useDefault);
    
    void setSelected(bool selected);
    bool isSelected() const { return m_selected; }
    int selectedRegionId() const { return m_selectedRegionId; }
    int selectedVertexStart() const { return m_selectedVertexStart; }

    void setSelectedVertexRange(int start, int count);
    
private:
    void updateVertexColors();
    void markVertexDirty();
 
    QVector<VertexData> m_vertexData;
    QVector<VertexData> m_originalVertexData;
    QVector<uint32_t> m_indexData;
    uint32_t m_indexCount = 0;
    
    QColor m_defaultColor = Qt::white;
    QColor m_baseColor = Qt::white;
    
    FSLIB::FsAnnotation m_annotation;
    bool m_hasAnnotation = false;
    VisualizationMode m_visMode = ModeSurface;
    QVector<float> m_curvature;
    QVector<uint32_t> m_stcColors;
    
    bool m_visible = true;
    bool m_selected = false;
    int m_selectedRegionId = -1;
    int m_selectedVertexStart = -1;
    int m_selectedVertexCount = 0;
    int m_hemi = -1; // 0=lh, 1=rh
    TissueType m_tissueType = TissueUnknown;

    struct GpuBuffers;
    std::unique_ptr<GpuBuffers> m_gpu;
 
    quint64 m_vertexGeneration = 0;
 
    mutable QVector3D m_aabbMin;
    mutable QVector3D m_aabbMax;
    mutable bool m_bAABBDirty = true;
};
 
#endif // BRAINSURFACE_H