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 <QImage>
#include <QMouseEvent>
#include <QPaintEvent>
#include <QPointer>
#include <QPropertyAnimation>
#include <QRhiWidget>
#include <QResizeEvent>
#include <QWheelEvent>
 
#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 scrollBy(float deltaSamples, 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;
    }
 
    // ── Export ────────────────────────────────────────────────────────
 
    //=========================================================================================================
    QImage renderToImage(const QSize& size = QSize()) const;
 
    // ── 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;
 
    //=========================================================================================================
    void renderFrame(QRhi* rhi, QRhiRenderTarget* target, QRhiCommandBuffer* cb);
 
    // 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:
    float clampScrollSample(float sample) const;
    void stopScrollAnimations();
 
    // ── GPU resource management ────────────────────────────────────────
    struct ChannelGpuData
    {
        std::unique_ptr<QRhiBuffer> vbo;
        int vertexCount = 0;
        int vboFirstSample = 0; // absolute first sample in VBO
    };
 
    void ensurePipeline(QRhi* rhi, QRhiRenderTarget* target);
    void rebuildVBOs(QRhi* rhi, QRhiResourceUpdateBatch* batch);
    void updateUBO(QRhiResourceUpdateBatch* batch);
    bool isVboDirty() const;
 
    // ── Overlay blit (annotations/events baked into texture, bands in shader) ──
    void ensureOverlayPipeline(QRhi* rhi, QRhiRenderTarget* target);
    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
 
 
    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;
    QPointer<QPropertyAnimation> m_pScrollAnim;
    float m_scrollTarget = 0.f;
 
    // ── 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