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 QTimer;
namespace CONNECTIVITYLIB
{
class Network;
}
 
namespace DISP3DLIB
{
 
class BrainTreeModel;
class BrainRenderer;
class BrainSurface;
class DipoleObject;
class NetworkObject;
class PolylineObject;
class VideoOverlay;
class SliceObject;
 
//=============================================================================================================
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 setAutomatedRotation(bool enabled);
 
    //=========================================================================================================
    bool automatedRotation() const;
 
    //=========================================================================================================
    void setHeadMovementPath(const QVector<Eigen::Vector3f>& vecPositions);
 
    //=========================================================================================================
    void clearHeadMovementPath();
 
    //=========================================================================================================
    bool saveSnapshot();
 
    //=========================================================================================================
    bool takeScreenshot(const QString& fileName);
 
    //=========================================================================================================
    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& matData);
 
    //=========================================================================================================
    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& vecData);
 
    //=========================================================================================================
    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();
    QMatrix4x4 itemTransform(const QStandardItem* item) const;
    void removeSurfacesByPrefix(const QStringList& prefixes);
 
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;               
    QPoint m_lastMousePos;                        
    QTimer* m_pAutoRotateTimer = nullptr;         
 
    // ── 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;          
    bool m_infoPanelVisible = true;          
 
    // ── Scene objects ──────────────────────────────────────────────────
    std::unique_ptr<DipoleObject> m_dipoles;                 
    std::unique_ptr<NetworkObject> m_network;                
    std::unique_ptr<PolylineObject> m_headPath;              
    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;      
    bool m_draggedSincePress = false;                 
};
 
} // namespace DISP3DLIB
 
#endif // BRAINVIEW_H