WaveformArea.h

Go to the documentation of this file.

/***********************************************************************************************************************
*                                                                                                                      *
* ngscopeclient                                                                                                        *
*                                                                                                                      *
* Copyright (c) 2012-2026 Andrew D. Zonenberg and contributors                                                         *
* All rights reserved.                                                                                                 *
*                                                                                                                      *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the     *
* following conditions are met:                                                                                        *
*                                                                                                                      *
*    * Redistributions of source code must retain the above copyright notice, this list of conditions, and the         *
*      following disclaimer.                                                                                           *
*                                                                                                                      *
*    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the       *
*      following disclaimer in the documentation and/or other materials provided with the distribution.                *
*                                                                                                                      *
*    * Neither the name of the author nor the names of any contributors may be used to endorse or promote products     *
*      derived from this software without specific prior written permission.                                           *
*                                                                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL *
* THE AUTHORS BE HELD LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES        *
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR       *
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE       *
* POSSIBILITY OF SUCH DAMAGE.                                                                                          *
*                                                                                                                      *
***********************************************************************************************************************/
 
#ifndef WaveformArea_h
#define WaveformArea_h
 
class WaveformArea;
class WaveformGroup;
class MainWindow;
 
#include "TextureManager.h"
#include "Marker.h"
 
class WaveformToneMapArgs
{
public:
    WaveformToneMapArgs(ImVec4 channelColor, uint32_t w, uint32_t h)
    : m_red(channelColor.x)
    , m_green(channelColor.y)
    , m_blue(channelColor.z)
    , m_width(w)
    , m_height(h)
    {}
 
    float m_red;
    float m_green;
    float m_blue;
    uint32_t m_width;
    uint32_t m_height;
};
 
class EyeToneMapArgs
{
public:
    EyeToneMapArgs(uint32_t w, uint32_t h)
    : m_width(w)
    , m_height(h)
    {}
 
    uint32_t m_width;
    uint32_t m_height;
};
 
class ConstellationToneMapArgs
{
public:
    ConstellationToneMapArgs(uint32_t w, uint32_t h)
    : m_width(w)
    , m_height(h)
    {}
 
    uint32_t m_width;
    uint32_t m_height;
};
 
class WaterfallToneMapArgs
{
public:
    WaterfallToneMapArgs(
        uint32_t w, uint32_t h, uint32_t outwidth, uint32_t outheight, uint32_t o, uint32_t p, float x)
    : m_width(w)
    , m_height(h)
    , m_outwidth(outwidth)
    , m_outheight(outheight)
    , m_offsetSamples(o)
    , m_writeRow(p)
    , m_xscale(x)
    {}
 
    uint32_t m_width;
    uint32_t m_height;
    uint32_t m_outwidth;
    uint32_t m_outheight;
    uint32_t m_offsetSamples;
    uint32_t m_writeRow;
    float m_xscale;
};
 
class SpectrogramToneMapArgs
{
public:
    SpectrogramToneMapArgs(uint32_t w, uint32_t h, uint32_t outwidth, uint32_t outheight, uint32_t xo,
        float x, int32_t yo, float y)
    : m_width(w)
    , m_height(h)
    , m_outwidth(outwidth)
    , m_outheight(outheight)
    , m_xoff(xo)
    , m_xscale(x)
    , m_yoff(yo)
    , m_yscale(y)
    {}
 
    uint32_t m_width;
    uint32_t m_height;
    uint32_t m_outwidth;
    uint32_t m_outheight;
    uint32_t m_xoff;
    float m_xscale;
    int32_t m_yoff;
    float m_yscale;
};
 
struct ConfigPushConstants
{
    int64_t innerXoff;
    uint32_t windowHeight;
    uint32_t windowWidth;
    uint32_t memDepth;
    uint32_t offset_samples;
    float alpha;
    float xoff;
    float xscale;
    float ybase;
    float yscale;
    float yoff;
    float persistScale;
};
 
class IndexSearchConstants
{
public:
    int64_t offset_samples;
    float xscale;
    uint32_t len;
    uint32_t w;
};
 
struct PeakLabel
{
    int64_t m_labelXpos;
 
    float m_labelYpos;
 
    int64_t m_peakXpos;
 
    float m_peakYpos;
 
    int64_t m_labelXsize;
 
    int64_t m_labelYsize;
 
    int m_peakAlpha;
 
    float m_fwhm;
};
 
class DisplayedChannel : public MeasurementDescriptor
{
public:
    DisplayedChannel(StreamDescriptor stream, Session& session);
    virtual ~DisplayedChannel();
 
    YAML::Node Serialize(IDTable& table) const;
 
    std::string GetName()
    { return m_sourceStream.GetName(); }
 
    StreamDescriptor GetStream()
    { return m_sourceStream; }
 
    std::shared_ptr<Texture> GetTexture()
    { return m_texture; }
 
    void SetTexture(std::shared_ptr<Texture> tex)
    { m_texture = tex; }
 
    void PrepareToRasterize(size_t x, size_t y);
 
    bool UpdateSize(ImVec2 newSize, MainWindow* top);
 
    AcceleratorBuffer<float>& GetRasterizedWaveform()
    { return m_rasterizedWaveform; }
 
    size_t GetRasterizedX()
    { return m_rasterizedX; }
 
    size_t GetRasterizedY()
    { return m_rasterizedY; }
 
    __attribute__((noinline))
    std::shared_ptr<ComputePipeline> GetUniformAnalogPipeline()
    {
        if(m_uniformAnalogComputePipeline == nullptr)
        {
            std::string base = "shaders/waveform-compute.";
            std::string suffix;
            if(ZeroHoldFlagSet())
                suffix += ".zerohold";
            if(g_hasShaderInt64)
                suffix += ".int64";
            m_uniformAnalogComputePipeline = std::make_shared<ComputePipeline>(
                base + "analog" + suffix + ".dense.spv", 2, sizeof(ConfigPushConstants));
        }
 
        return m_uniformAnalogComputePipeline;
    }
 
    __attribute__((noinline))
    std::shared_ptr<ComputePipeline> GetHistogramPipeline()
    {
        if(m_histogramComputePipeline == nullptr)
        {
            std::string base = "shaders/waveform-compute.";
            std::string suffix;
            if(g_hasShaderInt64)
                suffix += ".int64";
            m_histogramComputePipeline = std::make_shared<ComputePipeline>(
                base + "histogram" + suffix + ".dense.spv", 2, sizeof(ConfigPushConstants));
        }
 
        return m_histogramComputePipeline;
    }
 
    __attribute__((noinline))
    std::shared_ptr<ComputePipeline> GetSparseAnalogPipeline()
    {
        if(m_sparseAnalogComputePipeline == nullptr)
        {
            std::string base = "shaders/waveform-compute.";
            std::string suffix;
            int durationSSBOs = 0;
            if(ZeroHoldFlagSet())
            {
                suffix += ".zerohold";
                durationSSBOs++;
            }
            if(g_hasShaderInt64)
                suffix += ".int64";
            m_sparseAnalogComputePipeline = std::make_shared<ComputePipeline>(
                base + "analog" + suffix + ".spv", durationSSBOs + 4, sizeof(ConfigPushConstants));
        }
 
        return m_sparseAnalogComputePipeline;
    }
 
    __attribute__((noinline))
    std::shared_ptr<ComputePipeline> GetUniformDigitalPipeline()
    {
        if(m_uniformDigitalComputePipeline == nullptr)
        {
            std::string base = "shaders/waveform-compute.";
            std::string suffix;
            if(g_hasShaderInt64)
                suffix += ".int64";
            m_uniformDigitalComputePipeline = std::make_shared<ComputePipeline>(
                base + "digital" + suffix + ".dense.spv", 2, sizeof(ConfigPushConstants));
        }
 
        return m_uniformDigitalComputePipeline;
    }
 
    __attribute__((noinline))
    std::shared_ptr<ComputePipeline> GetSparseDigitalPipeline()
    {
        if(m_sparseDigitalComputePipeline == nullptr)
        {
            std::string base = "shaders/waveform-compute.";
            std::string suffix;
            int durationSSBOs = 0;  //TODO: support gaps
            if(g_hasShaderInt64)
                suffix += ".int64";
            m_sparseDigitalComputePipeline = std::make_shared<ComputePipeline>(
                base + "digital" + suffix + ".spv", durationSSBOs + 4, sizeof(ConfigPushConstants));
        }
 
        return m_sparseDigitalComputePipeline;
    }
 
    std::shared_ptr<ComputePipeline> GetToneMapPipeline()
    { return m_toneMapPipe; }
 
    std::shared_ptr<ComputePipeline> GetIndexSearchPipeline()
    { return m_indexSearchComputePipeline; }
 
    bool ZeroHoldFlagSet()
    {
        return m_sourceStream.GetFlags() & Stream::STREAM_DO_NOT_INTERPOLATE;
        // TODO: Allow this to be overridden by a configuration option in the WaveformArea
    }
 
    bool IsDensePacked()
    {
        auto data = m_sourceStream.GetData();
        if(dynamic_cast<UniformWaveformBase*>(data) != nullptr)
            return true;
        else
            return false;
    }
 
    bool ShouldFillUnder()
    { return m_sourceStream.GetFlags() & Stream::STREAM_FILL_UNDER; }
 
    bool ZeroHoldCursorBehaviour()
    {
        return ZeroHoldFlagSet();
    }
 
    bool ShouldMapDurations()
    {
        return ZeroHoldFlagSet() && !IsDensePacked();
        // Do not need durations if dense because each duration is "1"
    }
 
    bool IsPersistenceEnabled()
    { return m_persistenceEnabled; }
 
    void SetPersistenceEnabled(bool b)
    { m_persistenceEnabled = b; }
 
    AcceleratorBuffer<uint32_t>& GetIndexBuffer()
    { return m_indexBuffer; }
 
    void SetYButtonPos(float y)
    { m_yButtonPos = y; }
 
    float GetYButtonPos()
    { return m_yButtonPos; }
 
    std::vector<PeakLabel> m_peakLabels;
 
    std::string m_colorRamp;
 
protected:
 
    Session& m_session;
 
    AcceleratorBuffer<float> m_rasterizedWaveform;
 
    AcceleratorBuffer<uint32_t> m_indexBuffer;
 
    size_t m_rasterizedX;
 
    size_t m_rasterizedY;
 
    std::shared_ptr<Texture> m_texture;
 
    size_t m_cachedX;
 
    size_t m_cachedY;
 
    bool m_persistenceEnabled;
 
    std::shared_ptr<ComputePipeline> m_toneMapPipe;
 
    std::shared_ptr<ComputePipeline> m_uniformAnalogComputePipeline;
 
    std::shared_ptr<ComputePipeline> m_histogramComputePipeline;
 
    std::shared_ptr<ComputePipeline> m_sparseAnalogComputePipeline;
 
    std::shared_ptr<ComputePipeline> m_uniformDigitalComputePipeline;
 
    std::shared_ptr<ComputePipeline> m_sparseDigitalComputePipeline;
 
    std::shared_ptr<ComputePipeline> m_indexSearchComputePipeline;
 
    float m_yButtonPos;
 
    std::unique_ptr<vk::raii::CommandPool> m_utilCmdPool;
    std::unique_ptr<vk::raii::CommandBuffer> m_utilCmdBuffer;
};
 
class WaveformArea : public SinkNode
{
public:
    WaveformArea(StreamDescriptor stream, std::shared_ptr<WaveformGroup> group, MainWindow* parent);
    virtual ~WaveformArea();
 
    bool Render(int iArea, int numAreas, ImVec2 clientArea);
    void RenderWaveformTextures(
        vk::raii::CommandBuffer& cmdbuf,
        std::vector<std::shared_ptr<InputDescriptor> >& channels,
        bool clearPersistence);
    void ReferenceWaveformTextures();
    void ToneMapAllWaveforms(vk::raii::CommandBuffer& cmdbuf, std::vector<vk::ImageMemoryBarrier>& barriers);
 
    size_t GetStreamCount()
    { return m_inputs.size(); }
 
    StreamDescriptor GetStream(size_t i)
    {
        auto s = GetDisplayedChannel(i);
        if(s)
            return s->GetStream();
        else
            return nullptr; //should never happen
    }
 
    std::shared_ptr<DisplayedChannel> GetDisplayedChannel(size_t i)
    { return std::dynamic_pointer_cast<DisplayedChannel>(m_inputs[i]); }
 
    bool IsStreamBeingDisplayed(StreamDescriptor target);
 
    void AddStream(StreamDescriptor desc, bool persistence = false, const std::string& ramp = "eye-gradient-viridis");
    void AddStream(StreamDescriptor desc, size_t position, bool persistence = false, const std::string& ramp = "eye-gradient-viridis");
 
    bool IsCompatible(StreamDescriptor desc);
 
    bool IsShowing(StreamDescriptor desc);
 
    virtual void RemoveStream(size_t i) override;
 
    void ClearPersistence();
    void ClearPersistenceOfChannel(OscilloscopeChannel* chan);
 
    bool IsChannelBeingDragged();
    StreamDescriptor GetChannelBeingDragged();
 
    void AutofitVertical();
 
    std::shared_ptr<WaveformGroup> GetGroup()
    { return m_group; }
 
    TimePoint GetWaveformTimestamp();
 
    void SerializeConfiguration(YAML::Node& node);
    virtual YAML::Node SerializeConfiguration(IDTable& table) override;
    void LoadConfiguration(YAML::Node& node);
 
    bool IsMouseOverYCursor(int iCursor, bool ignoreCursorsPlacedThisFrame);
 
    bool IsMouseOverAnyYCursor(bool ignoreCursorsPlacedThisFrame)
    {
        return IsMouseOverYCursor(0, ignoreCursorsPlacedThisFrame) ||
            IsMouseOverYCursor(1, ignoreCursorsPlacedThisFrame);
    }
 
protected:
    void OnStreamAdded(StreamDescriptor desc);
 
    virtual void CreateInput(const std::string& name) override;
    virtual std::shared_ptr<DisplayedChannel> CreateInput(StreamDescriptor stream, Session& session);
 
    void ChannelButton(std::shared_ptr<DisplayedChannel> chan, size_t index);
    void RenderBackgroundGradient(ImVec2 start, ImVec2 size);
    void RenderGrid(ImVec2 start, ImVec2 size, std::map<float, float>& gridmap, float& vbot, float& vtop);
    void RenderYAxis(ImVec2 size, std::map<float, float>& gridmap, float vbot, float vtop);
    void RenderTriggerLevelArrows(ImVec2 start, ImVec2 size);
    void RenderBERLevelArrows(ImVec2 start, ImVec2 size);
    void RenderCursors(ImVec2 start, ImVec2 size);
    void RenderYAxisCursors(ImVec2 pos, ImVec2 size, float yAxisWidth);
    void RenderBERSamplingPoint(ImVec2 start, ImVec2 size);
    void CheckForScaleMismatch(ImVec2 start, ImVec2 size);
    void RenderEyePatternTooltip(ImVec2 start, ImVec2 size);
    void RenderWaveforms(ImVec2 start, ImVec2 size);
    void RenderAnalogWaveform(std::shared_ptr<DisplayedChannel> channel, ImVec2 start, ImVec2 size);
    void RenderEyeWaveform(std::shared_ptr<DisplayedChannel> channel, ImVec2 start, ImVec2 size);
    void RenderConstellationWaveform(std::shared_ptr<DisplayedChannel> channel, ImVec2 start, ImVec2 size);
    void RenderWaterfallWaveform(std::shared_ptr<DisplayedChannel> channel, ImVec2 start, ImVec2 size);
    void RenderSpectrogramWaveform(std::shared_ptr<DisplayedChannel> channel, ImVec2 start, ImVec2 size);
    void RenderSpectrumPeaks(ImDrawList* list, std::shared_ptr<DisplayedChannel> channel);
    void RenderDigitalWaveform(std::shared_ptr<DisplayedChannel> channel, ImVec2 start, ImVec2 size);
    void RenderProtocolWaveform(std::shared_ptr<DisplayedChannel> channel, ImVec2 start, ImVec2 size);
    void RenderDigitalBusWaveform(std::shared_ptr<DisplayedChannel> channel, ImVec2 start, ImVec2 size);
 
    template<class T>
    void RenderUniformDigitalBusWaveform(std::shared_ptr<DisplayedChannel> channel, T* data, ImVec2 start, ImVec2 size);
 
    void RenderComplexSignal(
        ImDrawList* list,
        int visleft, int visright,
        float xstart, float xend, float xoff,
        float ybot, float ymid, float ytop,
        std::string str,
        ImU32 color);
    void MakePathSignalBody(ImDrawList* list, float xstart, float xend, float ybot, float ymid, float ytop);
    void ToneMapAnalogOrDigitalWaveform(
        std::shared_ptr<DisplayedChannel> channel,
        vk::raii::CommandBuffer& cmdbuf,
        std::vector<vk::ImageMemoryBarrier>& barriers);
    void ToneMapEyeWaveform(
        std::shared_ptr<DisplayedChannel> channel,
        vk::raii::CommandBuffer& cmdbuf,
        std::vector<vk::ImageMemoryBarrier>& barriers);
    void ToneMapConstellationWaveform(
        std::shared_ptr<DisplayedChannel> channel,
        vk::raii::CommandBuffer& cmdbuf,
        std::vector<vk::ImageMemoryBarrier>& barriers);
    void ToneMapWaterfallWaveform(
        std::shared_ptr<DisplayedChannel> channel,
        vk::raii::CommandBuffer& cmdbuf,
        std::vector<vk::ImageMemoryBarrier>& barriers);
    void ToneMapSpectrogramWaveform(
        std::shared_ptr<DisplayedChannel> channel,
        vk::raii::CommandBuffer& cmdbuf,
        std::vector<vk::ImageMemoryBarrier>& barriers);
    void RasterizeAnalogOrDigitalWaveform(
        std::shared_ptr<DisplayedChannel> channel,
        vk::raii::CommandBuffer& cmdbuf,
        bool clearPersistence);
    void PlotContextMenu();
 
    void DrawDropRangeMismatchMessage(
        ImDrawList* list,
        ImVec2 center,
        StreamDescriptor ourStream,
        StreamDescriptor theirStream);
 
    void DrawDropScalarMessage(ImDrawList* list, ImVec2 center);
 
    void DragDropOverlays(ImVec2 start, ImVec2 size, int iArea, int numAreas);
    bool CenterRightDropArea(ImVec2 start, ImVec2 size, ImGuiDir direction);
    bool EdgeDropArea(const std::string& name, ImVec2 start, ImVec2 size, ImGuiDir splitDir);
    void CenterDropArea(ImVec2 start, ImVec2 size);
 
    void FilterMenu(std::shared_ptr<DisplayedChannel> chan);
    void FilterSubmenu(std::shared_ptr<DisplayedChannel> chan, const std::string& name, Filter::Category cat);
 
    float PixelsToYAxisUnits(float pix);
    float YAxisUnitsToPixels(float volt);
    float YAxisUnitsToYPosition(float volt);
    float YPositionToYAxisUnits(float y);
    float PickStepSize(float volts_per_half_span, int min_steps = 2, int max_steps = 5);
 
public:
    StreamDescriptor GetFirstAnalogStream();
    StreamDescriptor GetFirstEyeStream();
    StreamDescriptor GetFirstConstellationStream();
    StreamDescriptor GetFirstDensityFunctionStream();
    StreamDescriptor GetFirstAnalogOrDensityStream();
 
    Unit GetYAxisUnit()
    { return m_yAxisUnit; }
 
    bool IsMouseOverButtonAtEndOfRender()
    { return m_mouseOverButton; }
 
protected:
    float m_width;
 
    float m_height;
 
    float m_yAxisOffset;
 
    float m_ymid;
 
    float m_pixelsPerYAxisUnit;
 
    Unit m_yAxisUnit;
 
    enum DragState
    {
        DRAG_STATE_NONE,
        DRAG_STATE_CHANNEL,
        DRAG_STATE_CHANNEL_LAST,
        DRAG_STATE_Y_AXIS,
        DRAG_STATE_TRIGGER_LEVEL,
        DRAG_STATE_TRIGGER_SECONDARY_LEVEL,
        DRAG_STATE_BER_LEVEL,
        DRAG_STATE_BER_BOTH,
        DRAG_STATE_PEAK_MARKER,
        DRAG_STATE_Y_CURSOR0,
        DRAG_STATE_Y_CURSOR1
    } m_dragState;
 
    StreamDescriptor m_dragStream;
 
    void OnMouseWheelPlotArea(float delta, float delta_h);
    void OnMouseWheelYAxis(float delta);
    void OnMouseUp();
    void OnDragUpdate();
 
    std::shared_ptr<WaveformGroup> m_group;
 
    MainWindow* m_parent;
 
    double m_tLastMouseMove;
 
    bool m_mouseOverTriggerArrow;
 
    bool m_mouseOverBERTarget;
 
    float m_triggerLevelDuringDrag;
 
    int64_t m_xAxisPosDuringDrag;
 
    Trigger* m_triggerDuringDrag;
 
    BERTInputChannel* m_bertChannelDuringDrag;
 
    std::vector<std::shared_ptr<InputDescriptor> > m_channelsToRemove;
 
    int64_t m_lastRightClickOffset;
 
    std::atomic<bool> m_clearPersistence;
 
    float m_channelButtonHeight;
 
    PeakLabel* m_dragPeakLabel;
 
    ImVec2 m_dragPeakAnchorOffset;
 
    ImVec2 ClosestPointOnLineSegment(ImVec2 lineA, ImVec2 lineB, ImVec2 pt);
 
    bool m_mouseOverButton;
 
    enum YAxisCursorMode
    {
        Y_CURSOR_NONE,
        Y_CURSOR_SINGLE,
        Y_CURSOR_DUAL
    };
 
    YAxisCursorMode m_yAxisCursorMode;
 
    float m_yAxisCursorPositions[2];
 
    void DoCursor(int iCursor, DragState state);
 
    bool m_cursorPlacedThisFrame;
};
 
typedef std::pair<WaveformArea*, size_t> DragDescriptor;
 
#endif