channelrhiview.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef CHANNELRHIVIEW_H
#define CHANNELRHIVIEW_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../../disp_global.h"
#include "channeldatamodel.h"
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QColor>
#include <QElapsedTimer>
#include <QFutureWatcher>
#include <QImage>
#include <QMouseEvent>
#include <QPaintEvent>
#include <QPointer>
#include <QPropertyAnimation>
#include <QRhiWidget>
#include <QResizeEvent>
#include <QWheelEvent>
#include <QtConcurrent>
 
#include <memory>
#include <vector>
 
//=============================================================================================================
// DEFINE NAMESPACE DISPLIB
//=============================================================================================================
 
class QRhi;
class QRhiBuffer;
class QRhiCommandBuffer;
class QRhiGraphicsPipeline;
class QRhiResourceUpdateBatch;
class QRhiSampler;
class QRhiShaderResourceBindings;
class QRhiTexture;
 
class CrosshairOverlay;  // defined in .cpp
 
namespace DISPLIB
{
 
//=============================================================================================================
class DISPSHARED_EXPORT ChannelRhiView : public QRhiWidget
{
    Q_OBJECT
 
    Q_PROPERTY(float scrollSample    READ scrollSample    WRITE setScrollSample    NOTIFY scrollSampleChanged)
    Q_PROPERTY(float samplesPerPixel READ samplesPerPixel WRITE setSamplesPerPixel NOTIFY samplesPerPixelChanged)
 
public:
    //=========================================================================================================
    struct EventMarker {
        int     sample = 0;   
        int     type   = 1;   
        QColor  color;        
        QString label;        
    };
 
    //=========================================================================================================
    struct AnnotationSpan {
        int     startSample = 0; 
        int     endSample   = 0; 
        QColor  color;           
        QString label;           
    };
 
    explicit ChannelRhiView(QWidget *parent = nullptr);
    ~ChannelRhiView() override;
 
    //=========================================================================================================
    void setModel(ChannelDataModel *model);
 
    //=========================================================================================================
    void setEvents(const QVector<EventMarker> &events);
 
    void setEpochMarkers(const QVector<int> &triggerSamples);
    void setEpochMarkersVisible(bool visible);
    bool epochMarkersVisible() const { return m_bShowEpochMarkers; }
 
    void setClippingVisible(bool visible);
    bool clippingVisible() const { return m_bShowClipping; }
 
    void setZScoreMode(bool enabled);
    bool zScoreMode() const { return m_bZScoreMode; }
 
    //=========================================================================================================
    void setAnnotations(const QVector<AnnotationSpan> &annotations);
 
    //=========================================================================================================
    void setAnnotationSelectionEnabled(bool enabled);
 
    void setEventsVisible(bool visible);
    bool eventsVisible() const;
 
    void setAnnotationsVisible(bool visible);
    bool annotationsVisible() const;
 
    // ── Scroll / zoom ─────────────────────────────────────────────────
 
    float scrollSample()    const { return m_scrollSample; }
    float samplesPerPixel() const { return m_samplesPerPixel; }
 
    //=========================================================================================================
    void setScrollSample(float sample);
 
    //=========================================================================================================
    void setSamplesPerPixel(float spp);
 
    //=========================================================================================================
    void scrollTo(float targetSample, int durationMs = 200);
 
    //=========================================================================================================
    void zoomTo(float targetSpp, int durationMs = 200);
 
    //=========================================================================================================
    void setBackgroundColor(const QColor &color);
    QColor backgroundColor() const { return m_bgColor; }
 
    //=========================================================================================================
    void setPrefetchFactor(float factor);
 
    //=========================================================================================================
    int visibleFirstSample() const;
 
    //=========================================================================================================
    int visibleSampleCount() const;
 
    //=========================================================================================================
    void setChannelIndices(const QVector<int> &indices);
 
    //=========================================================================================================
    int totalLogicalChannels() const;
 
    //=========================================================================================================
    void setFirstVisibleChannel(int ch);
    int  firstVisibleChannel() const { return m_firstVisibleChannel; }
 
    //=========================================================================================================
    void setVisibleChannelCount(int count);
    int  visibleChannelCount() const { return m_visibleChannelCount; }
 
    //=========================================================================================================
    void setFrozen(bool frozen);
    bool isFrozen() const { return m_frozen; }
 
    //=========================================================================================================
    void setGridVisible(bool visible);
    bool gridVisible() const { return m_gridVisible; }
 
    //=========================================================================================================
    void setSfreq(float sfreq);
 
    //=========================================================================================================
    void setFirstFileSample(int first);
 
    //=========================================================================================================
    void setLastFileSample(int last);
    int  lastFileSample() const { return m_lastFileSample; }
 
    //=========================================================================================================
    void setWheelScrollsChannels(bool channelsMode);
    bool wheelScrollsChannels() const { return m_wheelScrollsChannels; }
 
    void setScrollSpeedFactor(float factor);
    float scrollSpeedFactor() const { return m_scrollSpeedFactor; }
 
    //=========================================================================================================
    void setHideBadChannels(bool hide);
    bool hideBadChannels() const { return m_hideBadChannels; }
 
    // ── Crosshair ─────────────────────────────────────────────────────
 
    //=========================================================================================================
    void setCrosshairEnabled(bool enabled);
    bool crosshairEnabled() const { return m_crosshairEnabled; }

    void setClockTimeFormat(bool useClock) { m_useClockTime = useClock; update(); }
    bool clockTimeFormat() const { return m_useClockTime; }
 
    // ── Scalebars ─────────────────────────────────────────────────────
 
    //=========================================================================================================
    void setScalebarsVisible(bool visible);
    bool scalebarsVisible() const { return m_scalebarsVisible; }
 
    // ── Butterfly mode ────────────────────────────────────────────────
 
    //=========================================================================================================
    void setButterflyMode(bool enabled);
    bool butterflyMode() const { return m_butterflyMode; }
 
signals:
    void scrollSampleChanged(float sample);
    void samplesPerPixelChanged(float spp);
    void viewResized(int newWidth, int newHeight);
 
    //=========================================================================================================
    void channelOffsetChanged(int firstChannel);
 
    //=========================================================================================================
    void sampleClicked(int sample);
 
    //=========================================================================================================
    void sampleRangeSelected(int startSample, int endSample);
 
    //=========================================================================================================
    void annotationBoundaryMoved(int annotationIndex, bool isStartBoundary, int newSample);
 
    //=========================================================================================================
    void cursorDataChanged(float timeSec, float amplitude,
                           const QString &channelName, const QString &unitLabel);
 
protected:
    void initialize(QRhiCommandBuffer *cb) override;
    void render(QRhiCommandBuffer *cb) override;
    void releaseResources() override;
    void paintEvent(QPaintEvent *event) override;
 
    // Overlay access — called by CrosshairOverlay::paintEvent
    friend class ::CrosshairOverlay;
    void drawCrosshair(QPainter &p);
    void drawScalebars(QPainter &p);
    void drawRulerOverlay(QPainter &p);
    void drawAnnotationSelectionOverlay(QPainter &p);
    void emitCursorData();
    bool rulerActive() const { return m_rulerActive; }
    bool annotationSelecting() const { return m_annSelecting; }
 
    void resizeEvent(QResizeEvent *event) override;
    void wheelEvent(QWheelEvent *event) override;
    void mousePressEvent(QMouseEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;
    void mouseDoubleClickEvent(QMouseEvent *event) override;
 
private:
    // ── GPU resource management ────────────────────────────────────────
    struct ChannelGpuData {
        std::unique_ptr<QRhiBuffer> vbo;
        int                         vertexCount  = 0;
        int                         vboFirstSample = 0; // absolute first sample in VBO
    };
 
    void ensurePipeline();
    void rebuildVBOs(QRhiResourceUpdateBatch *batch);
    void updateUBO(QRhiResourceUpdateBatch *batch);
    bool isVboDirty() const;
 
    // ── Overlay blit (annotations/events baked into texture, bands in shader) ──
    void ensureOverlayPipeline();
    void rebuildOverlayImage(int logicalWidth, int logicalHeight, qreal devicePixelRatio);
 
    std::unique_ptr<QRhiBuffer>                  m_overlayVbo;     // Static quad
    std::unique_ptr<QRhiTexture>                 m_overlayTex;
    std::unique_ptr<QRhiSampler>                 m_overlaySampler;
    std::unique_ptr<QRhiShaderResourceBindings>  m_overlaySrb;
    std::unique_ptr<QRhiGraphicsPipeline>        m_overlayPipeline;
    std::unique_ptr<QRhiBuffer>                  m_overlayUbo;     // OverlayParams UBO
    bool                                         m_overlayVboNeedsUpload = false;
    QImage                                       m_overlayImage;
    bool                                         m_overlayDirty = true;
    QSize                                        m_overlayTexSize;
 
    // Overlay prefetch: the texture covers a wider sample range than the viewport.
    // During scroll, the shader maps screen UVs into this wider texture via uniforms.
    // Rebuild is only needed when scroll exceeds the prefetch window.
    static constexpr float kOverlayPrefetchFactor = 1.0f; // extra viewport widths each side
    float                  m_overlayFirstSample   = 0.f;  // first sample covered by overlay tex
    float                  m_overlayTotalSamples  = 0.f;  // total sample span of overlay tex
 
    // ── Legacy async tile helpers retained for staging/reuse ──────────
    struct TileResult {
        QImage image;
        float  sampleFirst     = 0.f;
        float  samplesPerPixel = 0.f;
        int    firstChannel    = 0;
        int    visibleCount    = 0;
    };
 
    void scheduleTileRebuild();
    static TileResult buildTile(ChannelDataModel *model,
                                float scrollSample,
                                float samplesPerPixel,
                                int   firstVisibleChannel,
                                int   visibleChannelCount,
                                int   viewWidth, int viewHeight,
                                QColor bgColor,
                                bool  gridVisible,
                                float sfreq,
                                int   firstFileSample,
                                bool  hideBadChannels,
                                const QVector<int> &channelIndices,
                                const QVector<EventMarker> &events,
                                const QVector<AnnotationSpan> &annotations,
                                const QVector<int> &epochMarkers,
                                bool  showClipping,
                                bool  zScoreMode);
    bool isTileFresh() const;
 
    QImage m_tileImage;
    float  m_tileSampleFirst     = 0.f;
    float  m_tileSamplesPerPixel = 0.f;
    int    m_tileFirstChannel    = -1;
    int    m_tileVisibleCount    = 0;
    bool   m_tileDirty           = true;
 
    QFutureWatcher<TileResult>  m_tileWatcher;
    bool                        m_tileRebuildPending = false;
 
    std::unique_ptr<QRhiBuffer>                  m_ubo;
    std::unique_ptr<QRhiShaderResourceBindings>  m_srb;
    std::unique_ptr<QRhiGraphicsPipeline>        m_pipeline;
    std::vector<ChannelGpuData>                  m_gpuChannels;
    int                                          m_uboStride = 256;
    bool                                         m_pipelineDirty = true;
    bool                                         m_vboDirty      = true;
 
    // ── Shared browser state ───────────────────────────────────────────
    QPointer<ChannelDataModel> m_model;
    float                      m_scrollSample     = 0.f;
    float                      m_samplesPerPixel  = 1.f;
    float                      m_prefetchFactor   = 1.0f;
    QColor                     m_bgColor          { 250, 250, 250 }; // light default
 
    bool   m_frozen               = false;
    bool   m_gridVisible          = true;
    float  m_sfreq                = 1000.f;
    int    m_firstFileSample      = 0;
    int    m_lastFileSample       = -1;   // -1 = no limit (file not yet known)
    bool   m_wheelScrollsChannels = true; // default: vertical wheel → channels
    float  m_scrollSpeedFactor    = 1.0f;  // multiplier for wheel/keyboard scroll
    bool   m_hideBadChannels      = false;
 
    // ── Vertical channel windowing ────────────────────────────────────
    int   m_firstVisibleChannel  = 0;
    int   m_visibleChannelCount  = 12;
 
    // ── Drag scroll support ────────────────────────────────────────────
    bool  m_dragging        = false;
    int   m_dragStartX      = 0;
    float m_dragStartScroll = 0.f;
 
    // ── Left-button drag (panning) + inertial scroll ──────────────────
    bool  m_leftButtonDown    = false;
    int   m_leftDownX         = 0;
    float m_leftDownScroll    = 0.f;
    bool  m_leftDragActivated = false;
 
    struct VelocitySample { int x; qint64 t; };
    QVector<VelocitySample> m_velocityHistory;
    QElapsedTimer           m_dragTimer;
    QPropertyAnimation*     m_pInertialAnim = nullptr;
 
    // ── Channel index filter ──────────────────────────────────────────
    // When non-empty, only these model channel indices are rendered/scrolled.
    QVector<int> m_filteredChannels;
 
    // ── Event / stimulus markers ──────────────────────────────────────
    QVector<EventMarker> m_events;
    QVector<int>          m_epochTriggerSamples;
    QVector<AnnotationSpan> m_annotations;
    bool m_annotationSelectionEnabled = false;
    bool m_bShowEvents      = true;
    bool m_bShowAnnotations = true;
    bool m_bShowEpochMarkers = true;
    bool m_bShowClipping     = true;
    bool m_bZScoreMode       = false;
 
    // ── Annotation boundary drag-resize ───────────────────────────────
    bool m_annDragging         = false;   
    int  m_annDragIndex        = -1;      
    bool m_annDragIsStart      = true;    
    int  m_annHoverIndex       = -1;      
    bool m_annHoverIsStart     = true;    
    static constexpr int kAnnBoundaryHitPx = 5; 
 
    // ── Annotation range selection (right-drag when annotation mode ON) ─
    bool m_annSelecting        = false;   
    int  m_annSelX0            = 0;       
    int  m_annSelX1            = 0;       
 
    int hitTestAnnotationBoundary(int px, bool &isStart) const;
 
    // Helper — use instead of firstCh+i for actual model channel index
    int actualChannelAt(int logicalIdx) const; // maps logical → model channel index
    QVector<int> effectiveChannelIndices() const;
 
    // ── Prefetch window tracking ───────────────────────────────────────
    int   m_vboWindowFirst  = 0;
    int   m_vboWindowLast   = 0;
 
    // ── Ruler / measurement overlay ───────────────────────────────────
    // Active while right-button is held.
    enum class RulerSnap { Free, Horizontal, Vertical };
    bool       m_rulerActive = false;
    RulerSnap  m_rulerSnap   = RulerSnap::Free;
    int   m_rulerX0       = 0;   // press position (screen px)
    int   m_rulerY0       = 0;
    int   m_rulerX1       = 0;   // current cursor position (may be snapped)
    int   m_rulerY1       = 0;
    int   m_rulerRawX1    = 0;   // raw cursor position (unsnapped)
    int   m_rulerRawY1    = 0;
 
    // ── Crosshair cursor ──────────────────────────────────────────────
    bool  m_crosshairEnabled = false;
    int   m_crosshairX       = -1;  // screen px, -1 = not tracking
    int   m_crosshairY       = -1;
    bool  m_useClockTime     = false;  // mirror of TimeRulerWidget time format
    CrosshairOverlay* m_overlay = nullptr;  // lightweight overlay for crosshair/scalebars
 
    // ── Scalebars ─────────────────────────────────────────────────────
    bool  m_scalebarsVisible = false;
 
    // ── Butterfly mode ────────────────────────────────────────────────
    bool  m_butterflyMode = false;
 
    struct ButterflyTypeGroup {
        QString typeLabel;         // e.g. "MEG", "EEG"
        QColor  color;             // representative type colour
        float   amplitudeMax;      // per-type amplitude scale
        QVector<int> channelIndices; // model channel indices in this group
    };
 
    QVector<ButterflyTypeGroup> butterflyTypeGroups() const;
    int butterflyLaneCount() const;
 
    void drawOverlays();   // QPainter-based overlays on top of the QRHI-rendered traces
};
 
} // namespace DISPLIB
 
#endif // CHANNELRHIVIEW_H