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 <optional>
#include <vector>
#include <fs/fs_surface.h>
#include <fs/fs_annotation.h>
#include <mne/mne_bem.h>
 
#include <Eigen/Core>
 
//=============================================================================================================
// STRUCTS
//=============================================================================================================
 
namespace DISP3DLIB
{

struct VertexData
{
    QVector3D pos;
    QVector3D norm;
};
 
//=============================================================================================================
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 labelElements(int verticesPerElement);
 
    //=========================================================================================================
    void setVisualizationMode(VisualizationMode mode);
 
    //=========================================================================================================
    void applySourceEstimateColors(const QVector<uint32_t>& colors);

    void clearSourceEstimateColors();
 
    //=========================================================================================================
    GpuStream geometryStream() const;

    GpuStream colorStream() const;

    GpuStream annotationStream() const;

    GpuStream indexStream() const;

    const RenderKey& renderKey() const
    {
        return m_renderKey;
    }
 
    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>& colorsRef() const
    {
        return m_colors;
    }

    const QVector<uint32_t>& annotationColorsRef() const
    {
        return m_annotationColors;
    }
 
    //=========================================================================================================
    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);

    std::optional<uint32_t> selectedLabel() const;
 
private:
    void updateVertexColors();
    void setGeometry(QVector<VertexData> vertices, QVector<uint32_t> indices, const QColor& color);
    void markGeometryDirty();
 
    QVector<VertexData> m_vertexData;
    QVector<VertexData> m_originalVertexData;
    QVector<uint32_t> m_colors;
    QVector<uint32_t> m_annotationColors;
    QVector<int> m_vertexLabelIds;
    QVector<uint32_t> m_indexData;
    uint32_t m_indexCount = 0;
 
    RenderKey m_renderKey;
    quint64 m_geometryGeneration = 0;
    quint64 m_colorGeneration = 0;
    quint64 m_annotationGeneration = 0;
    quint64 m_indexGeneration = 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;
 
    mutable QVector3D m_aabbMin;
    mutable QVector3D m_aabbMax;
    mutable bool m_bAABBDirty = true;
 
    // Bounding volume hierarchy over the triangles, built on the first pick after a geometry change
    struct Bvh;
    const Bvh& bvh() const;
    mutable std::shared_ptr<const Bvh> m_bvh;
};
 
} // namespace DISP3DLIB
 
#endif // BRAINSURFACE_H