MRImGuiMeasurementIndicators.h

Go to the documentation of this file.

#pragma once
 
#include "MRMesh/MRFlagOperators.h"
#include "MRViewer/exports.h"
#include "MRViewer/MRViewerFwd.h"
#include "MRViewer/MRImGuiVectorOperators.h"
 
#include <imgui.h>
 
#include <cassert>
#include <optional>
#include <span>
#include <variant>
 
namespace MR::ImGuiMeasurementIndicators
{
 
struct Stipple
{
    float patternLength = 16;
 
    struct Segment
    {
        float a = 0;
        float b = 0;
 
        [[nodiscard]] float get( bool end ) const { return end ? b : a; }
    };
    std::span<const Segment> segments;
};
 
struct Params
{
    ImDrawList* list = ImGui::GetBackgroundDrawList();
    Color colorMain;
    Color colorOutline;
    Color colorText;
    Color colorTextOutline;
    Color colorTextOutlineHovered;
    Color colorTextOutlineActive;
 
    float pointDiameter = 6;
 
    float width = 1.5f;
    float smallWidth = 0.75f;
    float outlineWidth = 1.5f;
    float textOutlineWidth = 4.f;
    float textOutlineRounding = 3.f;
 
    float clickableLabelLineWidth = 1.f;
    float clickableLabelLineWidthSelected = 2.f;
    float clickableLabelOutlineWidth = 1.f;
 
    float arrowLen = 12;
    float arrowHalfWidth = 4;
    float arrowTipBackwardOffset = 2.5f;
 
    ImVec2 textToLineSpacingA = ImVec2( 0, 0 ); 
    ImVec2 textToLineSpacingB = ImVec2( 0, 0 ); 
    float textToLineSpacingRadius = 8;
 
    float totalLenThreshold = 48;
 
    float invertedOverhang = 24;
 
    float leaderLineLen = 20;
 
    float notchHalfLen = 8;
 
 
    Stipple stippleDashed;
 
    MRVIEWER_API Params();
};
 
enum class Element
{
    main = 1 << 0,
    outline = 1 << 1,
    both = main | outline, 
};
MR_MAKE_FLAG_OPERATORS( Element )
 
 
MRVIEWER_API void point( Element elem, const Params& params, ImVec2 point );
 
enum class TextIcon
{
    diameter,
};
 
struct TextColor
{
    std::optional<ImU32> color;
 
    TextColor() {}
    TextColor( ImVec4 color ) : color( ImGui::ColorConvertFloat4ToU32( color ) ) {}
    TextColor( ImU32 color ) : color( color ) {}
};
 
struct TextFont
{
    ImFont* font = nullptr;
    float size = 0.f;
};
 
struct Text
{
    using ElemVar = std::variant<std::string, TextIcon, TextColor, TextFont>;
 
    struct Elem
    {
        ElemVar var;
 
        ImVec2 size = ImVec2( 0, -1 );
 
        ImVec2 align;
 
        int columnId = -1;
 
        mutable ImVec2 computedSize;
 
        mutable ImVec2 computedSizeWithPadding;
 
        [[nodiscard]] bool hasDefaultParams() const
        {
            return size == ImVec2( 0, -1 ) && align == ImVec2() && columnId == -1;
        }
    };
 
    struct Line
    {
        std::vector<Elem> elems;
 
        ImVec2 size = ImVec2( -1, 0 );
 
        ImVec2 align;
 
        mutable ImVec2 computedSize;
 
        mutable ImVec2 computedSizeWithPadding;
    };
 
    std::vector<Line> lines;
 
    ImVec2 size;
 
    ImVec2 align;
 
    using FontFunc = std::function<FontAndSize()>;
    [[nodiscard]] MRVIEWER_API static const FontFunc& getStaticDefaultFontFunc();
    MRVIEWER_API static void setStaticDefaultFontFunc( FontFunc func );
 
    FontAndSize defaultFont = getStaticDefaultFontFunc()();
 
    mutable ImVec2 computedSize;
 
 
    mutable bool dirty = false;
 
    Text() {}
    Text( const std::string& text ) { addText( text ); }
    Text( std::string_view text ) { addText( text ); }
    Text( const char* text ) { addText( text ); }
 
    [[nodiscard]] bool isEmpty() const { return lines.empty(); }
 
    void addLine()
    {
        dirty = true;
        lines.emplace_back();
        lines.back().elems.emplace_back().var = std::string(); 
    }
 
    MRVIEWER_API void addText( std::string_view text );
 
    void addElem( Elem elem )
    {
        dirty = true;
        if ( lines.empty() )
            addLine();
        lines.back().elems.emplace_back( std::move( elem ) );
    }
 
    void add( auto&& elem )
    {
        addElem( { .var = decltype(elem)(elem) } );
    }
 
    MRVIEWER_API void update( bool force = false ) const;
 
    struct DrawResult
    {
        ImVec2 cornerA;
        ImVec2 cornerB;
    };
 
    MRVIEWER_API DrawResult draw( ImDrawList& list, ImVec2 pos, const TextColor& defaultTextColor = {} ) const;
};
 
enum class LineCapDecoration
{
    none,
    noOutline, 
    extend, 
    arrow,
    point, 
};
 
enum class LineFlags
{
    narrow = 1 << 0,
    noBackwardArrowTipOffset = 1 << 1, 
    onlyOutline = 1 << 2, 
};
MR_MAKE_FLAG_OPERATORS( LineFlags )
 
struct LineBodyParams
{
    LineFlags flags{};
 
    std::optional<Color> colorOverride;
 
    std::optional<Stipple> stipple;
};
 
struct TextParams
{
    Color borderColor = Color::transparent();
 
    struct Line
    {
        ImVec2 point;
        LineCapDecoration capDecoration{};
        LineBodyParams body;
    };
    std::optional<Line> line;
 
    bool isHovered = false;
    bool isActive = false;
 
    bool isSelected = false;
};
 
struct TextResult
{
    ImVec2 textCornerA; 
    ImVec2 textCornerB;
    ImVec2 bgCornerA; 
    ImVec2 bgCornerB;
};
 
MRVIEWER_API std::optional<TextResult> text(
    Element elem, const Params& params, ImVec2 pos,
    const Text& text, const TextParams& textParams = {},
    ImVec2 push = {}, ImVec2 pivot = { 0.5f, 0.5f }
);
 
MRVIEWER_API void arrowTriangle( Element elem, const Params& params, ImVec2 point, ImVec2 dir );
 
struct LineCap
{
    LineCapDecoration decoration{};
 
    Text text;
    TextParams textParams;
};
 
struct LineParams
{
    LineBodyParams body;
    LineCap capA{};
    LineCap capB{};
 
    std::span<const ImVec2> midPoints;
};
 
struct LineResult
{
    std::optional<TextResult> capA, capB;
};
 
MRVIEWER_API std::optional<LineResult> line( Element elem, const Params& params, ImVec2 a, ImVec2 b, const LineParams& lineParams = {} );
 
struct DistanceParams
{
    std::optional<bool> moveTextToLineEndIndex;
 
    TextParams textParams;
};
 
struct DistanceResult
{
    std::optional<LineResult> line;
    std::optional<TextResult> text;
};
 
MRVIEWER_API std::optional<DistanceResult> distance( Element elem, const Params& params, ImVec2 a, ImVec2 b, const Text& text, const DistanceParams& distanceParams = {} );
 
struct CurveParams
{
    int maxSubdivisionDepth = 10;
    int minSubdivisionDepth = 1;
    float subdivisionStepPixels = 4;
};
 
struct PreparedCurve
{
    ImVec2 a; 
    ImVec2 b; 
 
    [[nodiscard]] ImVec2 endPoint( bool second ) const { return second ? b : a; }
 
    std::span<ImVec2> midPoints; 
};
 
template <typename A, typename B, typename F, typename G, typename H = std::nullptr_t>
[[nodiscard]] PreparedCurve prepareCurve( const CurveParams& curveParams, std::vector<ImVec2>& pointBuffer, const A& stateA, const B& stateB,
    F&& stateToPoint, G&& bisectState, H&& onInsertPoint = nullptr
)
{
    const float pixelStepSq = curveParams.subdivisionStepPixels * curveParams.subdivisionStepPixels;
 
    std::size_t firstIndex = pointBuffer.size();
 
    auto makeCurve = [&]( auto makeCurve, int depth, const auto& stateA, const auto& stateB, ImVec2 pointA, ImVec2 pointB ) -> void
    {
        if ( depth < curveParams.maxSubdivisionDepth && ( depth < curveParams.minSubdivisionDepth || ImGuiMath::lengthSq( pointB - pointA ) > pixelStepSq ) )
        {
 
            auto midState = bisectState( stateA, stateB, int( depth ) ); 
            ImVec2 midPoint = stateToPoint( midState );
 
            makeCurve( makeCurve, depth + 1, stateA, midState, pointA, midPoint );
            makeCurve( makeCurve, depth + 1, midState, stateB, midPoint, pointB );
        }
        else
        {
 
            onInsertPoint( pointB, stateB );
            pointBuffer.push_back( pointB );
        }
 
    };
    ImVec2 firstPoint = stateToPoint( stateA );
    makeCurve( makeCurve, 0, stateA, stateB, firstPoint, stateToPoint( stateB ) );
 
    PreparedCurve ret{ .a = firstPoint, .b = pointBuffer.back() };
    pointBuffer.pop_back();
    ret.midPoints = { pointBuffer.data() + firstIndex, pointBuffer.data() + pointBuffer.size() };
    return ret;
}
 
}