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
//=============================================================================================================
 
namespace DISP3DLIB
{

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 = DISP3DLIB::VisualizationMode;
    static constexpr VisualizationMode ModeSurface = DISP3DLIB::ModeSurface;
    static constexpr VisualizationMode ModeAnnotation = DISP3DLIB::ModeAnnotation;
    static constexpr VisualizationMode ModeScientific = DISP3DLIB::ModeScientific;
    static constexpr VisualizationMode ModeSourceEstimate = DISP3DLIB::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 setColor(const QColor& color);
 
    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;
};
 
} // namespace DISP3DLIB
 
#endif // BRAINSURFACE_H