brainview.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef BRAINVIEW_H
#define BRAINVIEW_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../disp3D_global.h"
 
#include "../core/rendertypes.h"
#include "multiviewlayout.h"
#include "core/viewstate.h"
#include "input/cameracontroller.h"
#include "scene/sensorfieldmapper.h"
#include "scene/sourceestimatemanager.h"
#include "scene/rtsensorstreammanager.h"
 
#include <fiff/fiff_coord_trans.h>
#include <fiff/fiff_dig_point.h>
#include <QRhiWidget>
#include <QMap>
#include <QElapsedTimer>
#include <memory>
#include <QQuaternion>
#include <Eigen/Core>
#include <QRect>
#include <QImage>
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
class QLabel;
class QStandardItem;
class QFrame;
class BrainTreeModel;
class BrainRenderer;
class BrainSurface;
class DipoleObject;
class NetworkObject;
namespace DISP3DLIB { class VideoOverlay; class SliceObject; }
namespace CONNECTIVITYLIB { class Network; }
 
//=============================================================================================================
struct DISP3DSHARED_EXPORT LiveMarker {
    QVector3D position;
    QColor    color;
    float     radius = 0.003f;
    bool      transparent = false; 
};
 
//=============================================================================================================
class DISP3DSHARED_EXPORT BrainView : public QRhiWidget
{
    Q_OBJECT
 
public:
    enum ViewMode {
        SingleView,     
        MultiView       
    };
 
public:
    //=========================================================================================================
    explicit BrainView(QWidget *parent = nullptr);
 
    //=========================================================================================================
    ~BrainView();
 
    //=========================================================================================================
    void setModel(BrainTreeModel *model);
 
    //=========================================================================================================
    void setInitialCameraRotation(const QQuaternion &rotation);
 
public slots:
    void onRowsInserted(const QModelIndex &parent, int first, int last);
    void onDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles);
    //=========================================================================================================
    void setActiveSurface(const QString &type);
 
    //=========================================================================================================
    void setShaderMode(const QString &mode);
 
    //=========================================================================================================
    void setBemShaderMode(const QString &mode);

    void syncBemShadersToBrainShaders();
 
    //=========================================================================================================
    void setVisualizationMode(const QString &mode);
 
    //=========================================================================================================
    void setHemiVisible(int hemiIdx, bool visible);
 
    //=========================================================================================================
    void setBemVisible(const QString &name, bool visible);
 
    //=========================================================================================================
    void setBemHighContrast(bool enabled);
 
    //=========================================================================================================
    void setSensorVisible(const QString &type, bool visible);
 
    //=========================================================================================================
    void setSensorTransEnabled(bool enabled);
 
    //=========================================================================================================
    void setMegHelmetOverride(const QString &path);
 
    //=========================================================================================================
    bool loadMegHelmetSurface(const QString &helmetFilePath);
 
    //=========================================================================================================
    void setDipoleVisible(bool visible);
 
    //=========================================================================================================
    bool loadNetwork(const CONNECTIVITYLIB::Network &network, const QString &name = "Network");
 
    //=========================================================================================================
    void setNetworkVisible(bool visible);
 
    //=========================================================================================================
    void setNetworkThreshold(double threshold);
 
    //=========================================================================================================
    void setNetworkColormap(const QString &name);
 
    //=========================================================================================================
    void setLightingEnabled(bool enabled);
 
    //=========================================================================================================
    void saveSnapshot();
 
    //=========================================================================================================
    bool savePng(const QString &path, int width = 1200, int height = 800,
                 const QString &surfaceType = QStringLiteral("pial"));
 
    //=========================================================================================================
    void showSingleView();
 
    //=========================================================================================================
    void showMultiView();
 
    //=========================================================================================================
    void setViewCount(int count);

    int  viewCount() const { return m_viewCount; }
 
    //=========================================================================================================
    void setViewportEnabled(int index, bool enabled);

    void setViewportCameraPreset(int index, int preset);

    void resetSingleViewCameraState();

    void resetViewportCameraState(int index);

    void resetAllSubViewState();

    int viewportCameraPreset(int index) const;

    void resetMultiViewLayout();

    void setVisualizationEditTarget(int target);

    int visualizationEditTarget() const;

    QString activeSurfaceForTarget(int target) const;

    QString shaderModeForTarget(int target) const;

    QString bemShaderModeForTarget(int target) const;

    QString overlayModeForTarget(int target) const;

    bool objectVisibleForTarget(const QString &object, int target) const;

    bool megFieldMapOnHeadForTarget(int target) const;

    bool isViewportEnabled(int index) const;
 
    //=========================================================================================================
    void setInfoPanelVisible(bool visible);
 
    //=========================================================================================================
    bool isInfoPanelVisible() const { return m_infoPanelVisible; }
 
    //=========================================================================================================
    ViewMode viewMode() const { return m_viewMode; }
 
    //=========================================================================================================
    bool loadSourceEstimate(const QString &lhPath, const QString &rhPath);
 
    //=========================================================================================================
    bool loadSensors(const QString &fifPath);

    QMap<int, QVector3D> cardinalFiducialsInMri() const;

    bool bemTopVertexInMri(QVector3D& pos) const;
 
    //=========================================================================================================
    bool loadDipoles(const QString &dipPath);
 
    //=========================================================================================================
    bool loadSourceSpace(const QString &fwdPath);
 
    //=========================================================================================================
    static QStringList probeEvokedSets(const QString &evokedPath);

    bool loadSensorField(const QString &evokedPath, int aveIndex = 0);
 
    //=========================================================================================================
    void setSourceSpaceVisible(bool visible);
 
    //=========================================================================================================
    bool loadTransformation(const QString &transPath);
 
    //=========================================================================================================
    void setTimePoint(int index);
 
    //=========================================================================================================
    void castRay(const QPoint &pos);
 
    //=========================================================================================================
    void setSourceColormap(const QString &name);
 
    //=========================================================================================================
    void setSourceThresholds(float min, float mid, float max);
 
    //=========================================================================================================
    void setSensorFieldTimePoint(int index);
 
    //=========================================================================================================
    void setSensorFieldVisible(const QString &type, bool visible);
 
    //=========================================================================================================
    void setSensorFieldContourVisible(const QString &type, bool visible);
 
    //=========================================================================================================
    void setMegFieldMapOnHead(bool useHead);
 
    //=========================================================================================================
    void setSensorFieldColormap(const QString &name);
 
    //=========================================================================================================
    float stcStep() const;
 
    //=========================================================================================================
    float stcTmin() const;
 
    //=========================================================================================================
    int stcNumTimePoints() const;
 
    //=========================================================================================================
    int closestSensorFieldIndex(float timeSec) const;
 
    //=========================================================================================================
    int closestStcIndex(float timeSec) const;
 
    //=========================================================================================================
    void startRealtimeStreaming();
 
    //=========================================================================================================
    void stopRealtimeStreaming();
 
    //=========================================================================================================
    bool isRealtimeStreaming() const;
 
    //=========================================================================================================
    void pushRealtimeSourceData(const Eigen::VectorXd &data);
 
    //=========================================================================================================
    void setRealtimeInterval(int msec);
 
    //=========================================================================================================
    void setRealtimeLooping(bool enabled);
 
    //=========================================================================================================
    bool sensorFieldTimeRange(float &tmin, float &tmax) const;
 
    //=========================================================================================================
    // ── Real-time sensor data streaming ────────────────────────────────
    //=========================================================================================================

    void startRealtimeSensorStreaming(const QString &modality = QStringLiteral("MEG"));
 
    //=========================================================================================================
    void stopRealtimeSensorStreaming();
 
    //=========================================================================================================
    bool isRealtimeSensorStreaming() const;
 
    //=========================================================================================================
    void pushRealtimeSensorData(const Eigen::VectorXf &data);
 
    //=========================================================================================================
    void setRealtimeSensorInterval(int msec);
 
    //=========================================================================================================
    void setRealtimeSensorLooping(bool enabled);
 
    //=========================================================================================================
    void setRealtimeSensorAverages(int numAvr);
 
    //=========================================================================================================
    void setRealtimeSensorColormap(const QString &name);
 
    // ── Data removal ───────────────────────────────────────────────────

    void clearSurfaces();

    void clearBem();

    void clearSourceEstimate();

    void clearDipoles();

    void clearSourceSpace();

    void clearSensors();
 
    // ── Live marker overlay (lightweight, no model, no scene-bounds) ───

    void setLiveMarkers(const QVector<LiveMarker>& markers);

    void clearLiveMarkers();

    void setLiveRay(const QVector3D& from, const QVector3D& to,
                    const QColor& color, float radius = 0.001f);

    void clearLiveRay();

    void setProbeVisualization(const QVector3D& tip, const QVector3D& direction,
                               float length, const QColor& color,
                               const QColor& glowColor = QColor(0, 0, 0, 0),
                               const QQuaternion& orientation = QQuaternion(0, 0, 0, 0));

    void clearProbeVisualization();

    void setStaticMarkers(const QVector<LiveMarker>& markers);

    void clearStaticMarkers();

    void setCameraFocusOverride(const QVector3D& center, float size);

    void clearCameraFocusOverride();

    void clearEvoked();

    void clearTransformation();

    void clearNetwork();

    void stopAllStreaming();
 
    //=========================================================================================================
    // ── Video overlay ──────────────────────────────────────────────────
    //=========================================================================================================

    void setVideoOverlayEnabled(bool enabled);

    bool isVideoOverlayEnabled() const;

    void setVideoOverlayFocusPosition(const QVector3D &position);

    void setVideoOverlayUpHint(const QVector3D &dir);

    void setVideoOverlaySize(float meters);

    void setVideoOverlayOpacity(float opacity);

    void pushVideoOverlayFrame(const QImage &frame);

    void setVideoDepthEnabled(bool enabled);

    void setVideoDepthScale(float scale);

    void setVideoDepthSteps(int steps);

    void pushVideoDepthFrame(const QImage &depthFrame);

    bool intersectWorldRay(const QVector3D& origin, const QVector3D& direction, QVector3D& hitPoint) const;
 
    //=========================================================================================================
    // ── MRI slice rendering ────────────────────────────────────────────
    //=========================================================================================================

    void setSlice(int slotIndex, DISP3DLIB::SliceObject *slice);

    void setSliceVisible(int slotIndex, bool visible);

    void setMriSlicesVisible(bool visible);
 
signals:
    //=========================================================================================================
    void timePointChanged(int index, float time);
 
    //=========================================================================================================
    void sourceEstimateLoaded(int numTimePoints);
 
    //=========================================================================================================
    void sensorFieldLoaded(int numTimePoints, int initialTimePoint = 0);
 
    //=========================================================================================================
    void sourceThresholdsUpdated(float min, float mid, float max);
 
    //=========================================================================================================
    void stcLoadingProgress(int percent, const QString &message);
 
    //=========================================================================================================
    void sensorFieldTimePointChanged(int index, float time);
 
    //=========================================================================================================
    void hoveredRegionChanged(const QString &regionName);
 
    //=========================================================================================================
    void visualizationEditTargetChanged(int target);
 
    //=========================================================================================================
    void viewCountChanged(int count);
 
    //=========================================================================================================
    void shaderModeChanged(const QString &modeName);

    void surfacePointClicked(const QVector3D &worldPos);

    void surfacePointDoubleClicked(const QVector3D &worldPos);
 
private slots:
    //=========================================================================================================
    void onSourceEstimateLoaded(int numTimePoints);
 
    //=========================================================================================================
    void onRealtimeColorsAvailable(const QVector<uint32_t> &colorsLh,
                                   const QVector<uint32_t> &colorsRh);
 
    //=========================================================================================================
    void onSensorStreamColorsAvailable(const QString &surfaceKey,
                                       const QVector<uint32_t> &colors);
 
private:
    // Note: ViewVisibilityProfile and SubView are defined in core/viewstate.h.
    // SplitterHit is defined in view/multiviewlayout.h.

    SubView&       subViewForTarget(int target);
    const SubView& subViewForTarget(int target) const;
 
    ViewVisibilityProfile& visibilityProfileForTarget(int target);
    const ViewVisibilityProfile& visibilityProfileForTarget(int target) const;
 
    void refreshSensorTransforms();
    void removeSurfacesByPrefix(const QString &prefix);
 
protected:
    void initialize(QRhiCommandBuffer *cb) override;
    void render(QRhiCommandBuffer *cb) override;
 
    void mousePressEvent(QMouseEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;
    void mouseDoubleClickEvent(QMouseEvent *event) override;
    void wheelEvent(QWheelEvent *event) override;
    void keyPressEvent(QKeyEvent *event) override;
    void resizeEvent(QResizeEvent *event) override;
 
private:
    // ── Layout helpers (delegate to MultiViewLayout) ───────────────────
    QVector<int> enabledViewportIndices() const;
    int enabledViewportCount() const;
    int viewportIndexAt(const QPoint& pos) const;
    QRect multiViewSlotRect(int slot, int numEnabled, const QSize& outputSize) const;
    SplitterHit hitTestSplitter(const QPoint& pos, int numEnabled, const QSize& outputSize) const;
 
    // ── Helpers ────────────────────────────────────────────────────────
    void updateSplitterCursor(const QPoint& pos);
    void updateViewportSeparators();
    void updateOverlayLayout();
    void updateViewportLabelHighlight();
    void showViewportPresetMenu(int viewport, const QPoint &globalPos);
    void logPerspectiveRotation(const QString& context) const;
    void loadMultiViewSettings();
    void saveMultiViewSettings() const;
    void updateInflatedSurfaceTransforms();
 
    // ── Rendering ───────────────────────────────────────────────────────
    std::unique_ptr<BrainRenderer> m_renderer;      
    BrainTreeModel* m_model = nullptr;              
 
    QMap<const QStandardItem*, std::shared_ptr<BrainSurface>> m_itemSurfaceMap;  
    QMap<const QStandardItem*, std::shared_ptr<DipoleObject>> m_itemDipoleMap;   
 
    QMap<QString, std::shared_ptr<BrainSurface>> m_surfaces;  
    std::shared_ptr<BrainSurface> m_activeSurface;            
    QString m_activeSurfaceType;                              
 
    // ── SubView state ──────────────────────────────────────────────────
    static constexpr int kDefaultViewportCount = 4; 
    SubView m_singleView;                           
    QVector<SubView> m_subViews;                    
    int m_visualizationEditTarget = -1;             
 
    // ── Active (runtime) copies — kept in sync with selected SubView ──
    ShaderMode m_brainShaderMode = Standard;      
    ShaderMode m_bemShaderMode = Standard;        
    VisualizationMode m_currentVisMode = ModeSurface; 
    bool m_lightingEnabled = true;                  
 
    // ── Extracted components ───────────────────────────────────────────
    CameraController        m_camera;               
    MultiViewLayout         m_layout;               
    SensorFieldMapper       m_fieldMapper;          
    SourceEstimateManager   m_sourceManager;        
    RtSensorStreamManager   m_sensorStreamManager;  
 
    // ── Camera state ───────────────────────────────────────────────────
    QQuaternion m_cameraRotation;                   
    QVector3D m_sceneCenter = QVector3D(0, 0, 0);   
    float m_sceneSize = 0.3f;                       
    bool m_cameraFocusOverride = false;              
    QVector3D m_cameraFocusCenter;                   
    float m_cameraFocusSize = 0.3f;                  
    float m_zoom = 0.0f;                            
    QPoint m_lastMousePos;                          
 
    // ── UI overlays ────────────────────────────────────────────────────
    int m_frameCount = 0;                           
    QElapsedTimer m_fpsTimer;                       
    QLabel *m_fpsLabel = nullptr;                   
    QLabel *m_singleViewInfoLabel = nullptr;        
    bool m_sceneDirty = true;                       
    qint64 m_cachedVertexCount = 0;                 
    bool m_vertexCountDirty = true;                 
    int m_snapshotCounter = 0;                      
    bool m_infoPanelVisible = true;                 
 
    // ── Scene objects ──────────────────────────────────────────────────
    std::unique_ptr<DipoleObject> m_dipoles;        
    std::unique_ptr<NetworkObject> m_network;       
    std::unique_ptr<DISP3DLIB::VideoOverlay> m_videoOverlay; 
 
    // ── MRI slices ─────────────────────────────────────────────────────
    static constexpr int kMaxSliceSlots = 3;
    DISP3DLIB::SliceObject *m_slices[kMaxSliceSlots] = {};   
    bool m_sliceVisible[kMaxSliceSlots] = {true, true, true}; 

    void updateSceneBounds();
 
    // ── Coordinate transforms ──────────────────────────────────────────
    FIFFLIB::FiffCoordTrans m_headToMriTrans;       
    QList<FIFFLIB::FiffDigPoint> m_cardinalDigPoints; 
    bool m_applySensorTrans = true;                 
    QString m_megHelmetOverridePath;                
    QMatrix4x4 m_devHeadTrans;                      
    bool m_hasDevHead = false;                      
    bool m_dipolesVisible = true;                   
    bool m_networkVisible = false;                  
 
    // ── Ray-pick hover state ───────────────────────────────────────────
    QStandardItem* m_hoveredItem = nullptr;         
    int m_hoveredIndex = -1;                        
    QString m_hoveredRegion;                        
    QString m_hoveredSurfaceKey;                    
    QLabel* m_regionLabel = nullptr;                
    QVector<QLabel*> m_viewportNameLabels;          
    QVector<QLabel*> m_viewportInfoLabels;          
 
    // ── Debug intersection ─────────────────────────────────────────────
    std::shared_ptr<BrainSurface> m_debugPointerSurface; 
    QVector3D m_lastIntersectionPoint;              
    bool m_hasIntersection = false;                 
 
 
 
    // ── Multi-view support ─────────────────────────────────────────────
    ViewMode m_viewMode = SingleView;               
    int m_viewCount = 1;                            
    float m_multiSplitX = 0.5f;                     
    float m_multiSplitY = 0.5f;                     
    bool m_isDraggingSplitter = false;              
    SplitterHit m_activeSplitter = SplitterHit::None; 
    int m_splitterHitTolerancePx = 6;               
    int m_splitterMinPanePx = 80;                   
    int m_separatorLinePx = 2;                      
    QFrame* m_verticalSeparator = nullptr;          
    QFrame* m_horizontalSeparator = nullptr;        
    bool m_perspectiveRotatedSincePress = false;    
};
 
#endif // BRAINVIEW_H