aboutsummaryrefslogtreecommitdiff
path: root/3rdparty
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty')
-rw-r--r--3rdparty/implot/CMakeLists.txt7
-rw-r--r--3rdparty/implot/epezent-implot.LICENSE.txt21
-rw-r--r--3rdparty/implot/epezent-implot.stamp2
-rw-r--r--3rdparty/implot/implot.cpp4483
-rw-r--r--3rdparty/implot/implot.h836
-rw-r--r--3rdparty/implot/implot_demo.cpp1928
-rw-r--r--3rdparty/implot/implot_internal.h1240
-rw-r--r--3rdparty/implot/implot_items.cpp2252
8 files changed, 10769 insertions, 0 deletions
diff --git a/3rdparty/implot/CMakeLists.txt b/3rdparty/implot/CMakeLists.txt
new file mode 100644
index 0000000..6b92b02
--- /dev/null
+++ b/3rdparty/implot/CMakeLists.txt
@@ -0,0 +1,7 @@
+file(GLOB IMPLOT_SOURCES *.cpp)
+
+add_library(implot ${IMPLOT_SOURCES})
+target_include_directories(implot PRIVATE
+ ${CMAKE_SOURCE_DIR}/3rdparty/implot
+ ${CMAKE_SOURCE_DIR}/3rdparty/imgui
+)
diff --git a/3rdparty/implot/epezent-implot.LICENSE.txt b/3rdparty/implot/epezent-implot.LICENSE.txt
new file mode 100644
index 0000000..f2fc0cf
--- /dev/null
+++ b/3rdparty/implot/epezent-implot.LICENSE.txt
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Evan Pezent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. \ No newline at end of file
diff --git a/3rdparty/implot/epezent-implot.stamp b/3rdparty/implot/epezent-implot.stamp
new file mode 100644
index 0000000..7279f6c
--- /dev/null
+++ b/3rdparty/implot/epezent-implot.stamp
@@ -0,0 +1,2 @@
+# This file labels the commit which our source is from
+555ff688a8134bc0c602123149abe9c17d577475 \ No newline at end of file
diff --git a/3rdparty/implot/implot.cpp b/3rdparty/implot/implot.cpp
new file mode 100644
index 0000000..f97e08c
--- /dev/null
+++ b/3rdparty/implot/implot.cpp
@@ -0,0 +1,4483 @@
+// MIT License
+
+// Copyright (c) 2021 Evan Pezent
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// ImPlot v0.10 WIP
+
+/*
+
+API BREAKING CHANGES
+====================
+Occasionally introducing changes that are breaking the API. We try to make the breakage minor and easy to fix.
+Below is a change-log of API breaking changes only. If you are using one of the functions listed, expect to have to fix some code.
+When you are not sure about a old symbol or function name, try using the Search/Find function of your IDE to look for comments or references in all implot files.
+You can read releases logs https://github.com/epezent/implot/releases for more details.
+
+- 2021/03/08 (0.9) - SetColormap and PushColormap(ImVec4*) were removed. Use AddColormap for custom colormap support. LerpColormap was changed to SampleColormap.
+ ShowColormapScale was changed to ColormapScale and requires additional arguments.
+- 2021/03/07 (0.9) - The signature of ShowColormapScale was modified to accept a ImVec2 size.
+- 2021/02/28 (0.9) - BeginLegendDragDropSource was changed to BeginDragDropSourceItem with a number of other drag and drop improvements.
+- 2021/01/18 (0.9) - The default behavior for opening context menus was change from double right-click to single right-click. ImPlotInputMap and related functions were moved
+ to implot_internal.h due to its immaturity.
+- 2020/10/16 (0.8) - ImPlotStyleVar_InfoPadding was changed to ImPlotStyleVar_MousePosPadding
+- 2020/09/10 (0.8) - The single array versions of PlotLine, PlotScatter, PlotStems, and PlotShaded were given additional arguments for x-scale and x0.
+- 2020/09/07 (0.8) - Plotting functions which accept a custom getter function pointer have been post-fixed with a G (e.g. PlotLineG)
+- 2020/09/06 (0.7) - Several flags under ImPlotFlags and ImPlotAxisFlags were inverted (e.g. ImPlotFlags_Legend -> ImPlotFlags_NoLegend) so that the default flagset
+ is simply 0. This more closely matches ImGui's style and makes it easier to enable non-default but commonly used flags (e.g. ImPlotAxisFlags_Time).
+- 2020/08/28 (0.5) - ImPlotMarker_ can no longer be combined with bitwise OR, |. This features caused unecessary slow-down, and almost no one used it.
+- 2020/08/25 (0.5) - ImPlotAxisFlags_Scientific was removed. Logarithmic axes automatically uses scientific notation.
+- 2020/08/17 (0.5) - PlotText was changed so that text is centered horizontally and vertically about the desired point.
+- 2020/08/16 (0.5) - An ImPlotContext must be explicitly created and destroyed now with `CreateContext` and `DestroyContext`. Previously, the context was statically initialized in this source file.
+- 2020/06/13 (0.4) - The flags `ImPlotAxisFlag_Adaptive` and `ImPlotFlags_Cull` were removed. Both are now done internally by default.
+- 2020/06/03 (0.3) - The signature and behavior of PlotPieChart was changed so that data with sum less than 1 can optionally be normalized. The label format can now be specified as well.
+- 2020/06/01 (0.3) - SetPalette was changed to `SetColormap` for consistency with other plotting libraries. `RestorePalette` was removed. Use `SetColormap(ImPlotColormap_Default)`.
+- 2020/05/31 (0.3) - Plot functions taking custom ImVec2* getters were removed. Use the ImPlotPoint* getter versions instead.
+- 2020/05/29 (0.3) - The signature of ImPlotLimits::Contains was changed to take two doubles instead of ImVec2
+- 2020/05/16 (0.2) - All plotting functions were reverted to being prefixed with "Plot" to maintain a consistent VerbNoun style. `Plot` was split into `PlotLine`
+ and `PlotScatter` (however, `PlotLine` can still be used to plot scatter points as `Plot` did before.). `Bar` is not `PlotBars`, to indicate
+ that multiple bars will be plotted.
+- 2020/05/13 (0.2) - `ImMarker` was change to `ImPlotMarker` and `ImAxisFlags` was changed to `ImPlotAxisFlags`.
+- 2020/05/11 (0.2) - `ImPlotFlags_Selection` was changed to `ImPlotFlags_BoxSelect`
+- 2020/05/11 (0.2) - The namespace ImGui:: was replaced with ImPlot::. As a result, the following additional changes were made:
+ - Functions that were prefixed or decorated with the word "Plot" have been truncated. E.g., `ImGui::PlotBars` is now just `ImPlot::Bar`.
+ It should be fairly obvious what was what.
+ - Some functions have been given names that would have otherwise collided with the ImGui namespace. This has been done to maintain a consistent
+ style with ImGui. E.g., 'ImGui::PushPlotStyleVar` is now 'ImPlot::PushStyleVar'.
+- 2020/05/10 (0.2) - The following function/struct names were changes:
+ - ImPlotRange -> ImPlotLimits
+ - GetPlotRange() -> GetPlotLimits()
+ - SetNextPlotRange -> SetNextPlotLimits
+ - SetNextPlotRangeX -> SetNextPlotLimitsX
+ - SetNextPlotRangeY -> SetNextPlotLimitsY
+- 2020/05/10 (0.2) - Plot queries are pixel based by default. Query rects that maintain relative plot position have been removed. This was done to support multi-y-axis.
+
+*/
+
+#include "implot.h"
+#include "implot_internal.h"
+
+#ifdef _MSC_VER
+#define sprintf sprintf_s
+#endif
+
+// Support for pre-1.82 version. Users on 1.82+ can use 0 (default) flags to mean "all corners" but in order to support older versions we are more explicit.
+#if (IMGUI_VERSION_NUM < 18102) && !defined(ImDrawFlags_RoundCornersAll)
+#define ImDrawFlags_RoundCornersAll ImDrawCornerFlags_All
+#endif
+
+// Global plot context
+ImPlotContext* GImPlot = NULL;
+
+//-----------------------------------------------------------------------------
+// Struct Implementations
+//-----------------------------------------------------------------------------
+
+ImPlotInputMap::ImPlotInputMap() {
+ PanButton = ImGuiMouseButton_Left;
+ PanMod = ImGuiKeyModFlags_None;
+ FitButton = ImGuiMouseButton_Left;
+ ContextMenuButton = ImGuiMouseButton_Right;
+ BoxSelectButton = ImGuiMouseButton_Right;
+ BoxSelectMod = ImGuiKeyModFlags_None;
+ BoxSelectCancelButton = ImGuiMouseButton_Left;
+ QueryButton = ImGuiMouseButton_Middle;
+ QueryMod = ImGuiKeyModFlags_None;
+ QueryToggleMod = ImGuiKeyModFlags_Ctrl;
+ HorizontalMod = ImGuiKeyModFlags_Alt;
+ VerticalMod = ImGuiKeyModFlags_Shift;
+}
+
+ImPlotStyle::ImPlotStyle() {
+
+ LineWeight = 1;
+ Marker = ImPlotMarker_None;
+ MarkerSize = 4;
+ MarkerWeight = 1;
+ FillAlpha = 1;
+ ErrorBarSize = 5;
+ ErrorBarWeight = 1.5f;
+ DigitalBitHeight = 8;
+ DigitalBitGap = 4;
+
+ PlotBorderSize = 1;
+ MinorAlpha = 0.25f;
+ MajorTickLen = ImVec2(10,10);
+ MinorTickLen = ImVec2(5,5);
+ MajorTickSize = ImVec2(1,1);
+ MinorTickSize = ImVec2(1,1);
+ MajorGridSize = ImVec2(1,1);
+ MinorGridSize = ImVec2(1,1);
+ PlotPadding = ImVec2(10,10);
+ LabelPadding = ImVec2(5,5);
+ LegendPadding = ImVec2(10,10);
+ LegendInnerPadding = ImVec2(5,5);
+ LegendSpacing = ImVec2(5,0);
+ MousePosPadding = ImVec2(10,10);
+ AnnotationPadding = ImVec2(2,2);
+ FitPadding = ImVec2(0,0);
+ PlotDefaultSize = ImVec2(400,300);
+ PlotMinSize = ImVec2(300,225);
+
+ ImPlot::StyleColorsAuto(this);
+
+ Colormap = ImPlotColormap_Deep;
+
+ AntiAliasedLines = false;
+ UseLocalTime = false;
+ Use24HourClock = false;
+ UseISO8601 = false;
+}
+
+ImPlotItem* ImPlotPlot::GetLegendItem(int i) {
+ IM_ASSERT(Items.GetSize() > 0);
+ return Items.GetByIndex(LegendData.Indices[i]);
+}
+
+const char* ImPlotPlot::GetLegendLabel(int i) {
+ ImPlotItem* item = GetLegendItem(i);
+ IM_ASSERT(item != NULL);
+ IM_ASSERT(item->NameOffset != -1 && item->NameOffset < LegendData.Labels.Buf.Size);
+ return LegendData.Labels.Buf.Data + item->NameOffset;
+}
+
+//-----------------------------------------------------------------------------
+// Style
+//-----------------------------------------------------------------------------
+
+namespace ImPlot {
+
+const char* GetStyleColorName(ImPlotCol col) {
+ static const char* col_names[] = {
+ "Line",
+ "Fill",
+ "MarkerOutline",
+ "MarkerFill",
+ "ErrorBar",
+ "FrameBg",
+ "PlotBg",
+ "PlotBorder",
+ "LegendBg",
+ "LegendBorder",
+ "LegendText",
+ "TitleText",
+ "InlayText",
+ "XAxis",
+ "XAxisGrid",
+ "YAxis",
+ "YAxisGrid",
+ "YAxis2",
+ "YAxisGrid2",
+ "YAxis3",
+ "YAxisGrid3",
+ "Selection",
+ "Query",
+ "Crosshairs"
+ };
+ return col_names[col];
+}
+
+const char* GetMarkerName(ImPlotMarker marker) {
+ switch (marker) {
+ case ImPlotMarker_None: return "None";
+ case ImPlotMarker_Circle: return "Circle";
+ case ImPlotMarker_Square: return "Square";
+ case ImPlotMarker_Diamond: return "Diamond";
+ case ImPlotMarker_Up: return "Up";
+ case ImPlotMarker_Down: return "Down";
+ case ImPlotMarker_Left: return "Left";
+ case ImPlotMarker_Right: return "Right";
+ case ImPlotMarker_Cross: return "Cross";
+ case ImPlotMarker_Plus: return "Plus";
+ case ImPlotMarker_Asterisk: return "Asterisk";
+ default: return "";
+ }
+}
+
+ImVec4 GetAutoColor(ImPlotCol idx) {
+ ImVec4 col(0,0,0,1);
+ switch(idx) {
+ case ImPlotCol_Line: return col; // these are plot dependent!
+ case ImPlotCol_Fill: return col; // these are plot dependent!
+ case ImPlotCol_MarkerOutline: return col; // these are plot dependent!
+ case ImPlotCol_MarkerFill: return col; // these are plot dependent!
+ case ImPlotCol_ErrorBar: return ImGui::GetStyleColorVec4(ImGuiCol_Text);
+ case ImPlotCol_FrameBg: return ImGui::GetStyleColorVec4(ImGuiCol_FrameBg);
+ case ImPlotCol_PlotBg: return ImGui::GetStyleColorVec4(ImGuiCol_WindowBg);
+ case ImPlotCol_PlotBorder: return ImGui::GetStyleColorVec4(ImGuiCol_Border);
+ case ImPlotCol_LegendBg: return ImGui::GetStyleColorVec4(ImGuiCol_PopupBg);
+ case ImPlotCol_LegendBorder: return GetStyleColorVec4(ImPlotCol_PlotBorder);
+ case ImPlotCol_LegendText: return GetStyleColorVec4(ImPlotCol_InlayText);
+ case ImPlotCol_TitleText: return ImGui::GetStyleColorVec4(ImGuiCol_Text);
+ case ImPlotCol_InlayText: return ImGui::GetStyleColorVec4(ImGuiCol_Text);
+ case ImPlotCol_XAxis: return ImGui::GetStyleColorVec4(ImGuiCol_Text);
+ case ImPlotCol_XAxisGrid: return GetStyleColorVec4(ImPlotCol_XAxis) * ImVec4(1,1,1,0.25f);
+ case ImPlotCol_YAxis: return ImGui::GetStyleColorVec4(ImGuiCol_Text);
+ case ImPlotCol_YAxisGrid: return GetStyleColorVec4(ImPlotCol_YAxis) * ImVec4(1,1,1,0.25f);
+ case ImPlotCol_YAxis2: return ImGui::GetStyleColorVec4(ImGuiCol_Text);
+ case ImPlotCol_YAxisGrid2: return GetStyleColorVec4(ImPlotCol_YAxis2) * ImVec4(1,1,1,0.25f);
+ case ImPlotCol_YAxis3: return ImGui::GetStyleColorVec4(ImGuiCol_Text);
+ case ImPlotCol_YAxisGrid3: return GetStyleColorVec4(ImPlotCol_YAxis3) * ImVec4(1,1,1,0.25f);
+ case ImPlotCol_Selection: return ImVec4(1,1,0,1);
+ case ImPlotCol_Query: return ImVec4(0,1,0,1);
+ case ImPlotCol_Crosshairs: return GetStyleColorVec4(ImPlotCol_PlotBorder);
+ default: return col;
+ }
+}
+
+struct ImPlotStyleVarInfo {
+ ImGuiDataType Type;
+ ImU32 Count;
+ ImU32 Offset;
+ void* GetVarPtr(ImPlotStyle* style) const { return (void*)((unsigned char*)style + Offset); }
+};
+
+static const ImPlotStyleVarInfo GPlotStyleVarInfo[] =
+{
+ { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, LineWeight) }, // ImPlotStyleVar_LineWeight
+ { ImGuiDataType_S32, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, Marker) }, // ImPlotStyleVar_Marker
+ { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, MarkerSize) }, // ImPlotStyleVar_MarkerSize
+ { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, MarkerWeight) }, // ImPlotStyleVar_MarkerWeight
+ { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, FillAlpha) }, // ImPlotStyleVar_FillAlpha
+ { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, ErrorBarSize) }, // ImPlotStyleVar_ErrorBarSize
+ { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, ErrorBarWeight) }, // ImPlotStyleVar_ErrorBarWeight
+ { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, DigitalBitHeight) }, // ImPlotStyleVar_DigitalBitHeight
+ { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, DigitalBitGap) }, // ImPlotStyleVar_DigitalBitGap
+
+ { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, PlotBorderSize) }, // ImPlotStyleVar_PlotBorderSize
+ { ImGuiDataType_Float, 1, (ImU32)IM_OFFSETOF(ImPlotStyle, MinorAlpha) }, // ImPlotStyleVar_MinorAlpha
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MajorTickLen) }, // ImPlotStyleVar_MajorTickLen
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MinorTickLen) }, // ImPlotStyleVar_MinorTickLen
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MajorTickSize) }, // ImPlotStyleVar_MajorTickSize
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MinorTickSize) }, // ImPlotStyleVar_MinorTickSize
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MajorGridSize) }, // ImPlotStyleVar_MajorGridSize
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MinorGridSize) }, // ImPlotStyleVar_MinorGridSize
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, PlotPadding) }, // ImPlotStyleVar_PlotPadding
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, LabelPadding) }, // ImPlotStyleVar_LabelPaddine
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, LegendPadding) }, // ImPlotStyleVar_LegendPadding
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, LegendInnerPadding) }, // ImPlotStyleVar_LegendInnerPadding
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, LegendSpacing) }, // ImPlotStyleVar_LegendSpacing
+
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, MousePosPadding) }, // ImPlotStyleVar_MousePosPadding
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, AnnotationPadding) }, // ImPlotStyleVar_AnnotationPadding
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, FitPadding) }, // ImPlotStyleVar_FitPadding
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, PlotDefaultSize) }, // ImPlotStyleVar_PlotDefaultSize
+ { ImGuiDataType_Float, 2, (ImU32)IM_OFFSETOF(ImPlotStyle, PlotMinSize) } // ImPlotStyleVar_PlotMinSize
+};
+
+static const ImPlotStyleVarInfo* GetPlotStyleVarInfo(ImPlotStyleVar idx) {
+ IM_ASSERT(idx >= 0 && idx < ImPlotStyleVar_COUNT);
+ IM_ASSERT(IM_ARRAYSIZE(GPlotStyleVarInfo) == ImPlotStyleVar_COUNT);
+ return &GPlotStyleVarInfo[idx];
+}
+
+//-----------------------------------------------------------------------------
+// Generic Helpers
+//-----------------------------------------------------------------------------
+
+void AddTextVertical(ImDrawList *DrawList, ImVec2 pos, ImU32 col, const char *text_begin, const char* text_end) {
+ // the code below is based loosely on ImFont::RenderText
+ if (!text_end)
+ text_end = text_begin + strlen(text_begin);
+ ImGuiContext& g = *GImGui;
+ ImFont* font = g.Font;
+ // Align to be pixel perfect
+ pos.x = IM_FLOOR(pos.x);
+ pos.y = IM_FLOOR(pos.y);
+ const float scale = g.FontSize / font->FontSize;
+ const char* s = text_begin;
+ int chars_exp = (int)(text_end - s);
+ int chars_rnd = 0;
+ const int vtx_count_max = chars_exp * 4;
+ const int idx_count_max = chars_exp * 6;
+ DrawList->PrimReserve(idx_count_max, vtx_count_max);
+ while (s < text_end) {
+ unsigned int c = (unsigned int)*s;
+ if (c < 0x80) {
+ s += 1;
+ }
+ else {
+ s += ImTextCharFromUtf8(&c, s, text_end);
+ if (c == 0) // Malformed UTF-8?
+ break;
+ }
+ const ImFontGlyph * glyph = font->FindGlyph((ImWchar)c);
+ if (glyph == NULL) {
+ continue;
+ }
+ DrawList->PrimQuadUV(pos + ImVec2(glyph->Y0, -glyph->X0) * scale, pos + ImVec2(glyph->Y0, -glyph->X1) * scale,
+ pos + ImVec2(glyph->Y1, -glyph->X1) * scale, pos + ImVec2(glyph->Y1, -glyph->X0) * scale,
+ ImVec2(glyph->U0, glyph->V0), ImVec2(glyph->U1, glyph->V0),
+ ImVec2(glyph->U1, glyph->V1), ImVec2(glyph->U0, glyph->V1),
+ col);
+ pos.y -= glyph->AdvanceX * scale;
+ chars_rnd++;
+ }
+ // Give back unused vertices
+ int chars_skp = chars_exp-chars_rnd;
+ DrawList->PrimUnreserve(chars_skp*6, chars_skp*4);
+}
+
+double NiceNum(double x, bool round) {
+ double f; /* fractional part of x */
+ double nf; /* nice, rounded fraction */
+ int expv = (int)floor(ImLog10(x));
+ f = x / ImPow(10.0, (double)expv); /* between 1 and 10 */
+ if (round)
+ if (f < 1.5)
+ nf = 1;
+ else if (f < 3)
+ nf = 2;
+ else if (f < 7)
+ nf = 5;
+ else
+ nf = 10;
+ else if (f <= 1)
+ nf = 1;
+ else if (f <= 2)
+ nf = 2;
+ else if (f <= 5)
+ nf = 5;
+ else
+ nf = 10;
+ return nf * ImPow(10.0, expv);
+}
+
+//-----------------------------------------------------------------------------
+// Context Utils
+//-----------------------------------------------------------------------------
+
+void SetImGuiContext(ImGuiContext* ctx) {
+ ImGui::SetCurrentContext(ctx);
+}
+
+ImPlotContext* CreateContext() {
+ ImPlotContext* ctx = IM_NEW(ImPlotContext)();
+ Initialize(ctx);
+ if (GImPlot == NULL)
+ SetCurrentContext(ctx);
+ return ctx;
+}
+
+void DestroyContext(ImPlotContext* ctx) {
+ if (ctx == NULL)
+ ctx = GImPlot;
+ if (GImPlot == ctx)
+ SetCurrentContext(NULL);
+ IM_DELETE(ctx);
+}
+
+ImPlotContext* GetCurrentContext() {
+ return GImPlot;
+}
+
+void SetCurrentContext(ImPlotContext* ctx) {
+ GImPlot = ctx;
+}
+
+#define IMPLOT_APPEND_CMAP(name, qual) ctx->ColormapData.Append(#name, name, sizeof(name)/sizeof(ImU32), qual)
+#define IM_RGB(r,g,b) IM_COL32(r,g,b,255)
+
+void Initialize(ImPlotContext* ctx) {
+ Reset(ctx);
+
+ const ImU32 Deep[] = {4289753676, 4283598045, 4285048917, 4283584196, 4289950337, 4284512403, 4291005402, 4287401100, 4285839820, 4291671396 };
+ const ImU32 Dark[] = {4280031972, 4290281015, 4283084621, 4288892568, 4278222847, 4281597951, 4280833702, 4290740727, 4288256409 };
+ const ImU32 Pastel[] = {4289639675, 4293119411, 4291161036, 4293184478, 4289124862, 4291624959, 4290631909, 4293712637, 4294111986 };
+ const ImU32 Paired[] = {4293119554, 4290017311, 4287291314, 4281114675, 4288256763, 4280031971, 4285513725, 4278222847, 4292260554, 4288298346, 4288282623, 4280834481};
+ const ImU32 Viridis[] = {4283695428, 4285867080, 4287054913, 4287455029, 4287526954, 4287402273, 4286883874, 4285579076, 4283552122, 4280737725, 4280674301 };
+ const ImU32 Plasma[] = {4287039501, 4288480321, 4289200234, 4288941455, 4287638193, 4286072780, 4284638433, 4283139314, 4281771772, 4280667900, 4280416752 };
+ const ImU32 Hot[] = {4278190144, 4278190208, 4278190271, 4278190335, 4278206719, 4278223103, 4278239231, 4278255615, 4283826175, 4289396735, 4294967295 };
+ const ImU32 Cool[] = {4294967040, 4294960666, 4294954035, 4294947661, 4294941030, 4294934656, 4294928025, 4294921651, 4294915020, 4294908646, 4294902015 };
+ const ImU32 Pink[] = {4278190154, 4282532475, 4284308894, 4285690554, 4286879686, 4287870160, 4288794330, 4289651940, 4291685869, 4293392118, 4294967295 };
+ const ImU32 Jet[] = {4289331200, 4294901760, 4294923520, 4294945280, 4294967040, 4289396565, 4283826090, 4278255615, 4278233855, 4278212095, 4278190335 };
+ const ImU32 Twilight[] = {IM_RGB(226,217,226),IM_RGB(166,191,202),IM_RGB(109,144,192),IM_RGB(95,88,176),IM_RGB(83,30,124),IM_RGB(47,20,54),IM_RGB(100,25,75),IM_RGB(159,60,80),IM_RGB(192,117,94),IM_RGB(208,179,158),IM_RGB(226,217,226)};
+ const ImU32 RdBu[] = {IM_RGB(103,0,31),IM_RGB(178,24,43),IM_RGB(214,96,77),IM_RGB(244,165,130),IM_RGB(253,219,199),IM_RGB(247,247,247),IM_RGB(209,229,240),IM_RGB(146,197,222),IM_RGB(67,147,195),IM_RGB(33,102,172),IM_RGB(5,48,97)};
+ const ImU32 BrBG[] = {IM_RGB(84,48,5),IM_RGB(140,81,10),IM_RGB(191,129,45),IM_RGB(223,194,125),IM_RGB(246,232,195),IM_RGB(245,245,245),IM_RGB(199,234,229),IM_RGB(128,205,193),IM_RGB(53,151,143),IM_RGB(1,102,94),IM_RGB(0,60,48)};
+ const ImU32 PiYG[] = {IM_RGB(142,1,82),IM_RGB(197,27,125),IM_RGB(222,119,174),IM_RGB(241,182,218),IM_RGB(253,224,239),IM_RGB(247,247,247),IM_RGB(230,245,208),IM_RGB(184,225,134),IM_RGB(127,188,65),IM_RGB(77,146,33),IM_RGB(39,100,25)};
+ const ImU32 Spectral[] = {IM_RGB(158,1,66),IM_RGB(213,62,79),IM_RGB(244,109,67),IM_RGB(253,174,97),IM_RGB(254,224,139),IM_RGB(255,255,191),IM_RGB(230,245,152),IM_RGB(171,221,164),IM_RGB(102,194,165),IM_RGB(50,136,189),IM_RGB(94,79,162)};
+ const ImU32 Greys[] = {IM_COL32_WHITE, IM_COL32_BLACK };
+
+ IMPLOT_APPEND_CMAP(Deep, true);
+ IMPLOT_APPEND_CMAP(Dark, true);
+ IMPLOT_APPEND_CMAP(Pastel, true);
+ IMPLOT_APPEND_CMAP(Paired, true);
+ IMPLOT_APPEND_CMAP(Viridis, false);
+ IMPLOT_APPEND_CMAP(Plasma, false);
+ IMPLOT_APPEND_CMAP(Hot, false);
+ IMPLOT_APPEND_CMAP(Cool, false);
+ IMPLOT_APPEND_CMAP(Pink, false);
+ IMPLOT_APPEND_CMAP(Jet, false);
+ IMPLOT_APPEND_CMAP(Twilight, false);
+ IMPLOT_APPEND_CMAP(RdBu, false);
+ IMPLOT_APPEND_CMAP(BrBG, false);
+ IMPLOT_APPEND_CMAP(PiYG, false);
+ IMPLOT_APPEND_CMAP(Spectral, false);
+ IMPLOT_APPEND_CMAP(Greys, false);
+
+}
+
+void Reset(ImPlotContext* ctx) {
+ // end child window if it was made
+ if (ctx->ChildWindowMade)
+ ImGui::EndChild();
+ ctx->ChildWindowMade = false;
+ // reset the next plot/item data
+ ctx->NextPlotData.Reset();
+ ctx->NextItemData.Reset();
+ // reset items count
+ ctx->VisibleItemCount = 0;
+ // reset ticks/labels
+ ctx->XTicks.Reset();
+ for (int i = 0; i < 3; ++i)
+ ctx->YTicks[i].Reset();
+ // reset labels
+ ctx->Annotations.Reset();
+ // reset extents/fit
+ ctx->FitThisFrame = false;
+ ctx->FitX = false;
+ ctx->ExtentsX.Min = HUGE_VAL;
+ ctx->ExtentsX.Max = -HUGE_VAL;
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ ctx->ExtentsY[i].Min = HUGE_VAL;
+ ctx->ExtentsY[i].Max = -HUGE_VAL;
+ ctx->FitY[i] = false;
+ }
+ // reset digital plot items count
+ ctx->DigitalPlotItemCnt = 0;
+ ctx->DigitalPlotOffset = 0;
+ // nullify plot
+ ctx->CurrentPlot = NULL;
+ ctx->CurrentItem = NULL;
+ ctx->PreviousItem = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Plot Utils
+//-----------------------------------------------------------------------------
+
+ImPlotPlot* GetPlot(const char* title) {
+ ImGuiWindow* Window = GImGui->CurrentWindow;
+ const ImGuiID ID = Window->GetID(title);
+ return GImPlot->Plots.GetByKey(ID);
+}
+
+ImPlotPlot* GetCurrentPlot() {
+ return GImPlot->CurrentPlot;
+}
+
+void BustPlotCache() {
+ GImPlot->Plots.Clear();
+}
+
+void PushLinkedAxis(ImPlotAxis& axis) {
+ if (axis.LinkedMin) { *axis.LinkedMin = axis.Range.Min; }
+ if (axis.LinkedMax) { *axis.LinkedMax = axis.Range.Max; }
+}
+
+void PullLinkedAxis(ImPlotAxis& axis) {
+ if (axis.LinkedMin) { axis.SetMin(*axis.LinkedMin,true); }
+ if (axis.LinkedMax) { axis.SetMax(*axis.LinkedMax,true); }
+}
+
+//-----------------------------------------------------------------------------
+// Coordinate Utils
+//-----------------------------------------------------------------------------
+
+void UpdateTransformCache() {
+ ImPlotContext& gp = *GImPlot;
+ // get pixels for transforms
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ gp.PixelRange[i] = ImRect(ImHasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_Invert) ? gp.CurrentPlot->PlotRect.Max.x : gp.CurrentPlot->PlotRect.Min.x,
+ ImHasFlag(gp.CurrentPlot->YAxis[i].Flags, ImPlotAxisFlags_Invert) ? gp.CurrentPlot->PlotRect.Min.y : gp.CurrentPlot->PlotRect.Max.y,
+ ImHasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_Invert) ? gp.CurrentPlot->PlotRect.Min.x : gp.CurrentPlot->PlotRect.Max.x,
+ ImHasFlag(gp.CurrentPlot->YAxis[i].Flags, ImPlotAxisFlags_Invert) ? gp.CurrentPlot->PlotRect.Max.y : gp.CurrentPlot->PlotRect.Min.y);
+ gp.My[i] = (gp.PixelRange[i].Max.y - gp.PixelRange[i].Min.y) / gp.CurrentPlot->YAxis[i].Range.Size();
+ }
+ gp.LogDenX = ImLog10(gp.CurrentPlot->XAxis.Range.Max / gp.CurrentPlot->XAxis.Range.Min);
+ for (int i = 0; i < IMPLOT_Y_AXES; i++)
+ gp.LogDenY[i] = ImLog10(gp.CurrentPlot->YAxis[i].Range.Max / gp.CurrentPlot->YAxis[i].Range.Min);
+ gp.Mx = (gp.PixelRange[0].Max.x - gp.PixelRange[0].Min.x) / gp.CurrentPlot->XAxis.Range.Size();
+}
+
+ImPlotPoint PixelsToPlot(float x, float y, ImPlotYAxis y_axis_in) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "PixelsToPlot() needs to be called between BeginPlot() and EndPlot()!");
+ const ImPlotYAxis y_axis = y_axis_in >= 0 ? y_axis_in : gp.CurrentPlot->CurrentYAxis;
+ ImPlotPoint plt;
+ plt.x = (x - gp.PixelRange[y_axis].Min.x) / gp.Mx + gp.CurrentPlot->XAxis.Range.Min;
+ plt.y = (y - gp.PixelRange[y_axis].Min.y) / gp.My[y_axis] + gp.CurrentPlot->YAxis[y_axis].Range.Min;
+ if (ImHasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_LogScale)) {
+ double t = (plt.x - gp.CurrentPlot->XAxis.Range.Min) / gp.CurrentPlot->XAxis.Range.Size();
+ plt.x = ImPow(10, t * gp.LogDenX) * gp.CurrentPlot->XAxis.Range.Min;
+ }
+ if (ImHasFlag(gp.CurrentPlot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) {
+ double t = (plt.y - gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.CurrentPlot->YAxis[y_axis].Range.Size();
+ plt.y = ImPow(10, t * gp.LogDenY[y_axis]) * gp.CurrentPlot->YAxis[y_axis].Range.Min;
+ }
+ return plt;
+}
+
+ImPlotPoint PixelsToPlot(const ImVec2& pix, ImPlotYAxis y_axis) {
+ return PixelsToPlot(pix.x, pix.y, y_axis);
+}
+
+// This function is convenient but should not be used to process a high volume of points. Use the Transformer structs below instead.
+ImVec2 PlotToPixels(double x, double y, ImPlotYAxis y_axis_in) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "PlotToPixels() needs to be called between BeginPlot() and EndPlot()!");
+ const ImPlotYAxis y_axis = y_axis_in >= 0 ? y_axis_in : gp.CurrentPlot->CurrentYAxis;
+ ImVec2 pix;
+ if (ImHasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_LogScale)) {
+ double t = ImLog10(x / gp.CurrentPlot->XAxis.Range.Min) / gp.LogDenX;
+ x = ImLerp(gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max, (float)t);
+ }
+ if (ImHasFlag(gp.CurrentPlot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) {
+ double t = ImLog10(y / gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.LogDenY[y_axis];
+ y = ImLerp(gp.CurrentPlot->YAxis[y_axis].Range.Min, gp.CurrentPlot->YAxis[y_axis].Range.Max, (float)t);
+ }
+ pix.x = (float)(gp.PixelRange[y_axis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min));
+ pix.y = (float)(gp.PixelRange[y_axis].Min.y + gp.My[y_axis] * (y - gp.CurrentPlot->YAxis[y_axis].Range.Min));
+ return pix;
+}
+
+// This function is convenient but should not be used to process a high volume of points. Use the Transformer structs below instead.
+ImVec2 PlotToPixels(const ImPlotPoint& plt, ImPlotYAxis y_axis) {
+ return PlotToPixels(plt.x, plt.y, y_axis);
+}
+
+//-----------------------------------------------------------------------------
+// Legend Utils
+//-----------------------------------------------------------------------------
+
+ImVec2 GetLocationPos(const ImRect& outer_rect, const ImVec2& inner_size, ImPlotLocation loc, const ImVec2& pad) {
+ ImVec2 pos;
+ if (ImHasFlag(loc, ImPlotLocation_West) && !ImHasFlag(loc, ImPlotLocation_East))
+ pos.x = outer_rect.Min.x + pad.x;
+ else if (!ImHasFlag(loc, ImPlotLocation_West) && ImHasFlag(loc, ImPlotLocation_East))
+ pos.x = outer_rect.Max.x - pad.x - inner_size.x;
+ else
+ pos.x = outer_rect.GetCenter().x - inner_size.x * 0.5f;
+ // legend reference point y
+ if (ImHasFlag(loc, ImPlotLocation_North) && !ImHasFlag(loc, ImPlotLocation_South))
+ pos.y = outer_rect.Min.y + pad.y;
+ else if (!ImHasFlag(loc, ImPlotLocation_North) && ImHasFlag(loc, ImPlotLocation_South))
+ pos.y = outer_rect.Max.y - pad.y - inner_size.y;
+ else
+ pos.y = outer_rect.GetCenter().y - inner_size.y * 0.5f;
+ pos.x = IM_ROUND(pos.x);
+ pos.y = IM_ROUND(pos.y);
+ return pos;
+}
+
+ImVec2 CalcLegendSize(ImPlotPlot& plot, const ImVec2& pad, const ImVec2& spacing, ImPlotOrientation orn) {
+ // vars
+ const int nItems = plot.GetLegendCount();
+ const float txt_ht = ImGui::GetTextLineHeight();
+ const float icon_size = txt_ht;
+ // get label max width
+ float max_label_width = 0;
+ float sum_label_width = 0;
+ for (int i = 0; i < nItems; ++i) {
+ const char* label = plot.GetLegendLabel(i);
+ const float label_width = ImGui::CalcTextSize(label, NULL, true).x;
+ max_label_width = label_width > max_label_width ? label_width : max_label_width;
+ sum_label_width += label_width;
+ }
+ // calc legend size
+ const ImVec2 legend_size = orn == ImPlotOrientation_Vertical ?
+ ImVec2(pad.x * 2 + icon_size + max_label_width, pad.y * 2 + nItems * txt_ht + (nItems - 1) * spacing.y) :
+ ImVec2(pad.x * 2 + icon_size * nItems + sum_label_width + (nItems - 1) * spacing.x, pad.y * 2 + txt_ht);
+ return legend_size;
+}
+
+void ShowLegendEntries(ImPlotPlot& plot, const ImRect& legend_bb, bool interactable, const ImVec2& pad, const ImVec2& spacing, ImPlotOrientation orn, ImDrawList& DrawList) {
+ ImGuiIO& IO = ImGui::GetIO();
+ // vars
+ const float txt_ht = ImGui::GetTextLineHeight();
+ const float icon_size = txt_ht;
+ const float icon_shrink = 2;
+ ImU32 col_txt = GetStyleColorU32(ImPlotCol_LegendText);
+ ImU32 col_txt_dis = ImAlphaU32(col_txt, 0.25f);
+ // render each legend item
+ float sum_label_width = 0;
+ for (int i = 0; i < plot.GetLegendCount(); ++i) {
+ ImPlotItem* item = plot.GetLegendItem(i);
+ const char* label = plot.GetLegendLabel(i);
+ const float label_width = ImGui::CalcTextSize(label, NULL, true).x;
+ const ImVec2 top_left = orn == ImPlotOrientation_Vertical ?
+ legend_bb.Min + pad + ImVec2(0, i * (txt_ht + spacing.y)) :
+ legend_bb.Min + pad + ImVec2(i * (icon_size + spacing.x) + sum_label_width, 0);
+ sum_label_width += label_width;
+ ImRect icon_bb;
+ icon_bb.Min = top_left + ImVec2(icon_shrink,icon_shrink);
+ icon_bb.Max = top_left + ImVec2(icon_size - icon_shrink, icon_size - icon_shrink);
+ ImRect label_bb;
+ label_bb.Min = top_left;
+ label_bb.Max = top_left + ImVec2(label_width + icon_size, icon_size);
+ ImU32 col_hl_txt;
+ ImU32 col_item = ImAlphaU32(item->Color,1);
+ if (interactable && (icon_bb.Contains(IO.MousePos) || label_bb.Contains(IO.MousePos))) {
+ item->LegendHovered = true;
+ col_hl_txt = ImMixU32(col_txt, col_item, 64);
+ }
+ else {
+ // item->LegendHovered = false;
+ col_hl_txt = ImGui::GetColorU32(col_txt);
+ }
+ ImU32 iconColor;
+ if (interactable && icon_bb.Contains(IO.MousePos)) {
+ ImU32 col_alpha = ImAlphaU32(col_item,0.5f);
+ iconColor = item->Show ? col_alpha : ImGui::GetColorU32(ImGuiCol_TextDisabled, 0.5f);
+ if (IO.MouseClicked[0])
+ item->Show = !item->Show;
+ }
+ else {
+ iconColor = item->Show ? col_item : col_txt_dis;
+ }
+ DrawList.AddRectFilled(icon_bb.Min, icon_bb.Max, iconColor, 1);
+ const char* text_display_end = ImGui::FindRenderedTextEnd(label, NULL);
+ if (label != text_display_end)
+ DrawList.AddText(top_left + ImVec2(icon_size, 0), item->Show ? col_hl_txt : col_txt_dis, label, text_display_end);
+ }
+}
+
+//-----------------------------------------------------------------------------
+// Tick Utils
+//-----------------------------------------------------------------------------
+
+void AddTicksDefault(const ImPlotRange& range, float pix, ImPlotOrientation orn, ImPlotTickCollection& ticks, const char* fmt) {
+ const int idx0 = ticks.Size;
+ const int nMinor = 10;
+ const int nMajor = ImMax(2, (int)IM_ROUND(pix / (orn == ImPlotOrientation_Horizontal ? 400.0f : 300.0f)));
+ const double nice_range = NiceNum(range.Size() * 0.99, false);
+ const double interval = NiceNum(nice_range / (nMajor - 1), true);
+ const double graphmin = floor(range.Min / interval) * interval;
+ const double graphmax = ceil(range.Max / interval) * interval;
+ bool first_major_set = false;
+ int first_major_idx = 0;
+
+ char dummy[32];
+ sprintf(dummy,fmt,-ImAbs(interval / nMinor));
+ ImVec2 dummy_size = ImGui::CalcTextSize(dummy);
+ ImVec2 total_size(0,0);
+
+ for (double major = graphmin; major < graphmax + 0.5 * interval; major += interval) {
+ // is this zero? combat zero formatting issues
+ if (major-interval < 0 && major+interval > 0)
+ major = 0;
+ if (range.Contains(major)) {
+ if (!first_major_set) {
+ first_major_idx = ticks.Size;
+ first_major_set = true;
+ }
+ ticks.Append(major, true, true, fmt);
+ total_size += dummy_size;
+ }
+ for (int i = 1; i < nMinor; ++i) {
+ double minor = major + i * interval / nMinor;
+ if (range.Contains(minor)) {
+ ticks.Append(minor, false, true, fmt);
+ total_size += dummy_size;
+ }
+ }
+ }
+ // prune if necessary
+ if ((orn == ImPlotOrientation_Horizontal && total_size.x > pix) || (orn == ImPlotOrientation_Vertical && total_size.y > pix)) {
+ for (int i = first_major_idx-1; i >= idx0; i -= 2)
+ ticks.Ticks[i].ShowLabel = false;
+ for (int i = first_major_idx+1; i < ticks.Size; i += 2)
+ ticks.Ticks[i].ShowLabel = false;
+ }
+}
+
+void AddTicksLogarithmic(const ImPlotRange& range, float pix, ImPlotOrientation orn, ImPlotTickCollection& ticks, const char* fmt) {
+ if (range.Min <= 0 || range.Max <= 0)
+ return;
+ const int nMajor = orn == ImPlotOrientation_Horizontal ? ImMax(2, (int)IM_ROUND(pix * 0.01f)) : ImMax(2, (int)IM_ROUND(pix * 0.02f));
+ double log_min = ImLog10(range.Min);
+ double log_max = ImLog10(range.Max);
+ int exp_step = ImMax(1,(int)(log_max - log_min) / nMajor);
+ int exp_min = (int)log_min;
+ int exp_max = (int)log_max;
+ if (exp_step != 1) {
+ while(exp_step % 3 != 0) exp_step++; // make step size multiple of three
+ while(exp_min % exp_step != 0) exp_min--; // decrease exp_min until exp_min + N * exp_step will be 0
+ }
+ for (int e = exp_min - exp_step; e < (exp_max + exp_step); e += exp_step) {
+ double major1 = ImPow(10, (double)(e));
+ double major2 = ImPow(10, (double)(e + 1));
+ double interval = (major2 - major1) / 9;
+ if (major1 >= (range.Min - DBL_EPSILON) && major1 <= (range.Max + DBL_EPSILON))
+ ticks.Append(major1, true, true, fmt);
+ for (int j = 0; j < exp_step; ++j) {
+ major1 = ImPow(10, (double)(e+j));
+ major2 = ImPow(10, (double)(e+j+1));
+ interval = (major2 - major1) / 9;
+ for (int i = 1; i < (9 + (int)(j < (exp_step - 1))); ++i) {
+ double minor = major1 + i * interval;
+ if (minor >= (range.Min - DBL_EPSILON) && minor <= (range.Max + DBL_EPSILON))
+ ticks.Append(minor, false, false, fmt);
+
+ }
+ }
+ }
+}
+
+void AddTicksCustom(const double* values, const char* const labels[], int n, ImPlotTickCollection& ticks, const char* fmt) {
+ for (int i = 0; i < n; ++i) {
+ if (labels != NULL) {
+ ImPlotTick tick(values[i], false, true);
+ tick.TextOffset = ticks.TextBuffer.size();
+ ticks.TextBuffer.append(labels[i], labels[i] + strlen(labels[i]) + 1);
+ tick.LabelSize = ImGui::CalcTextSize(labels[i]);
+ ticks.Append(tick);
+ }
+ else {
+ ticks.Append(values[i], false, true, fmt);
+ }
+ }
+}
+
+//-----------------------------------------------------------------------------
+// Time Ticks and Utils
+//-----------------------------------------------------------------------------
+
+// this may not be thread safe?
+static const double TimeUnitSpans[ImPlotTimeUnit_COUNT] = {
+ 0.000001,
+ 0.001,
+ 1,
+ 60,
+ 3600,
+ 86400,
+ 2629800,
+ 31557600
+};
+
+inline ImPlotTimeUnit GetUnitForRange(double range) {
+ static double cutoffs[ImPlotTimeUnit_COUNT] = {0.001, 1, 60, 3600, 86400, 2629800, 31557600, IMPLOT_MAX_TIME};
+ for (int i = 0; i < ImPlotTimeUnit_COUNT; ++i) {
+ if (range <= cutoffs[i])
+ return (ImPlotTimeUnit)i;
+ }
+ return ImPlotTimeUnit_Yr;
+}
+
+inline int LowerBoundStep(int max_divs, const int* divs, const int* step, int size) {
+ if (max_divs < divs[0])
+ return 0;
+ for (int i = 1; i < size; ++i) {
+ if (max_divs < divs[i])
+ return step[i-1];
+ }
+ return step[size-1];
+}
+
+inline int GetTimeStep(int max_divs, ImPlotTimeUnit unit) {
+ if (unit == ImPlotTimeUnit_Ms || unit == ImPlotTimeUnit_Us) {
+ static const int step[] = {500,250,200,100,50,25,20,10,5,2,1};
+ static const int divs[] = {2,4,5,10,20,40,50,100,200,500,1000};
+ return LowerBoundStep(max_divs, divs, step, 11);
+ }
+ if (unit == ImPlotTimeUnit_S || unit == ImPlotTimeUnit_Min) {
+ static const int step[] = {30,15,10,5,1};
+ static const int divs[] = {2,4,6,12,60};
+ return LowerBoundStep(max_divs, divs, step, 5);
+ }
+ else if (unit == ImPlotTimeUnit_Hr) {
+ static const int step[] = {12,6,3,2,1};
+ static const int divs[] = {2,4,8,12,24};
+ return LowerBoundStep(max_divs, divs, step, 5);
+ }
+ else if (unit == ImPlotTimeUnit_Day) {
+ static const int step[] = {14,7,2,1};
+ static const int divs[] = {2,4,14,28};
+ return LowerBoundStep(max_divs, divs, step, 4);
+ }
+ else if (unit == ImPlotTimeUnit_Mo) {
+ static const int step[] = {6,3,2,1};
+ static const int divs[] = {2,4,6,12};
+ return LowerBoundStep(max_divs, divs, step, 4);
+ }
+ return 0;
+}
+
+ImPlotTime MkGmtTime(struct tm *ptm) {
+ ImPlotTime t;
+#ifdef _WIN32
+ t.S = _mkgmtime(ptm);
+#else
+ t.S = timegm(ptm);
+#endif
+ if (t.S < 0)
+ t.S = 0;
+ return t;
+}
+
+tm* GetGmtTime(const ImPlotTime& t, tm* ptm)
+{
+#ifdef _WIN32
+ if (gmtime_s(ptm, &t.S) == 0)
+ return ptm;
+ else
+ return NULL;
+#else
+ return gmtime_r(&t.S, ptm);
+#endif
+}
+
+ImPlotTime MkLocTime(struct tm *ptm) {
+ ImPlotTime t;
+ t.S = mktime(ptm);
+ if (t.S < 0)
+ t.S = 0;
+ return t;
+}
+
+tm* GetLocTime(const ImPlotTime& t, tm* ptm) {
+#ifdef _WIN32
+ if (localtime_s(ptm, &t.S) == 0)
+ return ptm;
+ else
+ return NULL;
+#else
+ return localtime_r(&t.S, ptm);
+#endif
+}
+
+inline ImPlotTime MkTime(struct tm *ptm) {
+ if (GetStyle().UseLocalTime)
+ return MkLocTime(ptm);
+ else
+ return MkGmtTime(ptm);
+}
+
+inline tm* GetTime(const ImPlotTime& t, tm* ptm) {
+ if (GetStyle().UseLocalTime)
+ return GetLocTime(t,ptm);
+ else
+ return GetGmtTime(t,ptm);
+}
+
+ImPlotTime MakeTime(int year, int month, int day, int hour, int min, int sec, int us) {
+ tm& Tm = GImPlot->Tm;
+
+ int yr = year - 1900;
+ if (yr < 0)
+ yr = 0;
+
+ sec = sec + us / 1000000;
+ us = us % 1000000;
+
+ Tm.tm_sec = sec;
+ Tm.tm_min = min;
+ Tm.tm_hour = hour;
+ Tm.tm_mday = day;
+ Tm.tm_mon = month;
+ Tm.tm_year = yr;
+
+ ImPlotTime t = MkTime(&Tm);
+
+ t.Us = us;
+ return t;
+}
+
+int GetYear(const ImPlotTime& t) {
+ tm& Tm = GImPlot->Tm;
+ GetTime(t, &Tm);
+ return Tm.tm_year + 1900;
+}
+
+ImPlotTime AddTime(const ImPlotTime& t, ImPlotTimeUnit unit, int count) {
+ tm& Tm = GImPlot->Tm;
+ ImPlotTime t_out = t;
+ switch(unit) {
+ case ImPlotTimeUnit_Us: t_out.Us += count; break;
+ case ImPlotTimeUnit_Ms: t_out.Us += count * 1000; break;
+ case ImPlotTimeUnit_S: t_out.S += count; break;
+ case ImPlotTimeUnit_Min: t_out.S += count * 60; break;
+ case ImPlotTimeUnit_Hr: t_out.S += count * 3600; break;
+ case ImPlotTimeUnit_Day: t_out.S += count * 86400; break;
+ case ImPlotTimeUnit_Mo: for (int i = 0; i < abs(count); ++i) {
+ GetTime(t_out, &Tm);
+ if (count > 0)
+ t_out.S += 86400 * GetDaysInMonth(Tm.tm_year + 1900, Tm.tm_mon);
+ else if (count < 0)
+ t_out.S -= 86400 * GetDaysInMonth(Tm.tm_year + 1900 - (Tm.tm_mon == 0 ? 1 : 0), Tm.tm_mon == 0 ? 11 : Tm.tm_mon - 1); // NOT WORKING
+ }
+ break;
+ case ImPlotTimeUnit_Yr: for (int i = 0; i < abs(count); ++i) {
+ if (count > 0)
+ t_out.S += 86400 * (365 + (int)IsLeapYear(GetYear(t_out)));
+ else if (count < 0)
+ t_out.S -= 86400 * (365 + (int)IsLeapYear(GetYear(t_out) - 1));
+ // this is incorrect if leap year and we are past Feb 28
+ }
+ break;
+ default: break;
+ }
+ t_out.RollOver();
+ return t_out;
+}
+
+ImPlotTime FloorTime(const ImPlotTime& t, ImPlotTimeUnit unit) {
+ GetTime(t, &GImPlot->Tm);
+ switch (unit) {
+ case ImPlotTimeUnit_S: return ImPlotTime(t.S, 0);
+ case ImPlotTimeUnit_Ms: return ImPlotTime(t.S, (t.Us / 1000) * 1000);
+ case ImPlotTimeUnit_Us: return t;
+ case ImPlotTimeUnit_Yr: GImPlot->Tm.tm_mon = 0; // fall-through
+ case ImPlotTimeUnit_Mo: GImPlot->Tm.tm_mday = 1; // fall-through
+ case ImPlotTimeUnit_Day: GImPlot->Tm.tm_hour = 0; // fall-through
+ case ImPlotTimeUnit_Hr: GImPlot->Tm.tm_min = 0; // fall-through
+ case ImPlotTimeUnit_Min: GImPlot->Tm.tm_sec = 0; break;
+ default: return t;
+ }
+ return MkTime(&GImPlot->Tm);
+}
+
+ImPlotTime CeilTime(const ImPlotTime& t, ImPlotTimeUnit unit) {
+ return AddTime(FloorTime(t, unit), unit, 1);
+}
+
+ImPlotTime RoundTime(const ImPlotTime& t, ImPlotTimeUnit unit) {
+ ImPlotTime t1 = FloorTime(t, unit);
+ ImPlotTime t2 = AddTime(t1,unit,1);
+ if (t1.S == t2.S)
+ return t.Us - t1.Us < t2.Us - t.Us ? t1 : t2;
+ return t.S - t1.S < t2.S - t.S ? t1 : t2;
+}
+
+ImPlotTime CombineDateTime(const ImPlotTime& date_part, const ImPlotTime& tod_part) {
+ tm& Tm = GImPlot->Tm;
+ GetTime(date_part, &GImPlot->Tm);
+ int y = Tm.tm_year;
+ int m = Tm.tm_mon;
+ int d = Tm.tm_mday;
+ GetTime(tod_part, &GImPlot->Tm);
+ Tm.tm_year = y;
+ Tm.tm_mon = m;
+ Tm.tm_mday = d;
+ ImPlotTime t = MkTime(&Tm);
+ t.Us = tod_part.Us;
+ return t;
+}
+
+static const char* MONTH_NAMES[] = {"January","February","March","April","May","June","July","August","September","October","November","December"};
+static const char* WD_ABRVS[] = {"Su","Mo","Tu","We","Th","Fr","Sa"};
+static const char* MONTH_ABRVS[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
+
+int FormatTime(const ImPlotTime& t, char* buffer, int size, ImPlotTimeFmt fmt, bool use_24_hr_clk) {
+ tm& Tm = GImPlot->Tm;
+ GetTime(t, &Tm);
+ const int us = t.Us % 1000;
+ const int ms = t.Us / 1000;
+ const int sec = Tm.tm_sec;
+ const int min = Tm.tm_min;
+ if (use_24_hr_clk) {
+ const int hr = Tm.tm_hour;
+ switch(fmt) {
+ case ImPlotTimeFmt_Us: return snprintf(buffer, size, ".%03d %03d", ms, us);
+ case ImPlotTimeFmt_SUs: return snprintf(buffer, size, ":%02d.%03d %03d", sec, ms, us);
+ case ImPlotTimeFmt_SMs: return snprintf(buffer, size, ":%02d.%03d", sec, ms);
+ case ImPlotTimeFmt_S: return snprintf(buffer, size, ":%02d", sec);
+ case ImPlotTimeFmt_HrMinSMs: return snprintf(buffer, size, "%02d:%02d:%02d.%03d", hr, min, sec, ms);
+ case ImPlotTimeFmt_HrMinS: return snprintf(buffer, size, "%02d:%02d:%02d", hr, min, sec);
+ case ImPlotTimeFmt_HrMin: return snprintf(buffer, size, "%02d:%02d", hr, min);
+ case ImPlotTimeFmt_Hr: return snprintf(buffer, size, "%02d:00", hr);
+ default: return 0;
+ }
+ }
+ else {
+ const char* ap = Tm.tm_hour < 12 ? "am" : "pm";
+ const int hr = (Tm.tm_hour == 0 || Tm.tm_hour == 12) ? 12 : Tm.tm_hour % 12;
+ switch(fmt) {
+ case ImPlotTimeFmt_Us: return snprintf(buffer, size, ".%03d %03d", ms, us);
+ case ImPlotTimeFmt_SUs: return snprintf(buffer, size, ":%02d.%03d %03d", sec, ms, us);
+ case ImPlotTimeFmt_SMs: return snprintf(buffer, size, ":%02d.%03d", sec, ms);
+ case ImPlotTimeFmt_S: return snprintf(buffer, size, ":%02d", sec);
+ case ImPlotTimeFmt_HrMinSMs: return snprintf(buffer, size, "%d:%02d:%02d.%03d%s", hr, min, sec, ms, ap);
+ case ImPlotTimeFmt_HrMinS: return snprintf(buffer, size, "%d:%02d:%02d%s", hr, min, sec, ap);
+ case ImPlotTimeFmt_HrMin: return snprintf(buffer, size, "%d:%02d%s", hr, min, ap);
+ case ImPlotTimeFmt_Hr: return snprintf(buffer, size, "%d%s", hr, ap);
+ default: return 0;
+ }
+ }
+}
+
+int FormatDate(const ImPlotTime& t, char* buffer, int size, ImPlotDateFmt fmt, bool use_iso_8601) {
+ tm& Tm = GImPlot->Tm;
+ GetTime(t, &Tm);
+ const int day = Tm.tm_mday;
+ const int mon = Tm.tm_mon + 1;
+ const int year = Tm.tm_year + 1900;
+ const int yr = year % 100;
+ if (use_iso_8601) {
+ switch (fmt) {
+ case ImPlotDateFmt_DayMo: return snprintf(buffer, size, "--%02d-%02d", mon, day);
+ case ImPlotDateFmt_DayMoYr: return snprintf(buffer, size, "%d-%02d-%02d", year, mon, day);
+ case ImPlotDateFmt_MoYr: return snprintf(buffer, size, "%d-%02d", year, mon);
+ case ImPlotDateFmt_Mo: return snprintf(buffer, size, "--%02d", mon);
+ case ImPlotDateFmt_Yr: return snprintf(buffer, size, "%d", year);
+ default: return 0;
+ }
+ }
+ else {
+ switch (fmt) {
+ case ImPlotDateFmt_DayMo: return snprintf(buffer, size, "%d/%d", mon, day);
+ case ImPlotDateFmt_DayMoYr: return snprintf(buffer, size, "%d/%d/%02d", mon, day, yr);
+ case ImPlotDateFmt_MoYr: return snprintf(buffer, size, "%s %d", MONTH_ABRVS[Tm.tm_mon], year);
+ case ImPlotDateFmt_Mo: return snprintf(buffer, size, "%s", MONTH_ABRVS[Tm.tm_mon]);
+ case ImPlotDateFmt_Yr: return snprintf(buffer, size, "%d", year);
+ default: return 0;
+ }
+ }
+ }
+
+int FormatDateTime(const ImPlotTime& t, char* buffer, int size, ImPlotDateTimeFmt fmt) {
+ int written = 0;
+ if (fmt.Date != ImPlotDateFmt_None)
+ written += FormatDate(t, buffer, size, fmt.Date, fmt.UseISO8601);
+ if (fmt.Time != ImPlotTimeFmt_None) {
+ if (fmt.Date != ImPlotDateFmt_None)
+ buffer[written++] = ' ';
+ written += FormatTime(t, &buffer[written], size - written, fmt.Time, fmt.Use24HourClock);
+ }
+ return written;
+}
+
+inline float GetDateTimeWidth(ImPlotDateTimeFmt fmt) {
+ static const ImPlotTime t_max_width = MakeTime(2888, 12, 22, 12, 58, 58, 888888); // best guess at time that maximizes pixel width
+ char buffer[32];
+ FormatDateTime(t_max_width, buffer, 32, fmt);
+ return ImGui::CalcTextSize(buffer).x;
+}
+
+void LabelTickTime(ImPlotTick& tick, ImGuiTextBuffer& buffer, const ImPlotTime& t, ImPlotDateTimeFmt fmt) {
+ char temp[32];
+ if (tick.ShowLabel) {
+ tick.TextOffset = buffer.size();
+ FormatDateTime(t, temp, 32, fmt);
+ buffer.append(temp, temp + strlen(temp) + 1);
+ tick.LabelSize = ImGui::CalcTextSize(buffer.Buf.Data + tick.TextOffset);
+ }
+}
+
+inline bool TimeLabelSame(const char* l1, const char* l2) {
+ size_t len1 = strlen(l1);
+ size_t len2 = strlen(l2);
+ size_t n = len1 < len2 ? len1 : len2;
+ return strcmp(l1 + len1 - n, l2 + len2 - n) == 0;
+}
+
+static const ImPlotDateTimeFmt TimeFormatLevel0[ImPlotTimeUnit_COUNT] = {
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_Us),
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_SMs),
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_S),
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_HrMin),
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_Hr),
+ ImPlotDateTimeFmt(ImPlotDateFmt_DayMo, ImPlotTimeFmt_None),
+ ImPlotDateTimeFmt(ImPlotDateFmt_Mo, ImPlotTimeFmt_None),
+ ImPlotDateTimeFmt(ImPlotDateFmt_Yr, ImPlotTimeFmt_None)
+};
+
+static const ImPlotDateTimeFmt TimeFormatLevel1[ImPlotTimeUnit_COUNT] = {
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_HrMin),
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_HrMinS),
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_HrMin),
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_HrMin),
+ ImPlotDateTimeFmt(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),
+ ImPlotDateTimeFmt(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),
+ ImPlotDateTimeFmt(ImPlotDateFmt_Yr, ImPlotTimeFmt_None),
+ ImPlotDateTimeFmt(ImPlotDateFmt_Yr, ImPlotTimeFmt_None)
+};
+
+static const ImPlotDateTimeFmt TimeFormatLevel1First[ImPlotTimeUnit_COUNT] = {
+ ImPlotDateTimeFmt(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMinS),
+ ImPlotDateTimeFmt(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMinS),
+ ImPlotDateTimeFmt(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMin),
+ ImPlotDateTimeFmt(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMin),
+ ImPlotDateTimeFmt(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),
+ ImPlotDateTimeFmt(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),
+ ImPlotDateTimeFmt(ImPlotDateFmt_Yr, ImPlotTimeFmt_None),
+ ImPlotDateTimeFmt(ImPlotDateFmt_Yr, ImPlotTimeFmt_None)
+};
+
+static const ImPlotDateTimeFmt TimeFormatMouseCursor[ImPlotTimeUnit_COUNT] = {
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_Us),
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_SUs),
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_SMs),
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_HrMinS),
+ ImPlotDateTimeFmt(ImPlotDateFmt_None, ImPlotTimeFmt_HrMin),
+ ImPlotDateTimeFmt(ImPlotDateFmt_DayMo, ImPlotTimeFmt_Hr),
+ ImPlotDateTimeFmt(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),
+ ImPlotDateTimeFmt(ImPlotDateFmt_MoYr, ImPlotTimeFmt_None)
+};
+
+inline ImPlotDateTimeFmt GetDateTimeFmt(const ImPlotDateTimeFmt* ctx, ImPlotTimeUnit idx) {
+ ImPlotStyle& style = GetStyle();
+ ImPlotDateTimeFmt fmt = ctx[idx];
+ fmt.UseISO8601 = style.UseISO8601;
+ fmt.Use24HourClock = style.Use24HourClock;
+ return fmt;
+}
+
+void AddTicksTime(const ImPlotRange& range, float plot_width, ImPlotTickCollection& ticks) {
+ // get units for level 0 and level 1 labels
+ const ImPlotTimeUnit unit0 = GetUnitForRange(range.Size() / (plot_width / 100)); // level = 0 (top)
+ const ImPlotTimeUnit unit1 = unit0 + 1; // level = 1 (bottom)
+ // get time format specs
+ const ImPlotDateTimeFmt fmt0 = GetDateTimeFmt(TimeFormatLevel0, unit0);
+ const ImPlotDateTimeFmt fmt1 = GetDateTimeFmt(TimeFormatLevel1, unit1);
+ const ImPlotDateTimeFmt fmtf = GetDateTimeFmt(TimeFormatLevel1First, unit1);
+ // min max times
+ const ImPlotTime t_min = ImPlotTime::FromDouble(range.Min);
+ const ImPlotTime t_max = ImPlotTime::FromDouble(range.Max);
+ // maximum allowable density of labels
+ const float max_density = 0.5f;
+ // book keeping
+ const char* last_major = NULL;
+ if (unit0 != ImPlotTimeUnit_Yr) {
+ // pixels per major (level 1) division
+ const float pix_per_major_div = plot_width / (float)(range.Size() / TimeUnitSpans[unit1]);
+ // nominal pixels taken up by labels
+ const float fmt0_width = GetDateTimeWidth(fmt0);
+ const float fmt1_width = GetDateTimeWidth(fmt1);
+ const float fmtf_width = GetDateTimeWidth(fmtf);
+ // the maximum number of minor (level 0) labels that can fit between major (level 1) divisions
+ const int minor_per_major = (int)(max_density * pix_per_major_div / fmt0_width);
+ // the minor step size (level 0)
+ const int step = GetTimeStep(minor_per_major, unit0);
+ // generate ticks
+ ImPlotTime t1 = FloorTime(ImPlotTime::FromDouble(range.Min), unit1);
+ while (t1 < t_max) {
+ // get next major
+ const ImPlotTime t2 = AddTime(t1, unit1, 1);
+ // add major tick
+ if (t1 >= t_min && t1 <= t_max) {
+ // minor level 0 tick
+ ImPlotTick tick_min(t1.ToDouble(),true,true);
+ tick_min.Level = 0;
+ LabelTickTime(tick_min,ticks.TextBuffer,t1,fmt0);
+ ticks.Append(tick_min);
+ // major level 1 tick
+ ImPlotTick tick_maj(t1.ToDouble(),true,true);
+ tick_maj.Level = 1;
+ LabelTickTime(tick_maj,ticks.TextBuffer,t1, last_major == NULL ? fmtf : fmt1);
+ const char* this_major = ticks.TextBuffer.Buf.Data + tick_maj.TextOffset;
+ if (last_major && TimeLabelSame(last_major,this_major))
+ tick_maj.ShowLabel = false;
+ last_major = this_major;
+ ticks.Append(tick_maj);
+ }
+ // add minor ticks up until next major
+ if (minor_per_major > 1 && (t_min <= t2 && t1 <= t_max)) {
+ ImPlotTime t12 = AddTime(t1, unit0, step);
+ while (t12 < t2) {
+ float px_to_t2 = (float)((t2 - t12).ToDouble()/range.Size()) * plot_width;
+ if (t12 >= t_min && t12 <= t_max) {
+ ImPlotTick tick(t12.ToDouble(),false,px_to_t2 >= fmt0_width);
+ tick.Level = 0;
+ LabelTickTime(tick,ticks.TextBuffer,t12,fmt0);
+ ticks.Append(tick);
+ if (last_major == NULL && px_to_t2 >= fmt0_width && px_to_t2 >= (fmt1_width + fmtf_width) / 2) {
+ ImPlotTick tick_maj(t12.ToDouble(),true,true);
+ tick_maj.Level = 1;
+ LabelTickTime(tick_maj,ticks.TextBuffer,t12,fmtf);
+ last_major = ticks.TextBuffer.Buf.Data + tick_maj.TextOffset;
+ ticks.Append(tick_maj);
+ }
+ }
+ t12 = AddTime(t12, unit0, step);
+ }
+ }
+ t1 = t2;
+ }
+ }
+ else {
+ const ImPlotDateTimeFmt fmty = GetDateTimeFmt(TimeFormatLevel0, ImPlotTimeUnit_Yr);
+ const float label_width = GetDateTimeWidth(fmty);
+ const int max_labels = (int)(max_density * plot_width / label_width);
+ const int year_min = GetYear(t_min);
+ const int year_max = GetYear(CeilTime(t_max, ImPlotTimeUnit_Yr));
+ const double nice_range = NiceNum((year_max - year_min)*0.99,false);
+ const double interval = NiceNum(nice_range / (max_labels - 1), true);
+ const int graphmin = (int)(floor(year_min / interval) * interval);
+ const int graphmax = (int)(ceil(year_max / interval) * interval);
+ const int step = (int)interval <= 0 ? 1 : (int)interval;
+
+ for (int y = graphmin; y < graphmax; y += step) {
+ ImPlotTime t = MakeTime(y);
+ if (t >= t_min && t <= t_max) {
+ ImPlotTick tick(t.ToDouble(), true, true);
+ tick.Level = 0;
+ LabelTickTime(tick, ticks.TextBuffer, t, fmty);
+ ticks.Append(tick);
+ }
+ }
+ }
+}
+
+//-----------------------------------------------------------------------------
+// Axis Utils
+//-----------------------------------------------------------------------------
+
+static inline int AxisPrecision(const ImPlotAxis& axis, const ImPlotTickCollection& ticks) {
+ const double range = ticks.Size > 1 ? (ticks.Ticks[1].PlotPos - ticks.Ticks[0].PlotPos) : axis.Range.Size();
+ return Precision(range);
+}
+
+static inline double RoundAxisValue(const ImPlotAxis& axis, const ImPlotTickCollection& ticks, double value) {
+ return RoundTo(value, AxisPrecision(axis,ticks));
+}
+
+int LabelAxisValue(const ImPlotAxis& axis, const ImPlotTickCollection& ticks, double value, char* buff, int size) {
+ ImPlotContext& gp = *GImPlot;
+ if (ImHasFlag(axis.Flags, ImPlotAxisFlags_Time)) {
+ ImPlotTimeUnit unit = (axis.Orientation == ImPlotOrientation_Horizontal)
+ ? GetUnitForRange(axis.Range.Size() / (gp.CurrentPlot->PlotRect.GetWidth() / 100))
+ : GetUnitForRange(axis.Range.Size() / (gp.CurrentPlot->PlotRect.GetHeight() / 100));
+ return FormatDateTime(ImPlotTime::FromDouble(value), buff, size, GetDateTimeFmt(TimeFormatMouseCursor, unit));
+ }
+ else {
+ double range = ticks.Size > 1 ? (ticks.Ticks[1].PlotPos - ticks.Ticks[0].PlotPos) : axis.Range.Size();
+ return snprintf(buff, size, "%.*f", Precision(range), value);
+ }
+}
+
+void UpdateAxisColors(int axis_flag, ImPlotAxis* axis) {
+ const ImVec4 col_label = GetStyleColorVec4(axis_flag);
+ const ImVec4 col_grid = GetStyleColorVec4(axis_flag + 1);
+ axis->ColorMaj = ImGui::GetColorU32(col_grid);
+ axis->ColorMin = ImGui::GetColorU32(col_grid*ImVec4(1,1,1,GImPlot->Style.MinorAlpha));
+ axis->ColorTxt = ImGui::GetColorU32(col_label);
+}
+
+//-----------------------------------------------------------------------------
+// RENDERING
+//-----------------------------------------------------------------------------
+
+static inline void RenderGridLinesX(ImDrawList& DrawList, const ImPlotTickCollection& ticks, const ImRect& rect, ImU32 col_maj, ImU32 col_min, float size_maj, float size_min) {
+ const float density = ticks.Size / rect.GetWidth();
+ ImVec4 col_min4 = ImGui::ColorConvertU32ToFloat4(col_min);
+ col_min4.w *= ImClamp(ImRemap(density, 0.1f, 0.2f, 1.0f, 0.0f), 0.0f, 1.0f);
+ col_min = ImGui::ColorConvertFloat4ToU32(col_min4);
+ for (int t = 0; t < ticks.Size; t++) {
+ const ImPlotTick& xt = ticks.Ticks[t];
+ if (xt.Level == 0) {
+ if (xt.Major)
+ DrawList.AddLine(ImVec2(xt.PixelPos, rect.Min.y), ImVec2(xt.PixelPos, rect.Max.y), col_maj, size_maj);
+ else if (density < 0.2f)
+ DrawList.AddLine(ImVec2(xt.PixelPos, rect.Min.y), ImVec2(xt.PixelPos, rect.Max.y), col_min, size_min);
+ }
+ }
+}
+
+static inline void RenderGridLinesY(ImDrawList& DrawList, const ImPlotTickCollection& ticks, const ImRect& rect, ImU32 col_maj, ImU32 col_min, float size_maj, float size_min) {
+ const float density = ticks.Size / rect.GetHeight();
+ ImVec4 col_min4 = ImGui::ColorConvertU32ToFloat4(col_min);
+ col_min4.w *= ImClamp(ImRemap(density, 0.1f, 0.2f, 1.0f, 0.0f), 0.0f, 1.0f);
+ col_min = ImGui::ColorConvertFloat4ToU32(col_min4);
+ for (int t = 0; t < ticks.Size; t++) {
+ const ImPlotTick& yt = ticks.Ticks[t];
+ if (yt.Major)
+ DrawList.AddLine(ImVec2(rect.Min.x, yt.PixelPos), ImVec2(rect.Max.x, yt.PixelPos), col_maj, size_maj);
+ else if (density < 0.2f)
+ DrawList.AddLine(ImVec2(rect.Min.x, yt.PixelPos), ImVec2(rect.Max.x, yt.PixelPos), col_min, size_min);
+ }
+}
+
+static inline void RenderSelectionRect(ImDrawList& DrawList, const ImVec2& p_min, const ImVec2& p_max, const ImVec4& col) {
+ const ImU32 col_bg = ImGui::GetColorU32(col * ImVec4(1,1,1,0.25f));
+ const ImU32 col_bd = ImGui::GetColorU32(col);
+ DrawList.AddRectFilled(p_min, p_max, col_bg);
+ DrawList.AddRect(p_min, p_max, col_bd);
+}
+
+//-----------------------------------------------------------------------------
+// BeginPlot()
+//-----------------------------------------------------------------------------
+
+bool BeginPlot(const char* title, const char* x_label, const char* y1_label, const ImVec2& size,
+ ImPlotFlags flags, ImPlotAxisFlags x_flags, ImPlotAxisFlags y1_flags, ImPlotAxisFlags y2_flags, ImPlotAxisFlags y3_flags,
+ const char* y2_label, const char* y3_label)
+{
+ IM_ASSERT_USER_ERROR(GImPlot != NULL, "No current context. Did you call ImPlot::CreateContext() or ImPlot::SetCurrentContext()?");
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot == NULL, "Mismatched BeginPlot()/EndPlot()!");
+ IM_ASSERT_USER_ERROR(!(ImHasFlag(x_flags, ImPlotAxisFlags_Time) && ImHasFlag(x_flags, ImPlotAxisFlags_LogScale)), "ImPlotAxisFlags_Time and ImPlotAxisFlags_LogScale cannot be enabled at the same time!");
+ IM_ASSERT_USER_ERROR(!ImHasFlag(y1_flags, ImPlotAxisFlags_Time), "Y axes cannot display time formatted labels!");
+
+ // FRONT MATTER -----------------------------------------------------------
+
+ ImGuiContext &G = *GImGui;
+ ImGuiWindow * Window = G.CurrentWindow;
+ if (Window->SkipItems) {
+ Reset(GImPlot);
+ return false;
+ }
+
+ const ImGuiID ID = Window->GetID(title);
+ const ImGuiStyle &Style = G.Style;
+ const ImGuiIO & IO = ImGui::GetIO();
+
+ bool just_created = gp.Plots.GetByKey(ID) == NULL;
+ gp.CurrentPlot = gp.Plots.GetOrAddByKey(ID);
+ gp.CurrentPlot->ID = ID;
+ ImPlotPlot &plot = *gp.CurrentPlot;
+
+ plot.CurrentYAxis = 0;
+
+ if (just_created) {
+ plot.Flags = flags;
+ plot.XAxis.Flags = x_flags;
+ plot.YAxis[0].Flags = y1_flags;
+ plot.YAxis[1].Flags = y2_flags;
+ plot.YAxis[2].Flags = y3_flags;
+ }
+ else {
+ // TODO: Check which individual flags changed, and only reset those!
+ // There's probably an easy bit mask trick I'm not aware of.
+ if (flags != plot.PreviousFlags)
+ plot.Flags = flags;
+ if (x_flags != plot.XAxis.PreviousFlags)
+ plot.XAxis.Flags = x_flags;
+ if (y1_flags != plot.YAxis[0].PreviousFlags)
+ plot.YAxis[0].Flags = y1_flags;
+ if (y2_flags != plot.YAxis[1].PreviousFlags)
+ plot.YAxis[1].Flags = y2_flags;
+ if (y3_flags != plot.YAxis[2].PreviousFlags)
+ plot.YAxis[2].Flags = y3_flags;
+ }
+
+ plot.PreviousFlags = flags;
+ plot.XAxis.PreviousFlags = x_flags;
+ plot.YAxis[0].PreviousFlags = y1_flags;
+ plot.YAxis[1].PreviousFlags = y2_flags;
+ plot.YAxis[2].PreviousFlags = y3_flags;
+
+ // capture scroll with a child region
+ if (!ImHasFlag(plot.Flags, ImPlotFlags_NoChild)) {
+ ImGui::BeginChild(title, ImVec2(size.x == 0 ? gp.Style.PlotDefaultSize.x : size.x, size.y == 0 ? gp.Style.PlotDefaultSize.y : size.y), false, ImGuiWindowFlags_NoScrollbar);
+ Window = ImGui::GetCurrentWindow();
+ Window->ScrollMax.y = 1.0f;
+ gp.ChildWindowMade = true;
+ }
+ else {
+ gp.ChildWindowMade = false;
+ }
+
+ ImDrawList &DrawList = *Window->DrawList;
+
+ // NextPlotData -----------------------------------------------------------
+
+ // linked axes
+ plot.XAxis.LinkedMin = gp.NextPlotData.LinkedXmin;
+ plot.XAxis.LinkedMax = gp.NextPlotData.LinkedXmax;
+ PullLinkedAxis(plot.XAxis);
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i) {
+ plot.YAxis[i].LinkedMin = gp.NextPlotData.LinkedYmin[i];
+ plot.YAxis[i].LinkedMax = gp.NextPlotData.LinkedYmax[i];
+ PullLinkedAxis(plot.YAxis[i]);
+ }
+
+ if (gp.NextPlotData.HasXRange) {
+ if (!plot.Initialized || gp.NextPlotData.XRangeCond == ImGuiCond_Always)
+ plot.XAxis.SetRange(gp.NextPlotData.XRange);
+ }
+
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (gp.NextPlotData.HasYRange[i]) {
+ if (!plot.Initialized || gp.NextPlotData.YRangeCond[i] == ImGuiCond_Always)
+ plot.YAxis[i].SetRange(gp.NextPlotData.YRange[i]);
+ }
+ }
+
+ // Initialization ------------------------------------------------------------
+
+ if (!plot.Initialized) {
+ if (!ImHasFlag(plot.XAxis.Flags,ImPlotAxisFlags_NoInitialFit) && !gp.NextPlotData.HasXRange && !gp.NextPlotData.LinkedXmin && !gp.NextPlotData.LinkedXmax)
+ gp.FitThisFrame = gp.FitX = true;
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i) {
+ if (!ImHasFlag(plot.YAxis[i].Flags,ImPlotAxisFlags_NoInitialFit) && !gp.NextPlotData.HasYRange[i] && !gp.NextPlotData.LinkedYmin[i] && !gp.NextPlotData.LinkedYmax[i])
+ gp.FitThisFrame = gp.FitY[i] = true;
+ }
+ }
+
+ // AXIS STATES ------------------------------------------------------------
+ plot.XAxis.HasRange = gp.NextPlotData.HasXRange; plot.XAxis.RangeCond = gp.NextPlotData.XRangeCond; plot.XAxis.Present = true;
+ plot.YAxis[0].HasRange = gp.NextPlotData.HasYRange[0]; plot.YAxis[0].RangeCond = gp.NextPlotData.YRangeCond[0]; plot.YAxis[0].Present = true;
+ plot.YAxis[1].HasRange = gp.NextPlotData.HasYRange[1]; plot.YAxis[1].RangeCond = gp.NextPlotData.YRangeCond[1]; plot.YAxis[1].Present = ImHasFlag(plot.Flags, ImPlotFlags_YAxis2);
+ plot.YAxis[2].HasRange = gp.NextPlotData.HasYRange[2]; plot.YAxis[2].RangeCond = gp.NextPlotData.YRangeCond[2]; plot.YAxis[2].Present = ImHasFlag(plot.Flags, ImPlotFlags_YAxis3);
+
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i) {
+ if (!ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_LogScale) && !ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_LogScale))
+ gp.Scales[i] = ImPlotScale_LinLin;
+ else if (ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_LogScale) && !ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_LogScale))
+ gp.Scales[i] = ImPlotScale_LogLin;
+ else if (!ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_LogScale) && ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_LogScale))
+ gp.Scales[i] = ImPlotScale_LinLog;
+ else if (ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_LogScale) && ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_LogScale))
+ gp.Scales[i] = ImPlotScale_LogLog;
+ }
+
+ // constraints
+ plot.XAxis.Constrain();
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i)
+ plot.YAxis[i].Constrain();
+
+ // constrain equal axes for primary x and y if not approximately equal
+ // constrains x to y since x pixel size depends on y labels width, and causes feedback loops in opposite case
+ if (ImHasFlag(plot.Flags, ImPlotFlags_Equal)) {
+ double xar = plot.XAxis.GetAspect();
+ double yar = plot.YAxis[0].GetAspect();
+ if (!ImAlmostEqual(xar,yar) && !plot.YAxis[0].IsInputLocked())
+ plot.XAxis.SetAspect(yar);
+ }
+
+ // AXIS COLORS -----------------------------------------------------------------
+
+ UpdateAxisColors(ImPlotCol_XAxis, &plot.XAxis);
+ UpdateAxisColors(ImPlotCol_YAxis, &plot.YAxis[0]);
+ UpdateAxisColors(ImPlotCol_YAxis2, &plot.YAxis[1]);
+ UpdateAxisColors(ImPlotCol_YAxis3, &plot.YAxis[2]);
+
+ // BB, PADDING, HOVER -----------------------------------------------------------
+
+ // frame
+ ImVec2 frame_size = ImGui::CalcItemSize(size, gp.Style.PlotDefaultSize.x, gp.Style.PlotDefaultSize.y);
+ if (frame_size.x < gp.Style.PlotMinSize.x && size.x < 0.0f)
+ frame_size.x = gp.Style.PlotMinSize.x;
+ if (frame_size.y < gp.Style.PlotMinSize.y && size.y < 0.0f)
+ frame_size.y = gp.Style.PlotMinSize.y;
+ plot.FrameRect = ImRect(Window->DC.CursorPos, Window->DC.CursorPos + frame_size);
+ ImGui::ItemSize(plot.FrameRect);
+ if (!ImGui::ItemAdd(plot.FrameRect, ID, &plot.FrameRect)) {
+ Reset(GImPlot);
+ return false;
+ }
+ plot.FrameHovered = ImGui::ItemHoverable(plot.FrameRect, ID);
+ if (G.HoveredIdPreviousFrame != 0 && G.HoveredIdPreviousFrame != ID)
+ plot.FrameHovered = false;
+ ImGui::SetItemAllowOverlap();
+ ImGui::RenderFrame(plot.FrameRect.Min, plot.FrameRect.Max, GetStyleColorU32(ImPlotCol_FrameBg), true, Style.FrameRounding);
+
+ // canvas/axes bb
+ plot.CanvasRect = ImRect(plot.FrameRect.Min + gp.Style.PlotPadding, plot.FrameRect.Max - gp.Style.PlotPadding);
+ plot.AxesRect = plot.FrameRect;
+
+ // outside legend adjustments
+ if (!ImHasFlag(plot.Flags, ImPlotFlags_NoLegend) && plot.GetLegendCount() > 0 && plot.LegendOutside) {
+ const ImVec2 legend_size = CalcLegendSize(plot, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, plot.LegendOrientation);
+ const bool west = ImHasFlag(plot.LegendLocation, ImPlotLocation_West) && !ImHasFlag(plot.LegendLocation, ImPlotLocation_East);
+ const bool east = ImHasFlag(plot.LegendLocation, ImPlotLocation_East) && !ImHasFlag(plot.LegendLocation, ImPlotLocation_West);
+ const bool north = ImHasFlag(plot.LegendLocation, ImPlotLocation_North) && !ImHasFlag(plot.LegendLocation, ImPlotLocation_South);
+ const bool south = ImHasFlag(plot.LegendLocation, ImPlotLocation_South) && !ImHasFlag(plot.LegendLocation, ImPlotLocation_North);
+ const bool horz = plot.LegendOrientation == ImPlotOrientation_Horizontal;
+ if ((west && !horz) || (west && horz && !north && !south)) {
+ plot.CanvasRect.Min.x += (legend_size.x + gp.Style.LegendPadding.x);
+ plot.AxesRect.Min.x += (legend_size.x + gp.Style.PlotPadding.x);
+ }
+ if ((east && !horz) || (east && horz && !north && !south)) {
+ plot.CanvasRect.Max.x -= (legend_size.x + gp.Style.LegendPadding.x);
+ plot.AxesRect.Max.x -= (legend_size.x + gp.Style.PlotPadding.x);
+ }
+ if ((north && horz) || (north && !horz && !west && !east)) {
+ plot.CanvasRect.Min.y += (legend_size.y + gp.Style.LegendPadding.y);
+ plot.AxesRect.Min.y += (legend_size.y + gp.Style.PlotPadding.y);
+ }
+ if ((south && horz) || (south && !horz && !west && !east)) {
+ plot.CanvasRect.Max.y -= (legend_size.y + gp.Style.LegendPadding.y);
+ plot.AxesRect.Max.y -= (legend_size.y + gp.Style.PlotPadding.y);
+ }
+ }
+
+ gp.RenderX = (!ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_NoGridLines) ||
+ !ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_NoTickMarks) ||
+ !ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_NoTickLabels));
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ gp.RenderY[i] = plot.YAxis[i].Present &&
+ (!ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_NoGridLines) ||
+ !ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_NoTickMarks) ||
+ !ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_NoTickLabels));
+ }
+
+ // plot bb
+
+ // (1) calc top/bot padding and plot height
+ ImVec2 title_size(0.0f, 0.0f);
+ const float txt_height = ImGui::GetTextLineHeight();
+ if (!ImHasFlag(plot.Flags, ImPlotFlags_NoTitle)){
+ title_size = ImGui::CalcTextSize(title, NULL, true);
+ }
+
+ const bool show_x_label = x_label && !ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_NoLabel);
+
+ const float pad_top = title_size.x > 0.0f ? txt_height + gp.Style.LabelPadding.y : 0;
+ const float pad_bot = (plot.XAxis.IsLabeled() ? ImMax(txt_height, gp.XTicks.MaxHeight) + gp.Style.LabelPadding.y + (plot.XAxis.IsTime() ? txt_height + gp.Style.LabelPadding.y : 0) : 0)
+ + (show_x_label ? txt_height + gp.Style.LabelPadding.y : 0);
+
+ const float plot_height = plot.CanvasRect.GetHeight() - pad_top - pad_bot;
+
+ // (2) get y tick labels (needed for left/right pad)
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (gp.RenderY[i] && gp.NextPlotData.ShowDefaultTicksY[i]) {
+ if (ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_LogScale))
+ AddTicksLogarithmic(plot.YAxis[i].Range, plot_height, ImPlotOrientation_Vertical, gp.YTicks[i], GetFormatY(i));
+ else
+ AddTicksDefault(plot.YAxis[i].Range, plot_height, ImPlotOrientation_Vertical, gp.YTicks[i], GetFormatY(i));
+ }
+ }
+
+ // (3) calc left/right pad
+ const bool show_y1_label = y1_label && !ImHasFlag(plot.YAxis[0].Flags, ImPlotAxisFlags_NoLabel);
+ const bool show_y2_label = y2_label && !ImHasFlag(plot.YAxis[1].Flags, ImPlotAxisFlags_NoLabel);
+ const bool show_y3_label = y3_label && !ImHasFlag(plot.YAxis[2].Flags, ImPlotAxisFlags_NoLabel);
+
+ const float pad_left = (show_y1_label ? txt_height + gp.Style.LabelPadding.x : 0)
+ + (plot.YAxis[0].IsLabeled() ? gp.YTicks[0].MaxWidth + gp.Style.LabelPadding.x : 0);
+ const float pad_right = ((plot.YAxis[1].Present && plot.YAxis[1].IsLabeled()) ? gp.YTicks[1].MaxWidth + gp.Style.LabelPadding.x : 0)
+ + ((plot.YAxis[1].Present && show_y2_label) ? txt_height + gp.Style.LabelPadding.x : 0)
+ + ((plot.YAxis[1].Present && plot.YAxis[2].Present) ? gp.Style.LabelPadding.x + gp.Style.MinorTickLen.y : 0)
+ + ((plot.YAxis[2].Present && plot.YAxis[2].IsLabeled()) ? gp.YTicks[2].MaxWidth + gp.Style.LabelPadding.x : 0)
+ + ((plot.YAxis[2].Present && show_y3_label) ? txt_height + gp.Style.LabelPadding.x : 0);
+
+ const float plot_width = plot.CanvasRect.GetWidth() - pad_left - pad_right;
+
+ // (4) get x ticks
+ if (gp.RenderX && gp.NextPlotData.ShowDefaultTicksX) {
+ if (plot.XAxis.IsTime())
+ AddTicksTime(plot.XAxis.Range, plot_width, gp.XTicks);
+ else if (ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_LogScale))
+ AddTicksLogarithmic(plot.XAxis.Range, plot_width, ImPlotOrientation_Horizontal, gp.XTicks, GetFormatX());
+ else
+ AddTicksDefault(plot.XAxis.Range, plot_width, ImPlotOrientation_Horizontal, gp.XTicks, GetFormatX());
+ }
+
+ // (5) calc plot bb
+ plot.PlotRect = ImRect(plot.CanvasRect.Min + ImVec2(pad_left, pad_top), plot.CanvasRect.Max - ImVec2(pad_right, pad_bot));
+ plot.PlotHovered = plot.FrameHovered && plot.PlotRect.Contains(IO.MousePos);
+
+ // x axis region bb and hover
+ plot.XAxis.HoverRect = ImRect(plot.PlotRect.GetBL(), ImVec2(plot.PlotRect.Max.x, plot.AxesRect.Max.y));
+ plot.XAxis.ExtHovered = plot.XAxis.HoverRect.Contains(IO.MousePos);
+ plot.XAxis.AllHovered = plot.XAxis.ExtHovered || plot.PlotHovered;
+
+ // axis label reference
+ gp.YAxisReference[0] = plot.PlotRect.Min.x;
+ gp.YAxisReference[1] = plot.PlotRect.Max.x;
+ gp.YAxisReference[2] = !plot.YAxis[1].Present ? plot.PlotRect.Max.x : gp.YAxisReference[1]
+ + (plot.YAxis[1].IsLabeled() ? gp.Style.LabelPadding.x + gp.YTicks[1].MaxWidth : 0)
+ + (show_y2_label ? txt_height + gp.Style.LabelPadding.x : 0)
+ + gp.Style.LabelPadding.x + gp.Style.MinorTickLen.y;
+
+ // y axis regions bb and hover
+ plot.YAxis[0].HoverRect = ImRect(ImVec2(plot.AxesRect.Min.x, plot.PlotRect.Min.y), ImVec2(plot.PlotRect.Min.x, plot.PlotRect.Max.y));
+ plot.YAxis[1].HoverRect = plot.YAxis[2].Present
+ ? ImRect(plot.PlotRect.GetTR(), ImVec2(gp.YAxisReference[2], plot.PlotRect.Max.y))
+ : ImRect(plot.PlotRect.GetTR(), ImVec2(plot.AxesRect.Max.x, plot.PlotRect.Max.y));
+
+ plot.YAxis[2].HoverRect = ImRect(ImVec2(gp.YAxisReference[2], plot.PlotRect.Min.y), ImVec2(plot.AxesRect.Max.x, plot.PlotRect.Max.y));
+
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i) {
+ plot.YAxis[i].ExtHovered = plot.YAxis[i].Present && plot.YAxis[i].HoverRect.Contains(IO.MousePos);
+ plot.YAxis[i].AllHovered = plot.YAxis[i].ExtHovered || plot.PlotHovered;
+ }
+
+ const bool any_hov_y_axis_region = plot.YAxis[0].AllHovered || plot.YAxis[1].AllHovered || plot.YAxis[2].AllHovered;
+
+ bool hov_query = false;
+ if (plot.PlotHovered && plot.Queried && !plot.Querying) {
+ ImRect bb_query = plot.QueryRect;
+ bb_query.Min += plot.PlotRect.Min;
+ bb_query.Max += plot.PlotRect.Min;
+ hov_query = bb_query.Contains(IO.MousePos);
+ }
+
+ // AXIS ASPECT RATIOS
+ plot.XAxis.Pixels = plot.PlotRect.GetWidth();
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i)
+ plot.YAxis[i].Pixels = plot.PlotRect.GetHeight();
+
+ // QUERY DRAG -------------------------------------------------------------
+ if (plot.DraggingQuery && (IO.MouseReleased[gp.InputMap.PanButton] || !IO.MouseDown[gp.InputMap.PanButton])) {
+ plot.DraggingQuery = false;
+ }
+ if (plot.DraggingQuery) {
+ ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeAll);
+ plot.QueryRect.Min += IO.MouseDelta;
+ plot.QueryRect.Max += IO.MouseDelta;
+ }
+ if (plot.PlotHovered && hov_query && !plot.DraggingQuery && !plot.Selecting && !plot.LegendHovered) {
+ ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeAll);
+ const bool any_y_dragging = plot.YAxis[0].Dragging || plot.YAxis[1].Dragging || plot.YAxis[2].Dragging;
+ if (IO.MouseDown[gp.InputMap.PanButton] && !plot.XAxis.Dragging && !any_y_dragging) {
+ plot.DraggingQuery = true;
+ }
+ }
+
+ // DRAG INPUT -------------------------------------------------------------
+
+ const bool axis_equal = ImHasFlag(plot.Flags, ImPlotFlags_Equal);
+
+ // end drags
+ if (plot.XAxis.Dragging && (IO.MouseReleased[gp.InputMap.PanButton] || !IO.MouseDown[gp.InputMap.PanButton])) {
+ plot.XAxis.Dragging = false;
+ G.IO.MouseDragMaxDistanceSqr[0] = 0;
+ }
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (plot.YAxis[i].Dragging && (IO.MouseReleased[gp.InputMap.PanButton] || !IO.MouseDown[gp.InputMap.PanButton])) {
+ plot.YAxis[i].Dragging = false;
+ G.IO.MouseDragMaxDistanceSqr[0] = 0;
+ }
+ }
+ const bool any_y_dragging = plot.YAxis[0].Dragging || plot.YAxis[1].Dragging || plot.YAxis[2].Dragging;
+ bool drag_in_progress = plot.XAxis.Dragging || any_y_dragging;
+ // do drag
+ if (drag_in_progress) {
+ UpdateTransformCache();
+ bool equal_dragged = false;
+ // special case for axis equal and both x and y0 hovered
+ if (axis_equal && !plot.XAxis.IsInputLocked() && plot.XAxis.Dragging && !plot.YAxis[0].IsInputLocked() && plot.YAxis[0].Dragging) {
+ ImPlotPoint plot_tl = PixelsToPlot(plot.PlotRect.Min - IO.MouseDelta, 0);
+ ImPlotPoint plot_br = PixelsToPlot(plot.PlotRect.Max - IO.MouseDelta, 0);
+ plot.XAxis.SetMin(plot.XAxis.IsInverted() ? plot_br.x : plot_tl.x);
+ plot.XAxis.SetMax(plot.XAxis.IsInverted() ? plot_tl.x : plot_br.x);
+ plot.YAxis[0].SetMin(plot.YAxis[0].IsInverted() ? plot_tl.y : plot_br.y);
+ plot.YAxis[0].SetMax(plot.YAxis[0].IsInverted() ? plot_br.y : plot_tl.y);
+ double xar = plot.XAxis.GetAspect();
+ double yar = plot.YAxis[0].GetAspect();
+ if (!ImAlmostEqual(xar,yar) && !plot.YAxis[0].IsInputLocked())
+ plot.XAxis.SetAspect(yar);
+ equal_dragged = true;
+ }
+ if (!plot.XAxis.IsInputLocked() && plot.XAxis.Dragging && !equal_dragged) {
+ ImPlotPoint plot_tl = PixelsToPlot(plot.PlotRect.Min - IO.MouseDelta, 0);
+ ImPlotPoint plot_br = PixelsToPlot(plot.PlotRect.Max - IO.MouseDelta, 0);
+ plot.XAxis.SetMin(plot.XAxis.IsInverted() ? plot_br.x : plot_tl.x);
+ plot.XAxis.SetMax(plot.XAxis.IsInverted() ? plot_tl.x : plot_br.x);
+ if (axis_equal)
+ plot.YAxis[0].SetAspect(plot.XAxis.GetAspect());
+ }
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (!plot.YAxis[i].IsInputLocked() && plot.YAxis[i].Dragging && !(i == 0 && equal_dragged)) {
+ ImPlotPoint plot_tl = PixelsToPlot(plot.PlotRect.Min - IO.MouseDelta, i);
+ ImPlotPoint plot_br = PixelsToPlot(plot.PlotRect.Max - IO.MouseDelta, i);
+ plot.YAxis[i].SetMin(plot.YAxis[i].IsInverted() ? plot_tl.y : plot_br.y);
+ plot.YAxis[i].SetMax(plot.YAxis[i].IsInverted() ? plot_br.y : plot_tl.y);
+ if (i == 0 && axis_equal)
+ plot.XAxis.SetAspect(plot.YAxis[0].GetAspect());
+ }
+ }
+ // Set the mouse cursor based on which axes are moving.
+ int direction = 0;
+ if (!plot.XAxis.IsInputLocked() && plot.XAxis.Dragging) {
+ direction |= (1 << 1);
+ }
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (!plot.YAxis[i].Present) { continue; }
+ if (!plot.YAxis[i].IsInputLocked() && plot.YAxis[i].Dragging) {
+ direction |= (1 << 2);
+ break;
+ }
+ }
+ if (IO.MouseDragMaxDistanceSqr[0] > 5) {
+ if (direction == 0)
+ ImGui::SetMouseCursor(ImGuiMouseCursor_NotAllowed);
+ else if (direction == (1 << 1))
+ ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
+ else if (direction == (1 << 2))
+ ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeNS);
+ else
+ ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeAll);
+ }
+ }
+ // start drag
+ if (!drag_in_progress && plot.FrameHovered && IO.MouseClicked[gp.InputMap.PanButton] && ImHasFlag(IO.KeyMods, gp.InputMap.PanMod) && !plot.Selecting && !plot.LegendHovered && !hov_query && !plot.DraggingQuery) {
+ if (plot.XAxis.AllHovered) {
+ plot.XAxis.Dragging = true;
+ }
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (plot.YAxis[i].AllHovered) {
+ plot.YAxis[i].Dragging = true;
+ }
+ }
+ }
+
+ // SCROLL INPUT -----------------------------------------------------------
+
+ if (plot.FrameHovered && (plot.XAxis.AllHovered || any_hov_y_axis_region) && IO.MouseWheel != 0) {
+ UpdateTransformCache();
+ float zoom_rate = IMPLOT_ZOOM_RATE;
+ if (IO.MouseWheel > 0)
+ zoom_rate = (-zoom_rate) / (1.0f + (2.0f * zoom_rate));
+ float tx = ImRemap(IO.MousePos.x, plot.PlotRect.Min.x, plot.PlotRect.Max.x, 0.0f, 1.0f);
+ float ty = ImRemap(IO.MousePos.y, plot.PlotRect.Min.y, plot.PlotRect.Max.y, 0.0f, 1.0f);
+ bool equal_zoomed = false;
+ // special case for axis equal and both x and y0 hovered
+ if (axis_equal && plot.XAxis.AllHovered && !plot.XAxis.IsInputLocked() && plot.YAxis[0].AllHovered && !plot.YAxis[0].IsInputLocked()) {
+ const ImPlotPoint& plot_tl = PixelsToPlot(plot.PlotRect.Min - plot.PlotRect.GetSize() * ImVec2(tx * zoom_rate, ty * zoom_rate), 0);
+ const ImPlotPoint& plot_br = PixelsToPlot(plot.PlotRect.Max + plot.PlotRect.GetSize() * ImVec2((1 - tx) * zoom_rate, (1 - ty) * zoom_rate), 0);
+ plot.XAxis.SetMin(plot.XAxis.IsInverted() ? plot_br.x : plot_tl.x);
+ plot.XAxis.SetMax(plot.XAxis.IsInverted() ? plot_tl.x : plot_br.x);
+ plot.YAxis[0].SetMin(plot.YAxis[0].IsInverted() ? plot_tl.y : plot_br.y);
+ plot.YAxis[0].SetMax(plot.YAxis[0].IsInverted() ? plot_br.y : plot_tl.y);
+ double xar = plot.XAxis.GetAspect();
+ double yar = plot.YAxis[0].GetAspect();
+ if (!ImAlmostEqual(xar,yar) && !plot.YAxis[0].IsInputLocked())
+ plot.XAxis.SetAspect(yar);
+ equal_zoomed = true;
+ }
+ if (plot.XAxis.AllHovered && !plot.XAxis.IsInputLocked() && !equal_zoomed) {
+ const ImPlotPoint& plot_tl = PixelsToPlot(plot.PlotRect.Min - plot.PlotRect.GetSize() * ImVec2(tx * zoom_rate, ty * zoom_rate), 0);
+ const ImPlotPoint& plot_br = PixelsToPlot(plot.PlotRect.Max + plot.PlotRect.GetSize() * ImVec2((1 - tx) * zoom_rate, (1 - ty) * zoom_rate), 0);
+ plot.XAxis.SetMin(plot.XAxis.IsInverted() ? plot_br.x : plot_tl.x);
+ plot.XAxis.SetMax(plot.XAxis.IsInverted() ? plot_tl.x : plot_br.x);
+ if (axis_equal)
+ plot.YAxis[0].SetAspect(plot.XAxis.GetAspect());
+ }
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (plot.YAxis[i].AllHovered && !plot.YAxis[i].IsInputLocked() && !(i == 0 && equal_zoomed)) {
+ const ImPlotPoint& plot_tl = PixelsToPlot(plot.PlotRect.Min - plot.PlotRect.GetSize() * ImVec2(tx * zoom_rate, ty * zoom_rate), i);
+ const ImPlotPoint& plot_br = PixelsToPlot(plot.PlotRect.Max + plot.PlotRect.GetSize() * ImVec2((1 - tx) * zoom_rate, (1 - ty) * zoom_rate), i);
+ plot.YAxis[i].SetMin(plot.YAxis[i].IsInverted() ? plot_tl.y : plot_br.y);
+ plot.YAxis[i].SetMax(plot.YAxis[i].IsInverted() ? plot_br.y : plot_tl.y);
+ if (i == 0 && axis_equal)
+ plot.XAxis.SetAspect(plot.YAxis[0].GetAspect());
+ }
+ }
+ }
+
+ // BOX-SELECTION AND QUERY ------------------------------------------------
+
+ // begin selection
+ if (!ImHasFlag(plot.Flags, ImPlotFlags_NoBoxSelect) && plot.PlotHovered && IO.MouseClicked[gp.InputMap.BoxSelectButton] && ImHasFlag(IO.KeyMods, gp.InputMap.BoxSelectMod)) {
+ plot.Selecting = true;
+ plot.SelectStart = IO.MousePos;
+ plot.SelectRect = ImRect(0,0,0,0);
+ }
+ // update selection
+ if (plot.Selecting) {
+ UpdateTransformCache();
+ const ImVec2 d = plot.SelectStart - IO.MousePos;
+ const bool x_can_change = !ImHasFlag(IO.KeyMods,gp.InputMap.HorizontalMod) && ImFabs(d.x) > 2;
+ const bool y_can_change = !ImHasFlag(IO.KeyMods,gp.InputMap.VerticalMod) && ImFabs(d.y) > 2;
+ // confirm
+ if (IO.MouseReleased[gp.InputMap.BoxSelectButton] || !IO.MouseDown[gp.InputMap.BoxSelectButton]) {
+ if (!plot.XAxis.IsInputLocked() && x_can_change) {
+ ImPlotPoint p1 = PixelsToPlot(plot.SelectStart);
+ ImPlotPoint p2 = PixelsToPlot(IO.MousePos);
+ plot.XAxis.SetMin(ImMin(p1.x, p2.x));
+ plot.XAxis.SetMax(ImMax(p1.x, p2.x));
+ }
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (!plot.YAxis[i].IsInputLocked() && y_can_change) {
+ ImPlotPoint p1 = PixelsToPlot(plot.SelectStart, i);
+ ImPlotPoint p2 = PixelsToPlot(IO.MousePos, i);
+ plot.YAxis[i].SetMin(ImMin(p1.y, p2.y));
+ plot.YAxis[i].SetMax(ImMax(p1.y, p2.y));
+ }
+ }
+ if (x_can_change || y_can_change || (ImHasFlag(IO.KeyMods,gp.InputMap.HorizontalMod) && ImHasFlag(IO.KeyMods,gp.InputMap.VerticalMod)))
+ plot.ContextLocked = gp.InputMap.BoxSelectButton == gp.InputMap.ContextMenuButton;
+ plot.Selected = plot.Selecting = false;
+ }
+ // cancel
+ else if (IO.MouseClicked[gp.InputMap.BoxSelectCancelButton] || IO.MouseDown[gp.InputMap.BoxSelectCancelButton]) {
+ plot.Selected = plot.Selecting = false;
+ plot.ContextLocked = gp.InputMap.BoxSelectButton == gp.InputMap.ContextMenuButton;
+ }
+ else if (ImLengthSqr(d) > 4) {
+ // bad selection
+ if (plot.IsInputLocked()) {
+ ImGui::SetMouseCursor(ImGuiMouseCursor_NotAllowed);
+ plot.ContextLocked = gp.InputMap.BoxSelectButton == gp.InputMap.ContextMenuButton;
+ plot.Selected = false;
+ }
+ else {
+ // TODO: Handle only min or max locked cases
+ plot.SelectRect.Min.x = ImHasFlag(IO.KeyMods, gp.InputMap.HorizontalMod) || plot.XAxis.IsInputLocked() ? plot.PlotRect.Min.x : ImMin(plot.SelectStart.x, IO.MousePos.x);
+ plot.SelectRect.Max.x = ImHasFlag(IO.KeyMods, gp.InputMap.HorizontalMod) || plot.XAxis.IsInputLocked() ? plot.PlotRect.Max.x : ImMax(plot.SelectStart.x, IO.MousePos.x);
+ plot.SelectRect.Min.y = ImHasFlag(IO.KeyMods, gp.InputMap.VerticalMod) || plot.AllYInputLocked() ? plot.PlotRect.Min.y : ImMin(plot.SelectStart.y, IO.MousePos.y);
+ plot.SelectRect.Max.y = ImHasFlag(IO.KeyMods, gp.InputMap.VerticalMod) || plot.AllYInputLocked() ? plot.PlotRect.Max.y : ImMax(plot.SelectStart.y, IO.MousePos.y);
+ plot.SelectRect.Min -= plot.PlotRect.Min;
+ plot.SelectRect.Max -= plot.PlotRect.Min;
+ plot.Selected = true;
+ }
+ }
+ else {
+ plot.Selected = false;
+ }
+ }
+
+ // begin query
+ if (ImHasFlag(plot.Flags, ImPlotFlags_Query) && plot.PlotHovered && IO.MouseClicked[gp.InputMap.QueryButton] && ImHasFlag(IO.KeyMods, gp.InputMap.QueryMod)) {
+ plot.Querying = true;
+ plot.QueryStart = IO.MousePos;
+ plot.QueryRect = ImRect(0,0,0,0);
+ }
+ // update query
+ if (plot.Querying) {
+ UpdateTransformCache();
+ // confirm
+ if (IO.MouseReleased[gp.InputMap.QueryButton] || IO.MouseReleased[gp.InputMap.BoxSelectButton]) {
+ plot.Querying = false;
+ if (plot.QueryRect.GetWidth() > 2 && plot.QueryRect.GetHeight() > 2) {
+ plot.Queried = true;
+ plot.ContextLocked = gp.InputMap.BoxSelectButton == gp.InputMap.ContextMenuButton;
+ }
+ else
+ plot.Queried = false;
+ }
+ else {
+ plot.QueryRect.Min.x = ImHasFlag(IO.KeyMods, gp.InputMap.HorizontalMod) ? plot.PlotRect.Min.x : ImMin(plot.QueryStart.x, IO.MousePos.x);
+ plot.QueryRect.Max.x = ImHasFlag(IO.KeyMods, gp.InputMap.HorizontalMod) ? plot.PlotRect.Max.x : ImMax(plot.QueryStart.x, IO.MousePos.x);
+ plot.QueryRect.Min.y = ImHasFlag(IO.KeyMods, gp.InputMap.VerticalMod) ? plot.PlotRect.Min.y : ImMin(plot.QueryStart.y, IO.MousePos.y);
+ plot.QueryRect.Max.y = ImHasFlag(IO.KeyMods, gp.InputMap.VerticalMod) ? plot.PlotRect.Max.y : ImMax(plot.QueryStart.y, IO.MousePos.y);
+ plot.QueryRect.Min -= plot.PlotRect.Min;
+ plot.QueryRect.Max -= plot.PlotRect.Min;
+ plot.Queried = plot.QueryRect.GetWidth() > 2 && plot.QueryRect.GetHeight() > 2;
+ }
+ }
+
+ // switch select to query
+ if (ImHasFlag(plot.Flags, ImPlotFlags_Query) && plot.Selecting && ImHasFlag(IO.KeyMods,gp.InputMap.QueryToggleMod)) {
+ plot.Selecting = plot.Selected = false;
+ plot.Querying = plot.Queried = true;
+ plot.QueryStart = plot.SelectStart;
+ plot.QueryRect = plot.SelectRect;
+
+ }
+ // switch query to select
+ if (!ImHasFlag(plot.Flags, ImPlotFlags_NoBoxSelect) && plot.Querying && !ImHasFlag(IO.KeyMods, gp.InputMap.QueryToggleMod) && !IO.MouseDown[gp.InputMap.QueryButton]) {
+ plot.Selecting = plot.Selected = true;
+ plot.Querying = plot.Queried = false;
+ plot.SelectStart = plot.QueryStart;
+ plot.SelectRect = plot.QueryRect;
+ }
+
+ // FIT -----------------------------------------------------------
+
+ // fit from double click
+ if ( IO.MouseDoubleClicked[gp.InputMap.FitButton] && plot.FrameHovered && (plot.XAxis.AllHovered || any_hov_y_axis_region) && !plot.LegendHovered && !hov_query ) {
+ gp.FitThisFrame = true;
+ gp.FitX = plot.XAxis.AllHovered;
+ for (int i = 0; i < IMPLOT_Y_AXES; i++)
+ gp.FitY[i] = plot.YAxis[i].AllHovered;
+ }
+ // fit from FitNextPlotAxes or auto fit
+ if (gp.NextPlotData.FitX || ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_AutoFit)) {
+ gp.FitThisFrame = true;
+ gp.FitX = true;
+ }
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i) {
+ if (gp.NextPlotData.FitY[i] || ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_AutoFit)) {
+ gp.FitThisFrame = true;
+ gp.FitY[i] = true;
+ }
+ }
+
+ // FOCUS ------------------------------------------------------------------
+
+ // focus window
+ if ((IO.MouseClicked[0] || IO.MouseClicked[1] || IO.MouseClicked[2]) && plot.FrameHovered)
+ ImGui::FocusWindow(ImGui::GetCurrentWindow());
+
+ UpdateTransformCache();
+
+ // set mouse position
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ gp.MousePos[i] = PixelsToPlot(IO.MousePos, i);
+ }
+
+ // RENDER -----------------------------------------------------------------
+
+ // grid bg
+ DrawList.AddRectFilled(plot.PlotRect.Min, plot.PlotRect.Max, GetStyleColorU32(ImPlotCol_PlotBg));
+
+ // transform ticks (TODO: Move this into ImPlotTickCollection)
+ if (gp.RenderX) {
+ for (int t = 0; t < gp.XTicks.Size; t++) {
+ ImPlotTick *xt = &gp.XTicks.Ticks[t];
+ xt->PixelPos = PlotToPixels(xt->PlotPos, 0, 0).x;
+ }
+ }
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (gp.RenderY[i]) {
+ for (int t = 0; t < gp.YTicks[i].Size; t++) {
+ ImPlotTick *yt = &gp.YTicks[i].Ticks[t];
+ yt->PixelPos = PlotToPixels(0, yt->PlotPos, i).y;
+ }
+ }
+ }
+
+ // render grid (background)
+ PushPlotClipRect(gp.Style.PlotBorderSize == 0 ? 1.0f : 0.0f);
+ if (!ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_NoGridLines) && !ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_Foreground))
+ RenderGridLinesX(DrawList, gp.XTicks, plot.PlotRect, plot.XAxis.ColorMaj, plot.XAxis.ColorMin, gp.Style.MajorGridSize.x, gp.Style.MinorGridSize.x);
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (plot.YAxis[i].Present && !ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_NoGridLines) && !ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_Foreground))
+ RenderGridLinesY(DrawList, gp.YTicks[i], plot.PlotRect, plot.YAxis[i].ColorMaj, plot.YAxis[i].ColorMin, gp.Style.MajorGridSize.y, gp.Style.MinorGridSize.y);
+ }
+ PopPlotClipRect();
+
+ // render title
+ if (title_size.x > 0.0f && !ImHasFlag(plot.Flags, ImPlotFlags_NoTitle)) {
+ ImU32 col = GetStyleColorU32(ImPlotCol_TitleText);
+ const char* title_end = ImGui::FindRenderedTextEnd(title);
+ DrawList.AddText(ImVec2(plot.CanvasRect.GetCenter().x - title_size.x * 0.5f, plot.CanvasRect.Min.y),col,title,title_end);
+ }
+
+ // render axis labels
+ if (show_x_label) {
+ const ImVec2 xLabel_size = ImGui::CalcTextSize(x_label);
+ const ImVec2 xLabel_pos(plot.PlotRect.GetCenter().x - xLabel_size.x * 0.5f, plot.CanvasRect.Max.y - txt_height);
+ DrawList.AddText(xLabel_pos, plot.XAxis.ColorTxt, x_label);
+ }
+
+ if (show_y1_label) {
+ const ImVec2 yLabel_size = CalcTextSizeVertical(y1_label);
+ const ImVec2 yLabel_pos(plot.CanvasRect.Min.x, plot.PlotRect.GetCenter().y + yLabel_size.y * 0.5f);
+ AddTextVertical(&DrawList, yLabel_pos, plot.YAxis[0].ColorTxt, y1_label);
+ }
+
+ const char* y_labels[] = {y2_label, y3_label};
+ for (int i = 1; i < IMPLOT_Y_AXES; i++) {
+ const char* current_label = y_labels[i-1];
+ if (plot.YAxis[i].Present && current_label && !ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_NoLabel)) {
+ const ImVec2 yLabel_size = CalcTextSizeVertical(current_label);
+ float label_offset = (plot.YAxis[i].IsLabeled() ? gp.YTicks[i].MaxWidth + gp.Style.LabelPadding.x : 0.0f) + gp.Style.LabelPadding.x;
+ const ImVec2 yLabel_pos(gp.YAxisReference[i] + label_offset, plot.PlotRect.GetCenter().y + yLabel_size.y * 0.5f);
+ AddTextVertical(&DrawList, yLabel_pos, plot.YAxis[i].ColorTxt, current_label);
+ }
+ }
+
+ // render tick labels
+ ImGui::PushClipRect(plot.FrameRect.Min, plot.FrameRect.Max, true);
+ if (!ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_NoTickLabels)) {
+ for (int t = 0; t < gp.XTicks.Size; t++) {
+ ImPlotTick *xt = &gp.XTicks.Ticks[t];
+ if (xt->ShowLabel && xt->PixelPos >= plot.PlotRect.Min.x - 1 && xt->PixelPos <= plot.PlotRect.Max.x + 1)
+ DrawList.AddText(ImVec2(xt->PixelPos - xt->LabelSize.x * 0.5f, plot.PlotRect.Max.y + gp.Style.LabelPadding.y + xt->Level * (txt_height + gp.Style.LabelPadding.y)),
+ xt->Major ? plot.XAxis.ColorTxt : plot.XAxis.ColorTxt, gp.XTicks.GetText(t));
+ }
+ }
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (plot.YAxis[i].Present && !ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_NoTickLabels)) {
+ for (int t = 0; t < gp.YTicks[i].Size; t++) {
+ const float x_start = gp.YAxisReference[i] + (i == 0 ? (-gp.Style.LabelPadding.x - gp.YTicks[i].Ticks[t].LabelSize.x) : gp.Style.LabelPadding.x);
+ ImPlotTick *yt = &gp.YTicks[i].Ticks[t];
+ if (yt->ShowLabel && yt->PixelPos >= plot.PlotRect.Min.y - 1 && yt->PixelPos <= plot.PlotRect.Max.y + 1) {
+ ImVec2 start(x_start, yt->PixelPos - 0.5f * yt->LabelSize.y);
+ DrawList.AddText(start, yt->Major ? plot.YAxis[i].ColorTxt : plot.YAxis[i].ColorTxt, gp.YTicks[i].GetText(t));
+ }
+ }
+ }
+ }
+ ImGui::PopClipRect();
+
+ // clear legend
+ plot.LegendData.Reset();
+ // push plot ID into stack
+ ImGui::PushID(ID);
+ return true;
+}
+
+//-----------------------------------------------------------------------------
+// Context Menu
+//-----------------------------------------------------------------------------
+
+template <typename F>
+bool DragFloat(const char*, F*, float, F, F) {
+ return false;
+}
+
+template <>
+bool DragFloat<double>(const char* label, double* v, float v_speed, double v_min, double v_max) {
+ return ImGui::DragScalar(label, ImGuiDataType_Double, v, v_speed, &v_min, &v_max, "%.3f", 1);
+}
+
+template <>
+bool DragFloat<float>(const char* label, float* v, float v_speed, float v_min, float v_max) {
+ return ImGui::DragScalar(label, ImGuiDataType_Float, v, v_speed, &v_min, &v_max, "%.3f", 1);
+}
+
+inline void BeginDisabledControls(bool cond) {
+ if (cond) {
+ ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
+ ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.25f);
+ }
+}
+
+inline void EndDisabledControls(bool cond) {
+ if (cond) {
+ ImGui::PopItemFlag();
+ ImGui::PopStyleVar();
+ }
+}
+
+void ShowAxisContextMenu(ImPlotAxis& axis, ImPlotAxis* equal_axis, bool time_allowed) {
+
+ ImGui::PushItemWidth(75);
+ bool always_locked = axis.IsRangeLocked() || axis.IsAutoFitting();
+ bool label = !ImHasFlag(axis.Flags, ImPlotAxisFlags_NoLabel);
+ bool grid = !ImHasFlag(axis.Flags, ImPlotAxisFlags_NoGridLines);
+ bool ticks = !ImHasFlag(axis.Flags, ImPlotAxisFlags_NoTickMarks);
+ bool labels = !ImHasFlag(axis.Flags, ImPlotAxisFlags_NoTickLabels);
+ double drag_speed = (axis.Range.Size() <= DBL_EPSILON) ? DBL_EPSILON * 1.0e+13 : 0.01 * axis.Range.Size(); // recover from almost equal axis limits.
+
+ if (axis.IsTime()) {
+ ImPlotTime tmin = ImPlotTime::FromDouble(axis.Range.Min);
+ ImPlotTime tmax = ImPlotTime::FromDouble(axis.Range.Max);
+
+ BeginDisabledControls(always_locked);
+ ImGui::CheckboxFlags("##LockMin", (unsigned int*)&axis.Flags, ImPlotAxisFlags_LockMin);
+ EndDisabledControls(always_locked);
+ ImGui::SameLine();
+ BeginDisabledControls(axis.IsLockedMin() || always_locked);
+ if (ImGui::BeginMenu("Min Time")) {
+ if (ShowTimePicker("mintime", &tmin)) {
+ if (tmin >= tmax)
+ tmax = AddTime(tmin, ImPlotTimeUnit_S, 1);
+ axis.SetRange(tmin.ToDouble(),tmax.ToDouble());
+ }
+ ImGui::Separator();
+ if (ShowDatePicker("mindate",&axis.PickerLevel,&axis.PickerTimeMin,&tmin,&tmax)) {
+ tmin = CombineDateTime(axis.PickerTimeMin, tmin);
+ if (tmin >= tmax)
+ tmax = AddTime(tmin, ImPlotTimeUnit_S, 1);
+ axis.SetRange(tmin.ToDouble(), tmax.ToDouble());
+ }
+ ImGui::EndMenu();
+ }
+ EndDisabledControls(axis.IsLockedMin() || always_locked);
+
+ BeginDisabledControls(always_locked);
+ ImGui::CheckboxFlags("##LockMax", (unsigned int*)&axis.Flags, ImPlotAxisFlags_LockMax);
+ EndDisabledControls(always_locked);
+ ImGui::SameLine();
+ BeginDisabledControls(axis.IsLockedMax() || always_locked);
+ if (ImGui::BeginMenu("Max Time")) {
+ if (ShowTimePicker("maxtime", &tmax)) {
+ if (tmax <= tmin)
+ tmin = AddTime(tmax, ImPlotTimeUnit_S, -1);
+ axis.SetRange(tmin.ToDouble(),tmax.ToDouble());
+ }
+ ImGui::Separator();
+ if (ShowDatePicker("maxdate",&axis.PickerLevel,&axis.PickerTimeMax,&tmin,&tmax)) {
+ tmax = CombineDateTime(axis.PickerTimeMax, tmax);
+ if (tmax <= tmin)
+ tmin = AddTime(tmax, ImPlotTimeUnit_S, -1);
+ axis.SetRange(tmin.ToDouble(), tmax.ToDouble());
+ }
+ ImGui::EndMenu();
+ }
+ EndDisabledControls(axis.IsLockedMax() || always_locked);
+ }
+ else {
+ BeginDisabledControls(always_locked);
+ ImGui::CheckboxFlags("##LockMin", (unsigned int*)&axis.Flags, ImPlotAxisFlags_LockMin);
+ EndDisabledControls(always_locked);
+ ImGui::SameLine();
+ BeginDisabledControls(axis.IsLockedMin() || always_locked);
+ double temp_min = axis.Range.Min;
+ if (DragFloat("Min", &temp_min, (float)drag_speed, -HUGE_VAL, axis.Range.Max - DBL_EPSILON)) {
+ axis.SetMin(temp_min,true);
+ if (equal_axis != NULL)
+ equal_axis->SetAspect(axis.GetAspect());
+ }
+ EndDisabledControls(axis.IsLockedMin() || always_locked);
+
+ BeginDisabledControls(always_locked);
+ ImGui::CheckboxFlags("##LockMax", (unsigned int*)&axis.Flags, ImPlotAxisFlags_LockMax);
+ EndDisabledControls(always_locked);
+ ImGui::SameLine();
+ BeginDisabledControls(axis.IsLockedMax() || always_locked);
+ double temp_max = axis.Range.Max;
+ if (DragFloat("Max", &temp_max, (float)drag_speed, axis.Range.Min + DBL_EPSILON, HUGE_VAL)) {
+ axis.SetMax(temp_max,true);
+ if (equal_axis != NULL)
+ equal_axis->SetAspect(axis.GetAspect());
+ }
+ EndDisabledControls(axis.IsLockedMax() || always_locked);
+ }
+
+ ImGui::Separator();
+
+ ImGui::CheckboxFlags("Auto-Fit",(unsigned int*)&axis.Flags, ImPlotAxisFlags_AutoFit);
+ ImGui::CheckboxFlags("Invert",(unsigned int*)&axis.Flags, ImPlotAxisFlags_Invert);
+ BeginDisabledControls(axis.IsTime() && time_allowed);
+ ImGui::CheckboxFlags("Log Scale",(unsigned int*)&axis.Flags, ImPlotAxisFlags_LogScale);
+ EndDisabledControls(axis.IsTime() && time_allowed);
+
+ if (time_allowed) {
+ BeginDisabledControls(axis.IsLog());
+ ImGui::CheckboxFlags("Time",(unsigned int*)&axis.Flags, ImPlotAxisFlags_Time);
+ EndDisabledControls(axis.IsLog());
+ }
+
+ ImGui::Separator();
+ if (ImGui::Checkbox("Label", &label))
+ ImFlipFlag(axis.Flags, ImPlotAxisFlags_NoLabel);
+ if (ImGui::Checkbox("Grid Lines", &grid))
+ ImFlipFlag(axis.Flags, ImPlotAxisFlags_NoGridLines);
+ if (ImGui::Checkbox("Tick Marks", &ticks))
+ ImFlipFlag(axis.Flags, ImPlotAxisFlags_NoTickMarks);
+ if (ImGui::Checkbox("Tick Labels", &labels))
+ ImFlipFlag(axis.Flags, ImPlotAxisFlags_NoTickLabels);
+}
+
+void ShowPlotContextMenu(ImPlotPlot& plot) {
+ const bool equal = ImHasFlag(plot.Flags, ImPlotFlags_Equal);
+ if (ImGui::BeginMenu("X-Axis")) {
+ ImGui::PushID("X");
+ ShowAxisContextMenu(plot.XAxis, equal ? &plot.YAxis[0] : NULL, true);
+ ImGui::PopID();
+ ImGui::EndMenu();
+ }
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (i == 1 && !ImHasFlag(plot.Flags, ImPlotFlags_YAxis2)) {
+ continue;
+ }
+ if (i == 2 && !ImHasFlag(plot.Flags, ImPlotFlags_YAxis3)) {
+ continue;
+ }
+ char buf[10] = {};
+ if (i == 0) {
+ snprintf(buf, sizeof(buf) - 1, "Y-Axis");
+ } else {
+ snprintf(buf, sizeof(buf) - 1, "Y-Axis %d", i + 1);
+ }
+ if (ImGui::BeginMenu(buf)) {
+ ImGui::PushID(i);
+ ShowAxisContextMenu(plot.YAxis[i], (equal && i == 0) ? &plot.XAxis : NULL, false);
+ ImGui::PopID();
+ ImGui::EndMenu();
+ }
+ }
+
+ ImGui::Separator();
+ if ((ImGui::BeginMenu("Settings"))) {
+ if (ImGui::MenuItem("Anti-Aliased Lines",NULL,ImHasFlag(plot.Flags, ImPlotFlags_AntiAliased)))
+ ImFlipFlag(plot.Flags, ImPlotFlags_AntiAliased);
+ if (ImGui::MenuItem("Equal", NULL, ImHasFlag(plot.Flags, ImPlotFlags_Equal)))
+ ImFlipFlag(plot.Flags, ImPlotFlags_Equal);
+ if (ImGui::MenuItem("Box Select",NULL,!ImHasFlag(plot.Flags, ImPlotFlags_NoBoxSelect)))
+ ImFlipFlag(plot.Flags, ImPlotFlags_NoBoxSelect);
+ if (ImGui::MenuItem("Query",NULL,ImHasFlag(plot.Flags, ImPlotFlags_Query)))
+ ImFlipFlag(plot.Flags, ImPlotFlags_Query);
+ if (ImGui::MenuItem("Title",NULL,!ImHasFlag(plot.Flags, ImPlotFlags_NoTitle)))
+ ImFlipFlag(plot.Flags, ImPlotFlags_NoTitle);
+ if (ImGui::MenuItem("Mouse Position",NULL,!ImHasFlag(plot.Flags, ImPlotFlags_NoMousePos)))
+ ImFlipFlag(plot.Flags, ImPlotFlags_NoMousePos);
+ if (ImGui::MenuItem("Crosshairs",NULL,ImHasFlag(plot.Flags, ImPlotFlags_Crosshairs)))
+ ImFlipFlag(plot.Flags, ImPlotFlags_Crosshairs);
+ if ((ImGui::BeginMenu("Legend"))) {
+ const float s = ImGui::GetFrameHeight();
+ if (ImGui::RadioButton("H", plot.LegendOrientation == ImPlotOrientation_Horizontal))
+ plot.LegendOrientation = ImPlotOrientation_Horizontal;
+ ImGui::SameLine();
+ if (ImGui::RadioButton("V", plot.LegendOrientation == ImPlotOrientation_Vertical))
+ plot.LegendOrientation = ImPlotOrientation_Vertical;
+ ImGui::Checkbox("Outside", &plot.LegendOutside);
+ ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(1,1));
+ if (ImGui::Button("##NW",ImVec2(1.5f*s,s))) { plot.LegendLocation = ImPlotLocation_NorthWest; } ImGui::SameLine();
+ if (ImGui::Button("##N", ImVec2(1.5f*s,s))) { plot.LegendLocation = ImPlotLocation_North; } ImGui::SameLine();
+ if (ImGui::Button("##NE",ImVec2(1.5f*s,s))) { plot.LegendLocation = ImPlotLocation_NorthEast; }
+ if (ImGui::Button("##W", ImVec2(1.5f*s,s))) { plot.LegendLocation = ImPlotLocation_West; } ImGui::SameLine();
+ if (ImGui::Button("##C", ImVec2(1.5f*s,s))) { plot.LegendLocation = ImPlotLocation_Center; } ImGui::SameLine();
+ if (ImGui::Button("##E", ImVec2(1.5f*s,s))) { plot.LegendLocation = ImPlotLocation_East; }
+ if (ImGui::Button("##SW",ImVec2(1.5f*s,s))) { plot.LegendLocation = ImPlotLocation_SouthWest; } ImGui::SameLine();
+ if (ImGui::Button("##S", ImVec2(1.5f*s,s))) { plot.LegendLocation = ImPlotLocation_South; } ImGui::SameLine();
+ if (ImGui::Button("##SE",ImVec2(1.5f*s,s))) { plot.LegendLocation = ImPlotLocation_SouthEast; }
+ ImGui::PopStyleVar();
+ ImGui::EndMenu();
+ }
+ ImGui::EndMenu();
+ }
+ if (ImGui::MenuItem("Legend",NULL,!ImHasFlag(plot.Flags, ImPlotFlags_NoLegend))) {
+ ImFlipFlag(plot.Flags, ImPlotFlags_NoLegend);
+ }
+}
+
+//-----------------------------------------------------------------------------
+// EndPlot()
+//-----------------------------------------------------------------------------
+
+void EndPlot() {
+ IM_ASSERT_USER_ERROR(GImPlot != NULL, "No current context. Did you call ImPlot::CreateContext() or ImPlot::SetCurrentContext()?");
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "Mismatched BeginPlot()/EndPlot()!");
+ ImGuiContext &G = *GImGui;
+ ImPlotPlot &plot = *gp.CurrentPlot;
+ ImGuiWindow * Window = G.CurrentWindow;
+ ImDrawList & DrawList = *Window->DrawList;
+ const ImGuiIO & IO = ImGui::GetIO();
+
+ // AXIS STATES ------------------------------------------------------------
+
+ const bool any_y_dragging = plot.YAxis[0].Dragging || plot.YAxis[1].Dragging || plot.YAxis[2].Dragging;
+
+ // FINAL RENDER -----------------------------------------------------------
+
+ // render grid (foreground)
+ PushPlotClipRect(gp.Style.PlotBorderSize == 0 ? 1.0f : 0.0f);
+ if (!ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_NoGridLines) && ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_Foreground))
+ RenderGridLinesX(DrawList, gp.XTicks, plot.PlotRect, plot.XAxis.ColorMaj, plot.XAxis.ColorMaj, gp.Style.MajorGridSize.x, gp.Style.MinorGridSize.x);
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (plot.YAxis[i].Present && !ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_NoGridLines) && ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_Foreground))
+ RenderGridLinesY(DrawList, gp.YTicks[i], plot.PlotRect, plot.YAxis[i].ColorMaj, plot.YAxis[i].ColorMin, gp.Style.MajorGridSize.y, gp.Style.MinorGridSize.y);
+ }
+ PopPlotClipRect();
+
+ // render x-ticks
+ PushPlotClipRect();
+ if (!ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_NoTickMarks)) {
+ for (int t = 0; t < gp.XTicks.Size; t++) {
+ ImPlotTick *xt = &gp.XTicks.Ticks[t];
+ if (xt->Level == 0)
+ DrawList.AddLine(ImVec2(xt->PixelPos, plot.PlotRect.Max.y),
+ ImVec2(xt->PixelPos, plot.PlotRect.Max.y - (xt->Major ? gp.Style.MajorTickLen.x : gp.Style.MinorTickLen.x)),
+ plot.XAxis.ColorMaj,
+ xt->Major ? gp.Style.MajorTickSize.x : gp.Style.MinorTickSize.x);
+ }
+ }
+ PopPlotClipRect();
+
+ // render y-ticks
+ ImGui::PushClipRect(plot.PlotRect.Min, ImVec2(plot.FrameRect.Max.x, plot.PlotRect.Max.y), true);
+ int axis_count = 0;
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (!plot.YAxis[i].Present) { continue; }
+ axis_count++;
+ float x_start = gp.YAxisReference[i];
+ if (!ImHasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_NoTickMarks)) {
+ float direction = (i == 0) ? 1.0f : -1.0f;
+ bool no_major = axis_count >= 3;
+ for (int t = 0; t < gp.YTicks[i].Size; t++) {
+ ImPlotTick *yt = &gp.YTicks[i].Ticks[t];
+ ImVec2 start = ImVec2(x_start, yt->PixelPos);
+ DrawList.AddLine(start,
+ start + ImVec2(direction * ((!no_major && yt->Major) ? gp.Style.MajorTickLen.y : gp.Style.MinorTickLen.y), 0),
+ plot.YAxis[i].ColorMaj,
+ (!no_major && yt->Major) ? gp.Style.MajorTickSize.y : gp.Style.MinorTickSize.y);
+ }
+ }
+ if (axis_count >= 3) {
+ // Draw a bar next to the ticks to act as a visual separator.
+ DrawList.AddLine(ImVec2(x_start, plot.PlotRect.Min.y), ImVec2(x_start, plot.PlotRect.Max.y), GetStyleColorU32(ImPlotCol_YAxisGrid3), 1);
+ }
+ }
+ ImGui::PopClipRect();
+
+ // render annotations
+ PushPlotClipRect();
+ for (int i = 0; i < gp.Annotations.Size; ++i) {
+ const char* txt = gp.Annotations.GetText(i);
+ ImPlotAnnotation& an = gp.Annotations.Annotations[i];
+ const ImVec2 txt_size = ImGui::CalcTextSize(txt);
+ const ImVec2 size = txt_size + gp.Style.AnnotationPadding * 2;
+ ImVec2 pos = an.Pos;
+ if (an.Offset.x == 0)
+ pos.x -= size.x / 2;
+ else if (an.Offset.x > 0)
+ pos.x += an.Offset.x;
+ else
+ pos.x -= size.x - an.Offset.x;
+ if (an.Offset.y == 0)
+ pos.y -= size.y / 2;
+ else if (an.Offset.y > 0)
+ pos.y += an.Offset.y;
+ else
+ pos.y -= size.y - an.Offset.y;
+ if (an.Clamp)
+ pos = ClampLabelPos(pos, size, plot.PlotRect.Min, plot.PlotRect.Max);
+ ImRect rect(pos,pos+size);
+ if (an.Offset.x != 0 || an.Offset.y != 0) {
+ ImVec2 corners[4] = {rect.GetTL(), rect.GetTR(), rect.GetBR(), rect.GetBL()};
+ int min_corner = 0;
+ float min_len = FLT_MAX;
+ for (int c = 0; c < 4; ++c) {
+ float len = ImLengthSqr(an.Pos - corners[c]);
+ if (len < min_len) {
+ min_corner = c;
+ min_len = len;
+ }
+ }
+ DrawList.AddLine(an.Pos, corners[min_corner], an.ColorBg);
+ }
+ DrawList.AddRectFilled(rect.Min, rect.Max, an.ColorBg);
+ DrawList.AddText(pos + gp.Style.AnnotationPadding, an.ColorFg, txt);
+ }
+
+ // render selection
+ if (plot.Selected)
+ RenderSelectionRect(DrawList, plot.SelectRect.Min + plot.PlotRect.Min, plot.SelectRect.Max + plot.PlotRect.Min, GetStyleColorVec4(ImPlotCol_Selection));
+ // render query
+ if (plot.Queried)
+ RenderSelectionRect(DrawList, plot.QueryRect.Min + plot.PlotRect.Min, plot.QueryRect.Max + plot.PlotRect.Min, GetStyleColorVec4(ImPlotCol_Query));
+
+ // render crosshairs
+ if (ImHasFlag(plot.Flags, ImPlotFlags_Crosshairs) && plot.PlotHovered && !(plot.XAxis.Dragging || any_y_dragging) && !plot.Selecting && !plot.Querying && !plot.LegendHovered) {
+ ImGui::SetMouseCursor(ImGuiMouseCursor_None);
+ ImVec2 xy = IO.MousePos;
+ ImVec2 h1(plot.PlotRect.Min.x, xy.y);
+ ImVec2 h2(xy.x - 5, xy.y);
+ ImVec2 h3(xy.x + 5, xy.y);
+ ImVec2 h4(plot.PlotRect.Max.x, xy.y);
+ ImVec2 v1(xy.x, plot.PlotRect.Min.y);
+ ImVec2 v2(xy.x, xy.y - 5);
+ ImVec2 v3(xy.x, xy.y + 5);
+ ImVec2 v4(xy.x, plot.PlotRect.Max.y);
+ ImU32 col = GetStyleColorU32(ImPlotCol_Crosshairs);
+ DrawList.AddLine(h1, h2, col);
+ DrawList.AddLine(h3, h4, col);
+ DrawList.AddLine(v1, v2, col);
+ DrawList.AddLine(v3, v4, col);
+ }
+
+ // render mouse pos
+ if (!ImHasFlag(plot.Flags, ImPlotFlags_NoMousePos) && plot.PlotHovered) {
+ char buffer[128] = {};
+ ImBufferWriter writer(buffer, sizeof(buffer));
+ // x
+ if (ImHasFlag(plot.XAxis.Flags, ImPlotAxisFlags_Time)) {
+ ImPlotTimeUnit unit = GetUnitForRange(plot.XAxis.Range.Size() / (plot.PlotRect.GetWidth() / 100));
+ const int written = FormatDateTime(ImPlotTime::FromDouble(gp.MousePos[0].x), &writer.Buffer[writer.Pos], writer.Size - writer.Pos - 1, GetDateTimeFmt(TimeFormatMouseCursor, unit));
+ if (written > 0)
+ writer.Pos += ImMin(written, writer.Size - writer.Pos - 1);
+ }
+ else {
+ writer.Write(GetFormatX(), RoundAxisValue(plot.XAxis, gp.XTicks, gp.MousePos[0].x));
+ }
+ // y1
+ writer.Write(", ");
+ writer.Write(GetFormatY(0), RoundAxisValue(plot.YAxis[0], gp.YTicks[0], gp.MousePos[0].y));
+ // y2
+ if (ImHasFlag(plot.Flags, ImPlotFlags_YAxis2)) {
+ writer.Write(", (");
+ writer.Write(GetFormatY(1), RoundAxisValue(plot.YAxis[1], gp.YTicks[1], gp.MousePos[1].y));
+ writer.Write(")");
+ }
+ // y3
+ if (ImHasFlag(plot.Flags, ImPlotFlags_YAxis3)) {
+ writer.Write(", (");
+ writer.Write(GetFormatY(2), RoundAxisValue(plot.YAxis[2], gp.YTicks[2], gp.MousePos[2].y));
+ writer.Write(")");
+ }
+ const ImVec2 size = ImGui::CalcTextSize(buffer);
+ const ImVec2 pos = GetLocationPos(plot.PlotRect, size, plot.MousePosLocation, gp.Style.MousePosPadding);
+ DrawList.AddText(pos, GetStyleColorU32(ImPlotCol_InlayText), buffer);
+ }
+ PopPlotClipRect();
+
+ // reset legend hovers
+ plot.LegendHovered = false;
+ for (int i = 0; i < plot.Items.GetSize(); ++i)
+ plot.Items.GetByIndex(i)->LegendHovered = false;
+ // render legend
+ if (!ImHasFlag(plot.Flags, ImPlotFlags_NoLegend) && plot.GetLegendCount() > 0) {
+ const ImVec2 legend_size = CalcLegendSize(plot, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, plot.LegendOrientation);
+ const ImVec2 legend_pos = GetLocationPos(plot.LegendOutside ? plot.FrameRect : plot.PlotRect,
+ legend_size,
+ plot.LegendLocation,
+ plot.LegendOutside ? gp.Style.PlotPadding : gp.Style.LegendPadding);
+ plot.LegendRect = ImRect(legend_pos, legend_pos + legend_size);
+ // test hover
+ plot.LegendHovered = plot.FrameHovered && plot.LegendRect.Contains(IO.MousePos);
+
+ if (plot.LegendOutside)
+ ImGui::PushClipRect(plot.FrameRect.Min, plot.FrameRect.Max, true);
+ else
+ PushPlotClipRect();
+ ImU32 col_bg = GetStyleColorU32(ImPlotCol_LegendBg);
+ ImU32 col_bd = GetStyleColorU32(ImPlotCol_LegendBorder);
+ DrawList.AddRectFilled(plot.LegendRect.Min, plot.LegendRect.Max, col_bg);
+ DrawList.AddRect(plot.LegendRect.Min, plot.LegendRect.Max, col_bd);
+ ShowLegendEntries(plot, plot.LegendRect, plot.LegendHovered, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, plot.LegendOrientation, DrawList);
+ ImGui::PopClipRect();
+ }
+ else {
+ plot.LegendRect = ImRect();
+ }
+ if (plot.LegendFlipSideNextFrame) {
+ plot.LegendOutside = !plot.LegendOutside;
+ plot.LegendFlipSideNextFrame = false;
+ }
+
+ // render border
+ if (gp.Style.PlotBorderSize > 0)
+ DrawList.AddRect(plot.PlotRect.Min, plot.PlotRect.Max, GetStyleColorU32(ImPlotCol_PlotBorder), 0, ImDrawFlags_RoundCornersAll, gp.Style.PlotBorderSize);
+
+ // FIT DATA --------------------------------------------------------------
+ const bool axis_equal = ImHasFlag(plot.Flags, ImPlotFlags_Equal);
+ if (gp.FitThisFrame && (gp.VisibleItemCount > 0 || plot.Queried)) {
+ if (gp.FitX) {
+ const double ext_size = gp.ExtentsX.Size() * 0.5;
+ gp.ExtentsX.Min -= ext_size * gp.Style.FitPadding.x;
+ gp.ExtentsX.Max += ext_size * gp.Style.FitPadding.x;
+ if (!plot.XAxis.IsLockedMin() && !ImNanOrInf(gp.ExtentsX.Min))
+ plot.XAxis.Range.Min = (gp.ExtentsX.Min);
+ if (!plot.XAxis.IsLockedMax() && !ImNanOrInf(gp.ExtentsX.Max))
+ plot.XAxis.Range.Max = (gp.ExtentsX.Max);
+ if (ImAlmostEqual(plot.XAxis.Range.Max, plot.XAxis.Range.Min)) {
+ plot.XAxis.Range.Max += 0.5;
+ plot.XAxis.Range.Min -= 0.5;
+ }
+ plot.XAxis.Constrain();
+ if (axis_equal && !gp.FitY[0])
+ plot.YAxis[0].SetAspect(plot.XAxis.GetAspect());
+ }
+ for (int i = 0; i < IMPLOT_Y_AXES; i++) {
+ if (gp.FitY[i]) {
+ const double ext_size = gp.ExtentsY[i].Size() * 0.5;
+ gp.ExtentsY[i].Min -= ext_size * gp.Style.FitPadding.y;
+ gp.ExtentsY[i].Max += ext_size * gp.Style.FitPadding.y;
+ if (!plot.YAxis[i].IsLockedMin() && !ImNanOrInf(gp.ExtentsY[i].Min))
+ plot.YAxis[i].Range.Min = (gp.ExtentsY[i].Min);
+ if (!plot.YAxis[i].IsLockedMax() && !ImNanOrInf(gp.ExtentsY[i].Max))
+ plot.YAxis[i].Range.Max = (gp.ExtentsY[i].Max);
+ if (ImAlmostEqual(plot.YAxis[i].Range.Max, plot.YAxis[i].Range.Min)) {
+ plot.YAxis[i].Range.Max += 0.5;
+ plot.YAxis[i].Range.Min -= 0.5;
+ }
+ plot.YAxis[i].Constrain();
+ if (i == 0 && axis_equal && !gp.FitX)
+ plot.XAxis.SetAspect(plot.YAxis[0].GetAspect());
+ }
+ }
+ if (axis_equal && gp.FitX && gp.FitY[0]) {
+ double aspect = ImMax(plot.XAxis.GetAspect(), plot.YAxis[0].GetAspect());
+ plot.XAxis.SetAspect(aspect);
+ plot.YAxis[0].SetAspect(aspect);
+ }
+ }
+
+ // CONTEXT MENUS -----------------------------------------------------------
+
+ // main ctx menu
+ if (!ImHasFlag(plot.Flags, ImPlotFlags_NoMenus) && plot.PlotHovered && IO.MouseReleased[gp.InputMap.ContextMenuButton] && !plot.LegendHovered && !plot.ContextLocked)
+ ImGui::OpenPopup("##PlotContext");
+ if (ImGui::BeginPopup("##PlotContext")) {
+ ShowPlotContextMenu(plot);
+ ImGui::EndPopup();
+ }
+
+ // x-axis ctx menu
+ if (!ImHasFlag(plot.Flags, ImPlotFlags_NoMenus) && plot.FrameHovered && plot.XAxis.ExtHovered && IO.MouseReleased[gp.InputMap.ContextMenuButton] && !plot.LegendHovered && !plot.ContextLocked)
+ ImGui::OpenPopup("##XContext");
+ if (ImGui::BeginPopup("##XContext")) {
+ ImGui::Text("X-Axis"); ImGui::Separator();
+ ShowAxisContextMenu(plot.XAxis, ImHasFlag(plot.Flags, ImPlotFlags_Equal) ? &plot.YAxis[0] : NULL, true);
+ ImGui::EndPopup();
+ }
+
+ // y-axes ctx menus
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i) {
+ ImGui::PushID(i);
+ if (!ImHasFlag(plot.Flags, ImPlotFlags_NoMenus) && plot.FrameHovered && plot.YAxis[i].ExtHovered && IO.MouseReleased[gp.InputMap.ContextMenuButton] && !plot.LegendHovered && !plot.ContextLocked)
+ ImGui::OpenPopup("##YContext");
+ if (ImGui::BeginPopup("##YContext")) {
+ if (i == 0) {
+ ImGui::Text("Y-Axis"); ImGui::Separator();
+ }
+ else {
+ ImGui::Text("Y-Axis %d", i + 1); ImGui::Separator();
+ }
+ ShowAxisContextMenu(plot.YAxis[i], (i == 0 && ImHasFlag(plot.Flags, ImPlotFlags_Equal)) ? &plot.XAxis : NULL, false);
+ ImGui::EndPopup();
+ }
+ ImGui::PopID();
+ }
+
+
+ // LINKED AXES ------------------------------------------------------------
+
+ PushLinkedAxis(plot.XAxis);
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i)
+ PushLinkedAxis(plot.YAxis[i]);
+
+ // CLEANUP ----------------------------------------------------------------
+
+ // resset context locked flag
+ if (plot.ContextLocked && IO.MouseReleased[gp.InputMap.BoxSelectButton])
+ plot.ContextLocked = false;
+
+
+ // reset the plot items for the next frame
+ for (int i = 0; i < plot.Items.GetSize(); ++i) {
+ plot.Items.GetByIndex(i)->SeenThisFrame = false;
+ }
+
+ // mark the plot as initialized, i.e. having made it through one frame completely
+ plot.Initialized = true;
+
+ // Pop ImGui::PushID at the end of BeginPlot
+ ImGui::PopID();
+ // Reset context for next plot
+ Reset(GImPlot);
+}
+
+//-----------------------------------------------------------------------------
+// MISC API
+//-----------------------------------------------------------------------------
+
+ImPlotInputMap& GetInputMap() {
+ return GImPlot->InputMap;
+}
+
+void SetNextPlotLimits(double x_min, double x_max, double y_min, double y_max, ImGuiCond cond) {
+ IM_ASSERT_USER_ERROR(GImPlot->CurrentPlot == NULL, "SetNextPlotLimits() needs to be called before BeginPlot()!");
+ SetNextPlotLimitsX(x_min, x_max, cond);
+ SetNextPlotLimitsY(y_min, y_max, cond);
+}
+
+void SetNextPlotLimitsX(double x_min, double x_max, ImGuiCond cond) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot == NULL, "SetNextPlotLSetNextPlotLimitsXimitsY() needs to be called before BeginPlot()!");
+ IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
+ gp.NextPlotData.HasXRange = true;
+ gp.NextPlotData.XRangeCond = cond;
+ gp.NextPlotData.XRange.Min = x_min;
+ gp.NextPlotData.XRange.Max = x_max;
+}
+
+void SetNextPlotLimitsY(double y_min, double y_max, ImGuiCond cond, ImPlotYAxis y_axis) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot == NULL, "SetNextPlotLimitsY() needs to be called before BeginPlot()!");
+ IM_ASSERT_USER_ERROR(y_axis >= 0 && y_axis < IMPLOT_Y_AXES, "y_axis needs to be between 0 and IMPLOT_Y_AXES");
+ IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
+ gp.NextPlotData.HasYRange[y_axis] = true;
+ gp.NextPlotData.YRangeCond[y_axis] = cond;
+ gp.NextPlotData.YRange[y_axis].Min = y_min;
+ gp.NextPlotData.YRange[y_axis].Max = y_max;
+}
+
+void LinkNextPlotLimits(double* xmin, double* xmax, double* ymin, double* ymax, double* ymin2, double* ymax2, double* ymin3, double* ymax3) {
+ ImPlotContext& gp = *GImPlot;
+ gp.NextPlotData.LinkedXmin = xmin;
+ gp.NextPlotData.LinkedXmax = xmax;
+ gp.NextPlotData.LinkedYmin[0] = ymin;
+ gp.NextPlotData.LinkedYmax[0] = ymax;
+ gp.NextPlotData.LinkedYmin[1] = ymin2;
+ gp.NextPlotData.LinkedYmax[1] = ymax2;
+ gp.NextPlotData.LinkedYmin[2] = ymin3;
+ gp.NextPlotData.LinkedYmax[2] = ymax3;
+}
+
+void FitNextPlotAxes(bool x, bool y, bool y2, bool y3) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot == NULL, "FitNextPlotAxes() needs to be called before BeginPlot()!");
+ gp.NextPlotData.FitX = x;
+ gp.NextPlotData.FitY[0] = y;
+ gp.NextPlotData.FitY[1] = y2;
+ gp.NextPlotData.FitY[2] = y3;
+}
+
+void SetNextPlotTicksX(const double* values, int n_ticks, const char* const labels[], bool show_default) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot == NULL, "SetNextPlotTicksX() needs to be called before BeginPlot()!");
+ gp.NextPlotData.ShowDefaultTicksX = show_default;
+ AddTicksCustom(values, labels, n_ticks, gp.XTicks, GetFormatX());
+}
+
+void SetNextPlotTicksX(double x_min, double x_max, int n_ticks, const char* const labels[], bool show_default) {
+ IM_ASSERT_USER_ERROR(n_ticks > 1, "The number of ticks must be greater than 1");
+ static ImVector<double> buffer;
+ FillRange(buffer, n_ticks, x_min, x_max);
+ SetNextPlotTicksX(&buffer[0], n_ticks, labels, show_default);
+}
+
+void SetNextPlotTicksY(const double* values, int n_ticks, const char* const labels[], bool show_default, ImPlotYAxis y_axis) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot == NULL, "SetNextPlotTicksY() needs to be called before BeginPlot()!");
+ IM_ASSERT_USER_ERROR(y_axis >= 0 && y_axis < IMPLOT_Y_AXES, "y_axis needs to be between 0 and IMPLOT_Y_AXES");
+ gp.NextPlotData.ShowDefaultTicksY[y_axis] = show_default;
+ AddTicksCustom(values, labels, n_ticks, gp.YTicks[y_axis], GetFormatY(y_axis));
+}
+
+void SetNextPlotTicksY(double y_min, double y_max, int n_ticks, const char* const labels[], bool show_default, ImPlotYAxis y_axis) {
+ IM_ASSERT_USER_ERROR(n_ticks > 1, "The number of ticks must be greater than 1");
+ static ImVector<double> buffer;
+ FillRange(buffer, n_ticks, y_min, y_max);
+ SetNextPlotTicksY(&buffer[0], n_ticks, labels, show_default,y_axis);
+}
+
+void SetNextPlotFormatX(const char* fmt){
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot == NULL, "SetNextPlotFormatX() needs to be called before BeginPlot()!");
+ gp.NextPlotData.HasFmtX = true;
+ ImStrncpy(gp.NextPlotData.FmtX, fmt, 16);
+}
+
+void SetNextPlotFormatY(const char* fmt, ImPlotYAxis y_axis) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot == NULL, "SetNextPlotFormatY() needs to be called before BeginPlot()!");
+ IM_ASSERT_USER_ERROR(y_axis >= 0 && y_axis < IMPLOT_Y_AXES, "y_axis needs to be between 0 and IMPLOT_Y_AXES");
+ gp.NextPlotData.HasFmtY[y_axis] = true;
+ ImStrncpy(gp.NextPlotData.FmtY[y_axis], fmt, 16);
+}
+
+void SetPlotYAxis(ImPlotYAxis y_axis) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "SetPlotYAxis() needs to be called between BeginPlot() and EndPlot()!");
+ IM_ASSERT_USER_ERROR(y_axis >= 0 && y_axis < IMPLOT_Y_AXES, "y_axis needs to be between 0 and IMPLOT_Y_AXES");
+ gp.CurrentPlot->CurrentYAxis = y_axis;
+}
+
+ImVec2 GetPlotPos() {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "GetPlotPos() needs to be called between BeginPlot() and EndPlot()!");
+ return gp.CurrentPlot->PlotRect.Min;
+}
+
+ImVec2 GetPlotSize() {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "GetPlotSize() needs to be called between BeginPlot() and EndPlot()!");
+ return gp.CurrentPlot->PlotRect.GetSize();
+}
+
+ImDrawList* GetPlotDrawList() {
+ return ImGui::GetWindowDrawList();
+}
+
+void PushPlotClipRect(float expand) {
+ ImPlotContext& gp = *GImPlot;
+ ImRect rect = gp.CurrentPlot->PlotRect;
+ rect.Expand(expand);
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "PushPlotClipRect() needs to be called between BeginPlot() and EndPlot()!");
+ ImGui::PushClipRect(rect.Min, rect.Max, true);
+}
+
+void PopPlotClipRect() {
+ ImGui::PopClipRect();
+}
+
+bool IsPlotHovered() {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "IsPlotHovered() needs to be called between BeginPlot() and EndPlot()!");
+ return gp.CurrentPlot->PlotHovered;
+}
+
+bool IsPlotXAxisHovered() {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "IsPlotXAxisHovered() needs to be called between BeginPlot() and EndPlot()!");
+ return gp.CurrentPlot->XAxis.ExtHovered;
+}
+
+bool IsPlotYAxisHovered(ImPlotYAxis y_axis_in) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(y_axis_in >= -1 && y_axis_in < IMPLOT_Y_AXES, "y_axis needs to between -1 and IMPLOT_Y_AXES");
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "IsPlotYAxisHovered() needs to be called between BeginPlot() and EndPlot()!");
+ const ImPlotYAxis y_axis = y_axis_in >= 0 ? y_axis_in : gp.CurrentPlot->CurrentYAxis;
+ return gp.CurrentPlot->YAxis[y_axis].ExtHovered;
+}
+
+ImPlotPoint GetPlotMousePos(ImPlotYAxis y_axis_in) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(y_axis_in >= -1 && y_axis_in < IMPLOT_Y_AXES, "y_axis needs to between -1 and IMPLOT_Y_AXES");
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "GetPlotMousePos() needs to be called between BeginPlot() and EndPlot()!");
+ const ImPlotYAxis y_axis = y_axis_in >= 0 ? y_axis_in : gp.CurrentPlot->CurrentYAxis;
+ return gp.MousePos[y_axis];
+}
+
+
+ImPlotLimits GetPlotLimits(ImPlotYAxis y_axis_in) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(y_axis_in >= -1 && y_axis_in < IMPLOT_Y_AXES, "y_axis needs to between -1 and IMPLOT_Y_AXES");
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "GetPlotLimits() needs to be called between BeginPlot() and EndPlot()!");
+ const ImPlotYAxis y_axis = y_axis_in >= 0 ? y_axis_in : gp.CurrentPlot->CurrentYAxis;
+
+ ImPlotPlot& plot = *gp.CurrentPlot;
+ ImPlotLimits limits;
+ limits.X = plot.XAxis.Range;
+ limits.Y = plot.YAxis[y_axis].Range;
+ return limits;
+}
+
+bool IsPlotSelected() {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "IsPlotSelected() needs to be called between BeginPlot() and EndPlot()!");
+ return gp.CurrentPlot->Selected;
+}
+
+ImPlotLimits GetPlotSelection(ImPlotYAxis y_axis) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(y_axis >= -1 && y_axis < IMPLOT_Y_AXES, "y_axis needs to between -1 and IMPLOT_Y_AXES");
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "GetPlotSelection() needs to be called between BeginPlot() and EndPlot()!");
+ ImPlotPlot& plot = *gp.CurrentPlot;
+ y_axis = y_axis >= 0 ? y_axis : gp.CurrentPlot->CurrentYAxis;
+ if (!plot.Selected)
+ return ImPlotLimits(0,0,0,0);
+ UpdateTransformCache();
+ ImPlotPoint p1 = PixelsToPlot(plot.SelectRect.Min + plot.PlotRect.Min, y_axis);
+ ImPlotPoint p2 = PixelsToPlot(plot.SelectRect.Max + plot.PlotRect.Min, y_axis);
+ ImPlotLimits result;
+ result.X.Min = ImMin(p1.x, p2.x);
+ result.X.Max = ImMax(p1.x, p2.x);
+ result.Y.Min = ImMin(p1.y, p2.y);
+ result.Y.Max = ImMax(p1.y, p2.y);
+ return result;
+}
+
+bool IsPlotQueried() {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "IsPlotQueried() needs to be called between BeginPlot() and EndPlot()!");
+ return gp.CurrentPlot->Queried;
+}
+
+ImPlotLimits GetPlotQuery(ImPlotYAxis y_axis) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(y_axis >= -1 && y_axis < IMPLOT_Y_AXES, "y_axis needs to between -1 and IMPLOT_Y_AXES");
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "GetPlotQuery() needs to be called between BeginPlot() and EndPlot()!");
+ ImPlotPlot& plot = *gp.CurrentPlot;
+ y_axis = y_axis >= 0 ? y_axis : gp.CurrentPlot->CurrentYAxis;
+ if (!plot.Queried)
+ return ImPlotLimits(0,0,0,0);
+ UpdateTransformCache();
+ ImPlotPoint p1 = PixelsToPlot(plot.QueryRect.Min + plot.PlotRect.Min, y_axis);
+ ImPlotPoint p2 = PixelsToPlot(plot.QueryRect.Max + plot.PlotRect.Min, y_axis);
+ ImPlotLimits result;
+ result.X.Min = ImMin(p1.x, p2.x);
+ result.X.Max = ImMax(p1.x, p2.x);
+ result.Y.Min = ImMin(p1.y, p2.y);
+ result.Y.Max = ImMax(p1.y, p2.y);
+ return result;
+}
+
+void SetPlotQuery(const ImPlotLimits& query, ImPlotYAxis y_axis) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(y_axis >= -1 && y_axis < IMPLOT_Y_AXES, "y_axis needs to between -1 and IMPLOT_Y_AXES");
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "GetPlotQuery() needs to be called between BeginPlot() and EndPlot()!");
+ ImPlotPlot& plot = *gp.CurrentPlot;
+ y_axis = y_axis >= 0 ? y_axis : gp.CurrentPlot->CurrentYAxis;
+ UpdateTransformCache();
+ ImVec2 p1 = PlotToPixels(query.Min(),y_axis);
+ ImVec2 p2 = PlotToPixels(query.Max(),y_axis);
+ plot.Queried = true;
+ plot.Querying = false;
+ plot.QueryRect = ImRect(ImMin(p1,p2)-plot.PlotRect.Min, ImMax(p1,p2)-plot.PlotRect.Min);
+}
+
+void AnnotateEx(double x, double y, bool clamp, const ImVec4& col, const ImVec2& off, const char* fmt, va_list args) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "Annotate() needs to be called between BeginPlot() and EndPlot()!");
+ ImVec2 pos = PlotToPixels(x,y);
+ ImU32 bg = ImGui::GetColorU32(col);
+ ImU32 fg = col.w == 0 ? GetStyleColorU32(ImPlotCol_InlayText) : CalcTextColor(col);
+ gp.Annotations.AppendV(pos, off, bg, fg, clamp, fmt, args);
+}
+
+void AnnotateV(double x, double y, const ImVec2& offset, const char* fmt, va_list args) {
+ AnnotateEx(x,y,false,ImVec4(0,0,0,0),offset,fmt,args);
+}
+
+void Annotate(double x, double y, const ImVec2& offset, const char* fmt, ...) {
+ va_list args;
+ va_start(args, fmt);
+ AnnotateV(x,y,offset,fmt,args);
+ va_end(args);
+}
+
+void AnnotateV(double x, double y, const ImVec2& offset, const ImVec4& col, const char* fmt, va_list args) {
+ AnnotateEx(x,y,false,col,offset,fmt,args);
+}
+
+void Annotate(double x, double y, const ImVec2& offset, const ImVec4& col, const char* fmt, ...) {
+ va_list args;
+ va_start(args, fmt);
+ AnnotateV(x,y,offset,col,fmt,args);
+ va_end(args);
+}
+
+void AnnotateClampedV(double x, double y, const ImVec2& offset, const char* fmt, va_list args) {
+ AnnotateEx(x,y,true,ImVec4(0,0,0,0),offset,fmt,args);
+}
+
+void AnnotateClamped(double x, double y, const ImVec2& offset, const char* fmt, ...) {
+ va_list args;
+ va_start(args, fmt);
+ AnnotateClampedV(x,y,offset,fmt,args);
+ va_end(args);
+}
+
+void AnnotateClampedV(double x, double y, const ImVec2& offset, const ImVec4& col, const char* fmt, va_list args) {
+ AnnotateEx(x,y,true,col,offset,fmt,args);
+}
+
+void AnnotateClamped(double x, double y, const ImVec2& offset, const ImVec4& col, const char* fmt, ...) {
+ va_list args;
+ va_start(args, fmt);
+ AnnotateClampedV(x,y,offset,col,fmt,args);
+ va_end(args);
+}
+
+bool DragLineX(const char* id, double* value, bool show_label, const ImVec4& col, float thickness) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "DragLineX() needs to be called between BeginPlot() and EndPlot()!");
+ const float grab_size = ImMax(5.0f, thickness);
+ float yt = gp.CurrentPlot->PlotRect.Min.y;
+ float yb = gp.CurrentPlot->PlotRect.Max.y;
+ float x = IM_ROUND(PlotToPixels(*value,0).x);
+ const bool outside = x < (gp.CurrentPlot->PlotRect.Min.x - grab_size / 2) || x > (gp.CurrentPlot->PlotRect.Max.x + grab_size / 2);
+ if (outside)
+ return false;
+ float len = gp.Style.MajorTickLen.x;
+ ImVec4 color = IsColorAuto(col) ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : col;
+ ImU32 col32 = ImGui::ColorConvertFloat4ToU32(color);
+ ImDrawList& DrawList = *GetPlotDrawList();
+ PushPlotClipRect();
+ DrawList.AddLine(ImVec2(x,yt), ImVec2(x,yb), col32, thickness);
+ DrawList.AddLine(ImVec2(x,yt), ImVec2(x,yt+len), col32, 3*thickness);
+ DrawList.AddLine(ImVec2(x,yb), ImVec2(x,yb-len), col32, 3*thickness);
+ PopPlotClipRect();
+ if (gp.CurrentPlot->Selecting || gp.CurrentPlot->Querying)
+ return false;
+ ImVec2 old_cursor_pos = ImGui::GetCursorScreenPos();
+ ImVec2 new_cursor_pos = ImVec2(x - grab_size / 2.0f, yt);
+ ImGui::GetCurrentWindow()->DC.CursorPos = new_cursor_pos;
+ ImGui::InvisibleButton(id, ImVec2(grab_size, yb-yt));
+ ImGui::GetCurrentWindow()->DC.CursorPos = old_cursor_pos;
+ if (ImGui::IsItemHovered() || ImGui::IsItemActive()) {
+ gp.CurrentPlot->PlotHovered = false;
+ ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
+ if (show_label) {
+ char buff[32];
+ LabelAxisValue(gp.CurrentPlot->XAxis, gp.XTicks, *value, buff, 32);
+ gp.Annotations.Append(ImVec2(x,yb),ImVec2(0,0),col32,CalcTextColor(color),true,"%s = %s", id, buff);
+ }
+ }
+ bool dragging = false;
+ if (ImGui::IsItemActive() && ImGui::IsMouseDragging(0)) {
+ *value = ImPlot::GetPlotMousePos().x;
+ *value = ImClamp(*value, gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max);
+ dragging = true;
+ }
+ return dragging;
+}
+
+bool DragLineY(const char* id, double* value, bool show_label, const ImVec4& col, float thickness) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "DragLineY() needs to be called between BeginPlot() and EndPlot()!");
+ const float grab_size = ImMax(5.0f, thickness);
+ float xl = gp.CurrentPlot->PlotRect.Min.x;
+ float xr = gp.CurrentPlot->PlotRect.Max.x;
+ float y = IM_ROUND(PlotToPixels(0, *value).y);
+ const bool outside = y < (gp.CurrentPlot->PlotRect.Min.y - grab_size / 2) || y > (gp.CurrentPlot->PlotRect.Max.y + grab_size / 2);
+ if (outside)
+ return false;
+ float len = gp.Style.MajorTickLen.y;
+ ImVec4 color = IsColorAuto(col) ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : col;
+ ImU32 col32 = ImGui::ColorConvertFloat4ToU32(color);
+ ImDrawList& DrawList = *GetPlotDrawList();
+ PushPlotClipRect();
+ DrawList.AddLine(ImVec2(xl,y), ImVec2(xr,y), col32, thickness);
+ DrawList.AddLine(ImVec2(xl,y), ImVec2(xl+len,y), col32, 3*thickness);
+ DrawList.AddLine(ImVec2(xr,y), ImVec2(xr-len,y), col32, 3*thickness);
+ PopPlotClipRect();
+ if (gp.CurrentPlot->Selecting || gp.CurrentPlot->Querying)
+ return false;
+ ImVec2 old_cursor_pos = ImGui::GetCursorScreenPos();
+ ImVec2 new_cursor_pos = ImVec2(xl, y - grab_size / 2.0f);
+ ImGui::SetItemAllowOverlap();
+ ImGui::GetCurrentWindow()->DC.CursorPos = new_cursor_pos;
+ ImGui::InvisibleButton(id, ImVec2(xr - xl, grab_size));
+ ImGui::GetCurrentWindow()->DC.CursorPos = old_cursor_pos;
+ int yax = GetCurrentYAxis();
+ if (ImGui::IsItemHovered() || ImGui::IsItemActive()) {
+ gp.CurrentPlot->PlotHovered = false;
+ ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeNS);
+ if (show_label) {
+ char buff[32];
+ LabelAxisValue(gp.CurrentPlot->YAxis[yax], gp.YTicks[yax], *value, buff, 32);
+ gp.Annotations.Append(ImVec2(yax == 0 ? xl : xr,y), ImVec2(0,0), col32, CalcTextColor(color), true, "%s = %s", id, buff);
+ }
+ }
+ bool dragging = false;
+ if (ImGui::IsItemActive() && ImGui::IsMouseDragging(0)) {
+ *value = ImPlot::GetPlotMousePos().y;
+ *value = ImClamp(*value, gp.CurrentPlot->YAxis[yax].Range.Min, gp.CurrentPlot->YAxis[yax].Range.Max);
+ dragging = true;
+ }
+ return dragging;
+}
+
+bool DragPoint(const char* id, double* x, double* y, bool show_label, const ImVec4& col, float radius) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "DragPoint() needs to be called between BeginPlot() and EndPlot()!");
+ const float grab_size = ImMax(5.0f, 2*radius);
+ const bool outside = !GetPlotLimits().Contains(*x,*y);
+ if (outside)
+ return false;
+ const ImVec4 color = IsColorAuto(col) ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : col;
+ const ImU32 col32 = ImGui::ColorConvertFloat4ToU32(color);
+ ImDrawList& DrawList = *GetPlotDrawList();
+ const ImVec2 pos = PlotToPixels(*x,*y);
+ int yax = GetCurrentYAxis();
+ ImVec2 old_cursor_pos = ImGui::GetCursorScreenPos();
+ ImVec2 new_cursor_pos = ImVec2(pos - ImVec2(grab_size,grab_size)*0.5f);
+ ImGui::GetCurrentWindow()->DC.CursorPos = new_cursor_pos;
+ ImGui::InvisibleButton(id, ImVec2(grab_size, grab_size));
+ ImGui::GetCurrentWindow()->DC.CursorPos = old_cursor_pos;
+ PushPlotClipRect();
+ if (ImGui::IsItemHovered() || ImGui::IsItemActive()) {
+ DrawList.AddCircleFilled(pos, 1.5f*radius, (col32));
+ gp.CurrentPlot->PlotHovered = false;
+ if (show_label) {
+ ImVec2 label_pos = pos + ImVec2(16 * GImGui->Style.MouseCursorScale, 8 * GImGui->Style.MouseCursorScale);
+ char buff1[32];
+ char buff2[32];
+ LabelAxisValue(gp.CurrentPlot->XAxis, gp.XTicks, *x, buff1, 32);
+ LabelAxisValue(gp.CurrentPlot->YAxis[yax], gp.YTicks[yax], *y, buff2, 32);
+ gp.Annotations.Append(label_pos, ImVec2(0.0001f,0.00001f), col32, CalcTextColor(color), true, "%s = %s,%s", id, buff1, buff2);
+ }
+ }
+ else {
+ DrawList.AddCircleFilled(pos, radius, col32);
+ }
+ PopPlotClipRect();
+
+
+ bool dragging = false;
+ if (ImGui::IsItemActive() && ImGui::IsMouseDragging(0)) {
+ *x = ImPlot::GetPlotMousePos().x;
+ *y = ImPlot::GetPlotMousePos().y;
+ *x = ImClamp(*x, gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max);
+ *y = ImClamp(*y, gp.CurrentPlot->YAxis[yax].Range.Min, gp.CurrentPlot->YAxis[yax].Range.Max);
+ dragging = true;
+ }
+ return dragging;
+}
+
+//-----------------------------------------------------------------------------
+
+#define IMPLOT_ID_PLT 10030910
+#define IMPLOT_ID_LEG 10030911
+#define IMPLOT_ID_XAX 10030912
+#define IMPLOT_ID_YAX 10030913
+
+bool BeginDragDropTargetEx(int id, const ImRect& rect) {
+ ImGuiContext& G = *GImGui;
+ const ImGuiID ID = G.CurrentWindow->GetID(id);
+ if (ImGui::ItemAdd(rect, ID, &rect) &&
+ ImGui::BeginDragDropTarget())
+ return true;
+ return false;
+}
+
+bool BeginDragDropTarget() {
+ return BeginDragDropTargetEx(IMPLOT_ID_PLT, GImPlot->CurrentPlot->PlotRect);
+}
+
+bool BeginDragDropTargetX() {
+ return BeginDragDropTargetEx(IMPLOT_ID_XAX, GImPlot->CurrentPlot->XAxis.HoverRect);
+}
+
+bool BeginDragDropTargetY(ImPlotYAxis axis) {
+ return BeginDragDropTargetEx(IMPLOT_ID_YAX + axis, GImPlot->CurrentPlot->YAxis[axis].HoverRect);
+}
+
+bool BeginDragDropTargetLegend() {
+ return !ImHasFlag(GImPlot->CurrentPlot->Flags,ImPlotFlags_NoLegend) &&
+ BeginDragDropTargetEx(IMPLOT_ID_LEG, GImPlot->CurrentPlot->LegendRect);
+}
+
+void EndDragDropTarget() {
+ ImGui::EndDragDropTarget();
+}
+
+bool BeginDragDropSourceEx(ImGuiID source_id, bool is_hovered, ImGuiDragDropFlags flags, ImGuiKeyModFlags key_mods) {
+ ImGuiContext& g = *GImGui;
+ ImGuiWindow* window = g.CurrentWindow;
+ ImGuiMouseButton mouse_button = ImGuiMouseButton_Left;
+
+ if (g.IO.MouseDown[mouse_button] == false) {
+ if (g.ActiveId == source_id)
+ ImGui::ClearActiveID();
+ return false;
+ }
+
+ if (is_hovered && g.IO.MouseClicked[mouse_button] && g.IO.KeyMods == key_mods) {
+ ImGui::SetActiveID(source_id, window);
+ ImGui::FocusWindow(window);
+ }
+
+ if (g.ActiveId != source_id) {
+ return false;
+ }
+
+ g.ActiveIdAllowOverlap = is_hovered;
+ g.ActiveIdUsingNavDirMask = ~(ImU32)0;
+ g.ActiveIdUsingNavInputMask = ~(ImU32)0;
+ g.ActiveIdUsingKeyInputMask = ~(ImU64)0;
+
+ if (ImGui::IsMouseDragging(mouse_button)) {
+
+ if (!g.DragDropActive) {
+ ImGui::ClearDragDrop();
+ ImGuiPayload& payload = g.DragDropPayload;
+ payload.SourceId = source_id;
+ payload.SourceParentId = 0;
+ g.DragDropActive = true;
+ g.DragDropSourceFlags = 0;
+ g.DragDropMouseButton = mouse_button;
+ }
+ g.DragDropSourceFrameCount = g.FrameCount;
+ g.DragDropWithinSource = true;
+
+ if (!(flags & ImGuiDragDropFlags_SourceNoPreviewTooltip)) {
+ ImGui::BeginTooltip();
+ if (g.DragDropAcceptIdPrev && (g.DragDropAcceptFlags & ImGuiDragDropFlags_AcceptNoPreviewTooltip)) {
+ ImGuiWindow* tooltip_window = g.CurrentWindow;
+ tooltip_window->SkipItems = true;
+ tooltip_window->HiddenFramesCanSkipItems = 1;
+ }
+ }
+ return true;
+ }
+ return false;
+}
+
+bool BeginDragDropSource(ImGuiKeyModFlags key_mods, ImGuiDragDropFlags flags) {
+ if (ImGui::GetIO().KeyMods == key_mods) {
+ GImPlot->CurrentPlot->XAxis.Dragging = false;
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i)
+ GImPlot->CurrentPlot->YAxis[i].Dragging = false;
+ }
+ const ImGuiID ID = GImGui->CurrentWindow->GetID(IMPLOT_ID_PLT);
+ ImRect rect = GImPlot->CurrentPlot->PlotRect;
+ return ImGui::ItemAdd(rect, ID, &rect) && BeginDragDropSourceEx(ID, GImPlot->CurrentPlot->PlotHovered, flags, key_mods);
+}
+
+bool BeginDragDropSourceX(ImGuiKeyModFlags key_mods, ImGuiDragDropFlags flags) {
+ if (ImGui::GetIO().KeyMods == key_mods)
+ GImPlot->CurrentPlot->XAxis.Dragging = false;
+ const ImGuiID ID = GImGui->CurrentWindow->GetID(IMPLOT_ID_XAX);
+ ImRect rect = GImPlot->CurrentPlot->XAxis.HoverRect;
+ return ImGui::ItemAdd(rect, ID, &rect) && BeginDragDropSourceEx(ID, GImPlot->CurrentPlot->XAxis.ExtHovered, flags, key_mods);
+}
+
+bool BeginDragDropSourceY(ImPlotYAxis axis, ImGuiKeyModFlags key_mods, ImGuiDragDropFlags flags) {
+ if (ImGui::GetIO().KeyMods == key_mods)
+ GImPlot->CurrentPlot->YAxis[axis].Dragging = false;
+ const ImGuiID ID = GImGui->CurrentWindow->GetID(IMPLOT_ID_YAX + axis);
+ ImRect rect = GImPlot->CurrentPlot->YAxis[axis].HoverRect;
+ return ImGui::ItemAdd(rect, ID, &rect) && BeginDragDropSourceEx(ID, GImPlot->CurrentPlot->YAxis[axis].ExtHovered, flags, key_mods);
+}
+
+bool BeginDragDropSourceItem(const char* label_id, ImGuiDragDropFlags flags) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "BeginDragDropSourceItem() needs to be called between BeginPlot() and EndPlot()!");
+ ImGuiID source_id = ImGui::GetID(label_id);
+ ImPlotItem* item = gp.CurrentPlot->Items.GetByKey(source_id);
+ bool is_hovered = item && item->LegendHovered;
+ return BeginDragDropSourceEx(source_id, is_hovered, flags, ImGuiKeyModFlags_None);
+}
+
+void EndDragDropSource() {
+ ImGui::EndDragDropSource();
+}
+
+void ItemIcon(const ImVec4& col) {
+ ItemIcon(ImGui::ColorConvertFloat4ToU32(col));
+}
+
+void ItemIcon(ImU32 col) {
+ const float txt_size = ImGui::GetTextLineHeight();
+ ImVec2 size(txt_size-4,txt_size);
+ ImGuiWindow* window = ImGui::GetCurrentWindow();
+ ImVec2 pos = window->DC.CursorPos;
+ ImGui::GetWindowDrawList()->AddRectFilled(pos + ImVec2(0,2), pos + size - ImVec2(0,2), col);
+ ImGui::Dummy(size);
+}
+
+void ColormapIcon(ImPlotColormap cmap) {
+ ImPlotContext& gp = *GImPlot;
+ const float txt_size = ImGui::GetTextLineHeight();
+ ImVec2 size(txt_size-4,txt_size);
+ ImGuiWindow* window = ImGui::GetCurrentWindow();
+ ImVec2 pos = window->DC.CursorPos;
+ ImRect rect(pos+ImVec2(0,2),pos+size-ImVec2(0,2));
+ ImDrawList& DrawList = *ImGui::GetWindowDrawList();
+ RenderColorBar(gp.ColormapData.GetKeys(cmap),gp.ColormapData.GetKeyCount(cmap),DrawList,rect,false,false,!gp.ColormapData.IsQual(cmap));
+ ImGui::Dummy(size);
+}
+
+//-----------------------------------------------------------------------------
+
+void SetLegendLocation(ImPlotLocation location, ImPlotOrientation orientation, bool outside) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "SetLegendLocation() needs to be called between BeginPlot() and EndPlot()!");
+ gp.CurrentPlot->LegendLocation = location;
+ gp.CurrentPlot->LegendOrientation = orientation;
+ if (gp.CurrentPlot->LegendOutside != outside)
+ gp.CurrentPlot->LegendFlipSideNextFrame = true;
+}
+
+void SetMousePosLocation(ImPlotLocation location) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "SetMousePosLocation() needs to be called between BeginPlot() and EndPlot()!");
+ gp.CurrentPlot->MousePosLocation = location;
+}
+
+bool IsLegendEntryHovered(const char* label_id) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "IsPlotItemHighlight() needs to be called between BeginPlot() and EndPlot()!");
+ ImGuiID id = ImGui::GetID(label_id);
+ ImPlotItem* item = gp.CurrentPlot->Items.GetByKey(id);
+ return item && item->LegendHovered;
+}
+
+bool BeginLegendPopup(const char* label_id, ImGuiMouseButton mouse_button) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "BeginLegendPopup() needs to be called between BeginPlot() and EndPlot()!");
+ ImGuiWindow* window = GImGui->CurrentWindow;
+ if (window->SkipItems)
+ return false;
+ ImGuiID id = ImGui::GetID(label_id);
+ if (ImGui::IsMouseReleased(mouse_button)) {
+ ImPlotItem* item = gp.CurrentPlot->Items.GetByKey(id);
+ if (item && item->LegendHovered)
+ ImGui::OpenPopupEx(id);
+ }
+ return ImGui::BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings);
+}
+
+void EndLegendPopup() {
+ ImGui::EndPopup();
+}
+
+void ShowAltLegend(const char* title_id, ImPlotOrientation orientation, const ImVec2 size, bool interactable) {
+ ImPlotContext& gp = *GImPlot;
+ ImGuiContext &G = *GImGui;
+ ImGuiWindow * Window = G.CurrentWindow;
+ if (Window->SkipItems)
+ return;
+ ImDrawList &DrawList = *Window->DrawList;
+ ImPlotPlot* plot = GetPlot(title_id);
+ ImVec2 legend_size;
+ ImVec2 default_size = gp.Style.LegendPadding * 2;
+ if (plot != NULL) {
+ legend_size = CalcLegendSize(*plot, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, orientation);
+ default_size = legend_size + gp.Style.LegendPadding * 2;
+ }
+ ImVec2 frame_size = ImGui::CalcItemSize(size, default_size.x, default_size.y);
+ ImRect bb_frame = ImRect(Window->DC.CursorPos, Window->DC.CursorPos + frame_size);
+ ImGui::ItemSize(bb_frame);
+ if (!ImGui::ItemAdd(bb_frame, 0, &bb_frame))
+ return;
+ ImGui::RenderFrame(bb_frame.Min, bb_frame.Max, GetStyleColorU32(ImPlotCol_FrameBg), true, G.Style.FrameRounding);
+ DrawList.PushClipRect(bb_frame.Min, bb_frame.Max, true);
+ if (plot != NULL) {
+ const ImVec2 legend_pos = GetLocationPos(bb_frame, legend_size, 0, gp.Style.LegendPadding);
+ const ImRect legend_bb(legend_pos, legend_pos + legend_size);
+ interactable = interactable && bb_frame.Contains(ImGui::GetIO().MousePos);
+ // render legend box
+ ImU32 col_bg = GetStyleColorU32(ImPlotCol_LegendBg);
+ ImU32 col_bd = GetStyleColorU32(ImPlotCol_LegendBorder);
+ DrawList.AddRectFilled(legend_bb.Min, legend_bb.Max, col_bg);
+ DrawList.AddRect(legend_bb.Min, legend_bb.Max, col_bd);
+ // render entries
+ ShowLegendEntries(*plot, legend_bb, interactable, gp.Style.LegendInnerPadding, gp.Style.LegendSpacing, orientation, DrawList);
+ }
+ DrawList.PopClipRect();
+}
+
+//-----------------------------------------------------------------------------
+// STYLING
+//-----------------------------------------------------------------------------
+
+ImPlotStyle& GetStyle() {
+ ImPlotContext& gp = *GImPlot;
+ return gp.Style;
+}
+
+void PushStyleColor(ImPlotCol idx, ImU32 col) {
+ ImPlotContext& gp = *GImPlot;
+ ImGuiColorMod backup;
+ backup.Col = idx;
+ backup.BackupValue = gp.Style.Colors[idx];
+ gp.ColorModifiers.push_back(backup);
+ gp.Style.Colors[idx] = ImGui::ColorConvertU32ToFloat4(col);
+}
+
+void PushStyleColor(ImPlotCol idx, const ImVec4& col) {
+ ImPlotContext& gp = *GImPlot;
+ ImGuiColorMod backup;
+ backup.Col = idx;
+ backup.BackupValue = gp.Style.Colors[idx];
+ gp.ColorModifiers.push_back(backup);
+ gp.Style.Colors[idx] = col;
+}
+
+void PopStyleColor(int count) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(count <= gp.ColorModifiers.Size, "You can't pop more modifiers than have been pushed!");
+ while (count > 0)
+ {
+ ImGuiColorMod& backup = gp.ColorModifiers.back();
+ gp.Style.Colors[backup.Col] = backup.BackupValue;
+ gp.ColorModifiers.pop_back();
+ count--;
+ }
+}
+
+void PushStyleVar(ImPlotStyleVar idx, float val) {
+ ImPlotContext& gp = *GImPlot;
+ const ImPlotStyleVarInfo* var_info = GetPlotStyleVarInfo(idx);
+ if (var_info->Type == ImGuiDataType_Float && var_info->Count == 1) {
+ float* pvar = (float*)var_info->GetVarPtr(&gp.Style);
+ gp.StyleModifiers.push_back(ImGuiStyleMod(idx, *pvar));
+ *pvar = val;
+ return;
+ }
+ IM_ASSERT(0 && "Called PushStyleVar() float variant but variable is not a float!");
+}
+
+void PushStyleVar(ImPlotStyleVar idx, int val) {
+ ImPlotContext& gp = *GImPlot;
+ const ImPlotStyleVarInfo* var_info = GetPlotStyleVarInfo(idx);
+ if (var_info->Type == ImGuiDataType_S32 && var_info->Count == 1) {
+ int* pvar = (int*)var_info->GetVarPtr(&gp.Style);
+ gp.StyleModifiers.push_back(ImGuiStyleMod(idx, *pvar));
+ *pvar = val;
+ return;
+ }
+ else if (var_info->Type == ImGuiDataType_Float && var_info->Count == 1) {
+ float* pvar = (float*)var_info->GetVarPtr(&gp.Style);
+ gp.StyleModifiers.push_back(ImGuiStyleMod(idx, *pvar));
+ *pvar = (float)val;
+ return;
+ }
+ IM_ASSERT(0 && "Called PushStyleVar() int variant but variable is not a int!");
+}
+
+void PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
+{
+ ImPlotContext& gp = *GImPlot;
+ const ImPlotStyleVarInfo* var_info = GetPlotStyleVarInfo(idx);
+ if (var_info->Type == ImGuiDataType_Float && var_info->Count == 2)
+ {
+ ImVec2* pvar = (ImVec2*)var_info->GetVarPtr(&gp.Style);
+ gp.StyleModifiers.push_back(ImGuiStyleMod(idx, *pvar));
+ *pvar = val;
+ return;
+ }
+ IM_ASSERT(0 && "Called PushStyleVar() ImVec2 variant but variable is not a ImVec2!");
+}
+
+void PopStyleVar(int count) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(count <= gp.StyleModifiers.Size, "You can't pop more modifiers than have been pushed!");
+ while (count > 0) {
+ ImGuiStyleMod& backup = gp.StyleModifiers.back();
+ const ImPlotStyleVarInfo* info = GetPlotStyleVarInfo(backup.VarIdx);
+ void* data = info->GetVarPtr(&gp.Style);
+ if (info->Type == ImGuiDataType_Float && info->Count == 1) {
+ ((float*)data)[0] = backup.BackupFloat[0];
+ }
+ else if (info->Type == ImGuiDataType_Float && info->Count == 2) {
+ ((float*)data)[0] = backup.BackupFloat[0];
+ ((float*)data)[1] = backup.BackupFloat[1];
+ }
+ else if (info->Type == ImGuiDataType_S32 && info->Count == 1) {
+ ((int*)data)[0] = backup.BackupInt[0];
+ }
+ gp.StyleModifiers.pop_back();
+ count--;
+ }
+}
+
+//------------------------------------------------------------------------------
+// COLORMAPS
+//------------------------------------------------------------------------------
+
+ImPlotColormap AddColormap(const char* name, const ImVec4* colormap, int size, bool qual) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(size > 1, "The colormap size must be greater than 1!");
+ IM_ASSERT_USER_ERROR(gp.ColormapData.GetIndex(name) == -1, "The colormap name has already been used!");
+ ImVector<ImU32> buffer;
+ buffer.resize(size);
+ for (int i = 0; i < size; ++i)
+ buffer[i] = ImGui::ColorConvertFloat4ToU32(colormap[i]);
+ return gp.ColormapData.Append(name, buffer.Data, size, qual);
+}
+
+ImPlotColormap AddColormap(const char* name, const ImU32* colormap, int size, bool qual) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(size > 1, "The colormap size must be greater than 1!");
+ IM_ASSERT_USER_ERROR(gp.ColormapData.GetIndex(name) == -1, "The colormap name has already be used!");
+ return gp.ColormapData.Append(name, colormap, size, qual);
+}
+
+int GetColormapCount() {
+ ImPlotContext& gp = *GImPlot;
+ return gp.ColormapData.Count;
+}
+
+const char* GetColormapName(ImPlotColormap colormap) {
+ ImPlotContext& gp = *GImPlot;
+ return gp.ColormapData.GetName(colormap);
+}
+
+ImPlotColormap GetColormapIndex(const char* name) {
+ ImPlotContext& gp = *GImPlot;
+ return gp.ColormapData.GetIndex(name);
+}
+
+void PushColormap(ImPlotColormap colormap) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(colormap >= 0 && colormap < gp.ColormapData.Count, "The colormap index is invalid!");
+ gp.ColormapModifiers.push_back(gp.Style.Colormap);
+ gp.Style.Colormap = colormap;
+}
+
+void PushColormap(const char* name) {
+ ImPlotContext& gp = *GImPlot;
+ ImPlotColormap idx = gp.ColormapData.GetIndex(name);
+ IM_ASSERT_USER_ERROR(idx != -1, "The colormap name is invalid!");
+ PushColormap(idx);
+}
+
+void PopColormap(int count) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(count <= gp.ColormapModifiers.Size, "You can't pop more modifiers than have been pushed!");
+ while (count > 0) {
+ const ImPlotColormap& backup = gp.ColormapModifiers.back();
+ gp.Style.Colormap = backup;
+ gp.ColormapModifiers.pop_back();
+ count--;
+ }
+}
+
+ImU32 NextColormapColorU32() {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "NextColormapColor() needs to be called between BeginPlot() and EndPlot()!");
+ int idx = gp.CurrentPlot->ColormapIdx % gp.ColormapData.GetKeyCount(gp.Style.Colormap);
+ ImU32 col = gp.ColormapData.GetKeyColor(gp.Style.Colormap, idx);
+ gp.CurrentPlot->ColormapIdx++;
+ return col;
+}
+
+ImVec4 NextColormapColor() {
+ return ImGui::ColorConvertU32ToFloat4(NextColormapColorU32());
+}
+
+int GetColormapSize(ImPlotColormap cmap) {
+ ImPlotContext& gp = *GImPlot;
+ cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
+ IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
+ return gp.ColormapData.GetKeyCount(gp.Style.Colormap);
+}
+
+ImU32 GetColormapColorU32(int idx, ImPlotColormap cmap) {
+ ImPlotContext& gp = *GImPlot;
+ cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
+ IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
+ idx = idx % gp.ColormapData.GetKeyCount(cmap);
+ return gp.ColormapData.GetKeyColor(cmap, idx);
+}
+
+ImVec4 GetColormapColor(int idx, ImPlotColormap cmap) {
+ return ImGui::ColorConvertU32ToFloat4(GetColormapColorU32(idx,cmap));
+}
+
+ImU32 SampleColormapU32(float t, ImPlotColormap cmap) {
+ ImPlotContext& gp = *GImPlot;
+ cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
+ IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
+ return gp.ColormapData.LerpTable(cmap, t);
+}
+
+ImVec4 SampleColormap(float t, ImPlotColormap cmap) {
+ return ImGui::ColorConvertU32ToFloat4(SampleColormapU32(t,cmap));
+}
+
+void RenderColorBar(const ImU32* colors, int size, ImDrawList& DrawList, const ImRect& bounds, bool vert, bool reversed, bool continuous) {
+ const int n = continuous ? size - 1 : size;
+ ImU32 col1, col2;
+ if (vert) {
+ const float step = bounds.GetHeight() / n;
+ ImRect rect(bounds.Min.x, bounds.Min.y, bounds.Max.x, bounds.Min.y + step);
+ for (int i = 0; i < n; ++i) {
+ if (reversed) {
+ col1 = colors[size-i-1];
+ col2 = continuous ? colors[size-i-2] : col1;
+ }
+ else {
+ col1 = colors[i];
+ col2 = continuous ? colors[i+1] : col1;
+ }
+ DrawList.AddRectFilledMultiColor(rect.Min, rect.Max, col1, col1, col2, col2);
+ rect.TranslateY(step);
+ }
+ }
+ else {
+ const float step = bounds.GetWidth() / n;
+ ImRect rect(bounds.Min.x, bounds.Min.y, bounds.Min.x + step, bounds.Max.y);
+ for (int i = 0; i < n; ++i) {
+ if (reversed) {
+ col1 = colors[size-i-1];
+ col2 = continuous ? colors[size-i-2] : col1;
+ }
+ else {
+ col1 = colors[i];
+ col2 = continuous ? colors[i+1] : col1;
+ }
+ DrawList.AddRectFilledMultiColor(rect.Min, rect.Max, col1, col2, col2, col1);
+ rect.TranslateX(step);
+ }
+ }
+}
+
+void ColormapScale(const char* label, double scale_min, double scale_max, const ImVec2& size, ImPlotColormap cmap, const char* fmt) {
+ ImGuiContext &G = *GImGui;
+ ImGuiWindow * Window = G.CurrentWindow;
+ if (Window->SkipItems)
+ return;
+
+ const ImGuiID ID = Window->GetID(label);
+ ImVec2 label_size(0,0);
+ label_size = ImGui::CalcTextSize(label,NULL,true);
+
+ ImPlotContext& gp = *GImPlot;
+ cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
+ IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
+
+ ImVec2 frame_size = ImGui::CalcItemSize(size, 0, gp.Style.PlotDefaultSize.y);
+ if (frame_size.y < gp.Style.PlotMinSize.y && size.y < 0.0f)
+ frame_size.y = gp.Style.PlotMinSize.y;
+
+ ImPlotRange range(scale_min,scale_max);
+ gp.CTicks.Reset();
+ AddTicksDefault(range, frame_size.y, ImPlotOrientation_Vertical, gp.CTicks, fmt);
+
+ const float txt_off = gp.Style.LabelPadding.x;
+ const float pad_right = txt_off + gp.CTicks.MaxWidth + (label_size.x > 0 ? txt_off + label_size.y : 0);
+ float bar_w = 20;
+
+ if (frame_size.x == 0)
+ frame_size.x = bar_w + pad_right + 2 * gp.Style.PlotPadding.x;
+ else {
+ bar_w = frame_size.x - (pad_right + 2 * gp.Style.PlotPadding.x);
+ if (bar_w < gp.Style.MajorTickLen.y)
+ bar_w = gp.Style.MajorTickLen.y;
+ }
+
+ ImDrawList &DrawList = *Window->DrawList;
+ ImRect bb_frame = ImRect(Window->DC.CursorPos, Window->DC.CursorPos + frame_size);
+ ImGui::ItemSize(bb_frame);
+ if (!ImGui::ItemAdd(bb_frame, ID, &bb_frame))
+ return;
+
+ ImGui::RenderFrame(bb_frame.Min, bb_frame.Max, GetStyleColorU32(ImPlotCol_FrameBg), true, G.Style.FrameRounding);
+ ImRect bb_grad(bb_frame.Min + gp.Style.PlotPadding, bb_frame.Min + ImVec2(bar_w + gp.Style.PlotPadding.x, frame_size.y - gp.Style.PlotPadding.y));
+
+ ImGui::PushClipRect(bb_frame.Min, bb_frame.Max, true);
+ RenderColorBar(gp.ColormapData.GetKeys(cmap), gp.ColormapData.GetKeyCount(cmap), DrawList, bb_grad, true, true, !gp.ColormapData.IsQual(cmap));
+ const ImU32 col_tick = GetStyleColorU32(ImPlotCol_YAxis);
+ const ImU32 col_text = ImGui::GetColorU32(ImGuiCol_Text);
+ for (int i = 0; i < gp.CTicks.Size; ++i) {
+ const float ypos = ImRemap((float)gp.CTicks.Ticks[i].PlotPos, (float)range.Max, (float)range.Min, bb_grad.Min.y, bb_grad.Max.y);
+ const float tick_width = gp.CTicks.Ticks[i].Major ? gp.Style.MajorTickLen.y : gp.Style.MinorTickLen.y;
+ const float tick_thick = gp.CTicks.Ticks[i].Major ? gp.Style.MajorTickSize.y : gp.Style.MinorTickSize.y;
+ if (ypos < bb_grad.Max.y - 2 && ypos > bb_grad.Min.y + 2)
+ DrawList.AddLine(ImVec2(bb_grad.Max.x-1, ypos), ImVec2(bb_grad.Max.x - tick_width, ypos), col_tick, tick_thick);
+ DrawList.AddText(ImVec2(bb_grad.Max.x-1, ypos) + ImVec2(txt_off, -gp.CTicks.Ticks[i].LabelSize.y * 0.5f), col_text, gp.CTicks.GetText(i));
+ }
+ if (label_size.x > 0) {
+ ImVec2 label_pos(bb_grad.Max.x - 1 + 2*txt_off + gp.CTicks.MaxWidth, bb_grad.GetCenter().y + label_size.x*0.5f );
+ const char* label_end = ImGui::FindRenderedTextEnd(label);
+ AddTextVertical(&DrawList,label_pos,col_text,label,label_end);
+ }
+ DrawList.AddRect(bb_grad.Min, bb_grad.Max, GetStyleColorU32(ImPlotCol_PlotBorder));
+ ImGui::PopClipRect();
+}
+
+bool ColormapSlider(const char* label, float* t, ImVec4* out, const char* format, ImPlotColormap cmap) {
+ *t = ImClamp(*t,0.0f,1.0f);
+ ImGuiContext &G = *GImGui;
+ ImGuiWindow * Window = G.CurrentWindow;
+ if (Window->SkipItems)
+ return false;
+ ImPlotContext& gp = *GImPlot;
+ cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
+ IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
+ const ImU32* keys = GImPlot->ColormapData.GetKeys(cmap);
+ const int count = GImPlot->ColormapData.GetKeyCount(cmap);
+ const bool qual = GImPlot->ColormapData.IsQual(cmap);
+ const ImVec2 pos = ImGui::GetCurrentWindow()->DC.CursorPos;
+ const float w = ImGui::CalcItemWidth();
+ const float h = ImGui::GetFrameHeight();
+ const ImRect rect = ImRect(pos.x,pos.y,pos.x+w,pos.y+h);
+ RenderColorBar(keys,count,*ImGui::GetWindowDrawList(),rect,false,false,!qual);
+ const ImU32 grab = CalcTextColor(GImPlot->ColormapData.LerpTable(cmap,*t));
+ // const ImU32 text = CalcTextColor(GImPlot->ColormapData.LerpTable(cmap,0.5f));
+ ImGui::PushStyleColor(ImGuiCol_FrameBg,IM_COL32_BLACK_TRANS);
+ ImGui::PushStyleColor(ImGuiCol_FrameBgActive,IM_COL32_BLACK_TRANS);
+ ImGui::PushStyleColor(ImGuiCol_FrameBgHovered,ImVec4(1,1,1,0.1f));
+ ImGui::PushStyleColor(ImGuiCol_SliderGrab,grab);
+ ImGui::PushStyleColor(ImGuiCol_SliderGrabActive, grab);
+ ImGui::PushStyleVar(ImGuiStyleVar_GrabMinSize,2);
+ ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding,0);
+ const bool changed = ImGui::SliderFloat(label,t,0,1,format);
+ ImGui::PopStyleColor(5);
+ ImGui::PopStyleVar(2);
+ if (out != NULL)
+ *out = ImGui::ColorConvertU32ToFloat4(GImPlot->ColormapData.LerpTable(cmap,*t));
+ return changed;
+}
+
+bool ColormapButton(const char* label, const ImVec2& size_arg, ImPlotColormap cmap) {
+ ImGuiContext &G = *GImGui;
+ const ImGuiStyle& style = G.Style;
+ ImGuiWindow * Window = G.CurrentWindow;
+ if (Window->SkipItems)
+ return false;
+ ImPlotContext& gp = *GImPlot;
+ cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
+ IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
+ const ImU32* keys = GImPlot->ColormapData.GetKeys(cmap);
+ const int count = GImPlot->ColormapData.GetKeyCount(cmap);
+ const bool qual = GImPlot->ColormapData.IsQual(cmap);
+ const ImVec2 pos = ImGui::GetCurrentWindow()->DC.CursorPos;
+ const ImVec2 label_size = ImGui::CalcTextSize(label, NULL, true);
+ ImVec2 size = ImGui::CalcItemSize(size_arg, label_size.x + style.FramePadding.x * 2.0f, label_size.y + style.FramePadding.y * 2.0f);
+ const ImRect rect = ImRect(pos.x,pos.y,pos.x+size.x,pos.y+size.y);
+ RenderColorBar(keys,count,*ImGui::GetWindowDrawList(),rect,false,false,!qual);
+ const ImU32 text = CalcTextColor(GImPlot->ColormapData.LerpTable(cmap,G.Style.ButtonTextAlign.x));
+ ImGui::PushStyleColor(ImGuiCol_Button,IM_COL32_BLACK_TRANS);
+ ImGui::PushStyleColor(ImGuiCol_ButtonHovered,ImVec4(1,1,1,0.1f));
+ ImGui::PushStyleColor(ImGuiCol_ButtonActive,ImVec4(1,1,1,0.2f));
+ ImGui::PushStyleColor(ImGuiCol_Text,text);
+ ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding,0);
+ const bool pressed = ImGui::Button(label,size);
+ ImGui::PopStyleColor(4);
+ ImGui::PopStyleVar(1);
+ return pressed;
+}
+
+
+//-----------------------------------------------------------------------------
+// Style Editor etc.
+//-----------------------------------------------------------------------------
+
+static void HelpMarker(const char* desc) {
+ ImGui::TextDisabled("(?)");
+ if (ImGui::IsItemHovered()) {
+ ImGui::BeginTooltip();
+ ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
+ ImGui::TextUnformatted(desc);
+ ImGui::PopTextWrapPos();
+ ImGui::EndTooltip();
+ }
+}
+
+bool ShowStyleSelector(const char* label)
+{
+ static int style_idx = -1;
+ if (ImGui::Combo(label, &style_idx, "Auto\0Classic\0Dark\0Light\0"))
+ {
+ switch (style_idx)
+ {
+ case 0: StyleColorsAuto(); break;
+ case 1: StyleColorsClassic(); break;
+ case 2: StyleColorsDark(); break;
+ case 3: StyleColorsLight(); break;
+ }
+ return true;
+ }
+ return false;
+}
+
+bool ShowColormapSelector(const char* label) {
+ ImPlotContext& gp = *GImPlot;
+ bool set = false;
+ if (ImGui::BeginCombo(label, gp.ColormapData.GetName(gp.Style.Colormap))) {
+ for (int i = 0; i < gp.ColormapData.Count; ++i) {
+ const char* name = gp.ColormapData.GetName(i);
+ if (ImGui::Selectable(name, gp.Style.Colormap == i)) {
+ gp.Style.Colormap = i;
+ ImPlot::BustItemCache();
+ set = true;
+ }
+ }
+ ImGui::EndCombo();
+ }
+ return set;
+}
+
+void ShowStyleEditor(ImPlotStyle* ref) {
+ ImPlotContext& gp = *GImPlot;
+ ImPlotStyle& style = GetStyle();
+ static ImPlotStyle ref_saved_style;
+ // Default to using internal storage as reference
+ static bool init = true;
+ if (init && ref == NULL)
+ ref_saved_style = style;
+ init = false;
+ if (ref == NULL)
+ ref = &ref_saved_style;
+
+ if (ImPlot::ShowStyleSelector("Colors##Selector"))
+ ref_saved_style = style;
+
+ // Save/Revert button
+ if (ImGui::Button("Save Ref"))
+ *ref = ref_saved_style = style;
+ ImGui::SameLine();
+ if (ImGui::Button("Revert Ref"))
+ style = *ref;
+ ImGui::SameLine();
+ HelpMarker("Save/Revert in local non-persistent storage. Default Colors definition are not affected. "
+ "Use \"Export\" below to save them somewhere.");
+ if (ImGui::BeginTabBar("##StyleEditor")) {
+ if (ImGui::BeginTabItem("Variables")) {
+ ImGui::Text("Item Styling");
+ ImGui::SliderFloat("LineWeight", &style.LineWeight, 0.0f, 5.0f, "%.1f");
+ ImGui::SliderFloat("MarkerSize", &style.MarkerSize, 2.0f, 10.0f, "%.1f");
+ ImGui::SliderFloat("MarkerWeight", &style.MarkerWeight, 0.0f, 5.0f, "%.1f");
+ ImGui::SliderFloat("FillAlpha", &style.FillAlpha, 0.0f, 1.0f, "%.2f");
+ ImGui::SliderFloat("ErrorBarSize", &style.ErrorBarSize, 0.0f, 10.0f, "%.1f");
+ ImGui::SliderFloat("ErrorBarWeight", &style.ErrorBarWeight, 0.0f, 5.0f, "%.1f");
+ ImGui::SliderFloat("DigitalBitHeight", &style.DigitalBitHeight, 0.0f, 20.0f, "%.1f");
+ ImGui::SliderFloat("DigitalBitGap", &style.DigitalBitGap, 0.0f, 20.0f, "%.1f");
+ float indent = ImGui::CalcItemWidth() - ImGui::GetFrameHeight();
+ ImGui::Indent(ImGui::CalcItemWidth() - ImGui::GetFrameHeight());
+ ImGui::Checkbox("AntiAliasedLines", &style.AntiAliasedLines);
+ ImGui::Unindent(indent);
+ ImGui::Text("Plot Styling");
+ ImGui::SliderFloat("PlotBorderSize", &style.PlotBorderSize, 0.0f, 2.0f, "%.0f");
+ ImGui::SliderFloat("MinorAlpha", &style.MinorAlpha, 0.0f, 1.0f, "%.2f");
+ ImGui::SliderFloat2("MajorTickLen", (float*)&style.MajorTickLen, 0.0f, 20.0f, "%.0f");
+ ImGui::SliderFloat2("MinorTickLen", (float*)&style.MinorTickLen, 0.0f, 20.0f, "%.0f");
+ ImGui::SliderFloat2("MajorTickSize", (float*)&style.MajorTickSize, 0.0f, 2.0f, "%.1f");
+ ImGui::SliderFloat2("MinorTickSize", (float*)&style.MinorTickSize, 0.0f, 2.0f, "%.1f");
+ ImGui::SliderFloat2("MajorGridSize", (float*)&style.MajorGridSize, 0.0f, 2.0f, "%.1f");
+ ImGui::SliderFloat2("MinorGridSize", (float*)&style.MinorGridSize, 0.0f, 2.0f, "%.1f");
+ ImGui::SliderFloat2("PlotDefaultSize", (float*)&style.PlotDefaultSize, 0.0f, 1000, "%.0f");
+ ImGui::SliderFloat2("PlotMinSize", (float*)&style.PlotMinSize, 0.0f, 300, "%.0f");
+ ImGui::Text("Plot Padding");
+ ImGui::SliderFloat2("PlotPadding", (float*)&style.PlotPadding, 0.0f, 20.0f, "%.0f");
+ ImGui::SliderFloat2("LabelPadding", (float*)&style.LabelPadding, 0.0f, 20.0f, "%.0f");
+ ImGui::SliderFloat2("LegendPadding", (float*)&style.LegendPadding, 0.0f, 20.0f, "%.0f");
+ ImGui::SliderFloat2("LegendInnerPadding", (float*)&style.LegendInnerPadding, 0.0f, 10.0f, "%.0f");
+ ImGui::SliderFloat2("LegendSpacing", (float*)&style.LegendSpacing, 0.0f, 5.0f, "%.0f");
+ ImGui::SliderFloat2("MousePosPadding", (float*)&style.MousePosPadding, 0.0f, 20.0f, "%.0f");
+ ImGui::SliderFloat2("AnnotationPadding", (float*)&style.AnnotationPadding, 0.0f, 5.0f, "%.0f");
+ ImGui::SliderFloat2("FitPadding", (float*)&style.FitPadding, 0, 0.2f, "%.2f");
+
+ ImGui::EndTabItem();
+ }
+ if (ImGui::BeginTabItem("Colors")) {
+ static int output_dest = 0;
+ static bool output_only_modified = false;
+
+ if (ImGui::Button("Export", ImVec2(75,0))) {
+ if (output_dest == 0)
+ ImGui::LogToClipboard();
+ else
+ ImGui::LogToTTY();
+ ImGui::LogText("ImVec4* colors = ImPlot::GetStyle().Colors;\n");
+ for (int i = 0; i < ImPlotCol_COUNT; i++) {
+ const ImVec4& col = style.Colors[i];
+ const char* name = ImPlot::GetStyleColorName(i);
+ if (!output_only_modified || memcmp(&col, &ref->Colors[i], sizeof(ImVec4)) != 0) {
+ if (IsColorAuto(i))
+ ImGui::LogText("colors[ImPlotCol_%s]%*s= IMPLOT_AUTO_COL;\n",name,14 - (int)strlen(name), "");
+ else
+ ImGui::LogText("colors[ImPlotCol_%s]%*s= ImVec4(%.2ff, %.2ff, %.2ff, %.2ff);\n",
+ name, 14 - (int)strlen(name), "", col.x, col.y, col.z, col.w);
+ }
+ }
+ ImGui::LogFinish();
+ }
+ ImGui::SameLine(); ImGui::SetNextItemWidth(120); ImGui::Combo("##output_type", &output_dest, "To Clipboard\0To TTY\0");
+ ImGui::SameLine(); ImGui::Checkbox("Only Modified Colors", &output_only_modified);
+
+ static ImGuiTextFilter filter;
+ filter.Draw("Filter colors", ImGui::GetFontSize() * 16);
+
+ static ImGuiColorEditFlags alpha_flags = ImGuiColorEditFlags_AlphaPreviewHalf;
+ if (ImGui::RadioButton("Opaque", alpha_flags == ImGuiColorEditFlags_None)) { alpha_flags = ImGuiColorEditFlags_None; } ImGui::SameLine();
+ if (ImGui::RadioButton("Alpha", alpha_flags == ImGuiColorEditFlags_AlphaPreview)) { alpha_flags = ImGuiColorEditFlags_AlphaPreview; } ImGui::SameLine();
+ if (ImGui::RadioButton("Both", alpha_flags == ImGuiColorEditFlags_AlphaPreviewHalf)) { alpha_flags = ImGuiColorEditFlags_AlphaPreviewHalf; } ImGui::SameLine();
+ HelpMarker(
+ "In the color list:\n"
+ "Left-click on colored square to open color picker,\n"
+ "Right-click to open edit options menu.");
+ ImGui::Separator();
+ ImGui::PushItemWidth(-160);
+ for (int i = 0; i < ImPlotCol_COUNT; i++) {
+ const char* name = ImPlot::GetStyleColorName(i);
+ if (!filter.PassFilter(name))
+ continue;
+ ImGui::PushID(i);
+ ImVec4 temp = GetStyleColorVec4(i);
+ const bool is_auto = IsColorAuto(i);
+ if (!is_auto)
+ ImGui::PushStyleVar(ImGuiStyleVar_Alpha, 0.25f);
+ if (ImGui::Button("Auto")) {
+ if (is_auto)
+ style.Colors[i] = temp;
+ else
+ style.Colors[i] = IMPLOT_AUTO_COL;
+ BustItemCache();
+ }
+ if (!is_auto)
+ ImGui::PopStyleVar();
+ ImGui::SameLine();
+ if (ImGui::ColorEdit4(name, &temp.x, ImGuiColorEditFlags_NoInputs | alpha_flags)) {
+ style.Colors[i] = temp;
+ BustItemCache();
+ }
+ if (memcmp(&style.Colors[i], &ref->Colors[i], sizeof(ImVec4)) != 0) {
+ ImGui::SameLine(175); if (ImGui::Button("Save")) { ref->Colors[i] = style.Colors[i]; }
+ ImGui::SameLine(); if (ImGui::Button("Revert")) {
+ style.Colors[i] = ref->Colors[i];
+ BustItemCache();
+ }
+ }
+ ImGui::PopID();
+ }
+ ImGui::PopItemWidth();
+ ImGui::Separator();
+ ImGui::Text("Colors that are set to Auto (i.e. IMPLOT_AUTO_COL) will\n"
+ "be automatically deduced from your ImGui style or the\n"
+ "current ImPlot Colormap. If you want to style individual\n"
+ "plot items, use Push/PopStyleColor around its function.");
+ ImGui::EndTabItem();
+ }
+ if (ImGui::BeginTabItem("Colormaps")) {
+ static int output_dest = 0;
+ if (ImGui::Button("Export", ImVec2(75,0))) {
+ if (output_dest == 0)
+ ImGui::LogToClipboard();
+ else
+ ImGui::LogToTTY();
+ int size = GetColormapSize();
+ const char* name = GetColormapName(gp.Style.Colormap);
+ ImGui::LogText("static const ImU32 %s_Data[%d] = {\n", name, size);
+ for (int i = 0; i < size; ++i) {
+ ImU32 col = GetColormapColorU32(i,gp.Style.Colormap);
+ ImGui::LogText(" %u%s\n", col, i == size - 1 ? "" : ",");
+ }
+ ImGui::LogText("};\nImPlotColormap %s = ImPlot::AddColormap(\"%s\", %s_Data, %d);", name, name, name, size);
+ ImGui::LogFinish();
+ }
+ ImGui::SameLine(); ImGui::SetNextItemWidth(120); ImGui::Combo("##output_type", &output_dest, "To Clipboard\0To TTY\0");
+ ImGui::SameLine();
+ static bool edit = false;
+ ImGui::Checkbox("Edit Mode",&edit);
+
+ // built-in/added
+ ImGui::Separator();
+ for (int i = 0; i < gp.ColormapData.Count; ++i) {
+ ImGui::PushID(i);
+ int size = gp.ColormapData.GetKeyCount(i);
+ bool selected = i == gp.Style.Colormap;
+
+ const char* name = GetColormapName(i);
+ if (!selected)
+ ImGui::PushStyleVar(ImGuiStyleVar_Alpha, 0.25f);
+ if (ImGui::Button(name, ImVec2(100,0))) {
+ gp.Style.Colormap = i;
+ BustItemCache();
+ }
+ if (!selected)
+ ImGui::PopStyleVar();
+ ImGui::SameLine();
+ ImGui::BeginGroup();
+ if (edit) {
+ for (int c = 0; c < size; ++c) {
+ ImGui::PushID(c);
+ ImVec4 col4 = ImGui::ColorConvertU32ToFloat4(gp.ColormapData.GetKeyColor(i,c));
+ if (ImGui::ColorEdit4("",&col4.x,ImGuiColorEditFlags_NoInputs)) {
+ ImU32 col32 = ImGui::ColorConvertFloat4ToU32(col4);
+ gp.ColormapData.SetKeyColor(i,c,col32);
+ BustItemCache();
+ }
+ if ((c + 1) % 12 != 0 && c != size -1)
+ ImGui::SameLine();
+ ImGui::PopID();
+ }
+ }
+ else {
+ if (ImPlot::ColormapButton("##",ImVec2(-1,0),i))
+ edit = true;
+ }
+ ImGui::EndGroup();
+ ImGui::PopID();
+ }
+
+
+ static ImVector<ImVec4> custom;
+ if (custom.Size == 0) {
+ custom.push_back(ImVec4(1,0,0,1));
+ custom.push_back(ImVec4(0,1,0,1));
+ custom.push_back(ImVec4(0,0,1,1));
+ }
+ ImGui::Separator();
+ ImGui::BeginGroup();
+ static char name[16] = "MyColormap";
+
+
+ if (ImGui::Button("+", ImVec2((100 - ImGui::GetStyle().ItemSpacing.x)/2,0)))
+ custom.push_back(ImVec4(0,0,0,1));
+ ImGui::SameLine();
+ if (ImGui::Button("-", ImVec2((100 - ImGui::GetStyle().ItemSpacing.x)/2,0)) && custom.Size > 2)
+ custom.pop_back();
+ ImGui::SetNextItemWidth(100);
+ ImGui::InputText("##Name",name,16,ImGuiInputTextFlags_CharsNoBlank);
+ static bool qual = true;
+ ImGui::Checkbox("Qualitative",&qual);
+ if (ImGui::Button("Add", ImVec2(100, 0)) && gp.ColormapData.GetIndex(name)==-1)
+ AddColormap(name,custom.Data,custom.Size,qual);
+
+ ImGui::EndGroup();
+ ImGui::SameLine();
+ ImGui::BeginGroup();
+ for (int c = 0; c < custom.Size; ++c) {
+ ImGui::PushID(c);
+ if (ImGui::ColorEdit4("##Col1", &custom[c].x, ImGuiColorEditFlags_NoInputs)) {
+
+ }
+ if ((c + 1) % 12 != 0)
+ ImGui::SameLine();
+ ImGui::PopID();
+ }
+ ImGui::EndGroup();
+
+
+ ImGui::EndTabItem();
+ }
+ ImGui::EndTabBar();
+ }
+}
+
+void ShowUserGuide() {
+ ImGui::BulletText("Left-click drag within the plot area to pan X and Y axes.");
+ ImGui::Indent();
+ ImGui::BulletText("Left-click drag on axis labels to pan an individual axis.");
+ ImGui::Unindent();
+ ImGui::BulletText("Scroll in the plot area to zoom both X any Y axes.");
+ ImGui::Indent();
+ ImGui::BulletText("Scroll on axis labels to zoom an individual axis.");
+ ImGui::Unindent();
+ ImGui::BulletText("Right-click drag to box select data.");
+ ImGui::Indent();
+ ImGui::BulletText("Hold Alt to expand box selection horizontally.");
+ ImGui::BulletText("Hold Shift to expand box selection vertically.");
+ ImGui::BulletText("Left-click while box selecting to cancel the selection.");
+ ImGui::Unindent();
+ ImGui::BulletText("Double left-click to fit all visible data.");
+ ImGui::Indent();
+ ImGui::BulletText("Double left-click axis labels to fit the individual axis.");
+ ImGui::Unindent();
+ ImGui::BulletText("Right-click open the full plot context menu.");
+ ImGui::Indent();
+ ImGui::BulletText("Right-click axis labels to open an individual axis context menu.");
+ ImGui::Unindent();
+ ImGui::BulletText("Click legend label icons to show/hide plot items.");
+}
+
+void ShowAxisMetrics(ImPlotAxis* axis, bool show_axis_rects) {
+ ImGui::Bullet(); ImGui::Text("Flags: %d", axis->Flags);
+ ImGui::Bullet(); ImGui::Text("Range: [%f,%f]",axis->Range.Min, axis->Range.Max);
+ ImGui::Bullet(); ImGui::Text("Pixels: %f", axis->Pixels);
+ ImGui::Bullet(); ImGui::Text("Aspect: %f", axis->GetAspect());
+ ImGui::Bullet(); ImGui::Text("Dragging: %s", axis->Dragging ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("ExtHovered: %s", axis->ExtHovered ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("AllHovered: %s", axis->AllHovered ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("Present: %s", axis->Present ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("HasRange: %s", axis->HasRange ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("LinkedMin: %p", (void*)axis->LinkedMin);
+ ImGui::Bullet(); ImGui::Text("LinkedMax: %p", (void*)axis->LinkedMax);
+ if (show_axis_rects) {
+ ImDrawList& fg = *ImGui::GetForegroundDrawList();
+ fg.AddRect(axis->HoverRect.Min, axis->HoverRect.Max, IM_COL32(0,255,0,255));
+ }
+}
+
+void ShowMetricsWindow(bool* p_popen) {
+
+ static bool show_plot_rects = false;
+ static bool show_axes_rects = false;
+
+ ImDrawList& fg = *ImGui::GetForegroundDrawList();
+
+ ImPlotContext& gp = *GImPlot;
+ // ImGuiContext& g = *GImGui;
+ ImGuiIO& io = ImGui::GetIO();
+ ImGui::Begin("ImPlot Metrics", p_popen);
+ ImGui::Text("ImPlot " IMPLOT_VERSION);
+ ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
+ ImGui::Separator();
+ if (ImGui::TreeNode("Tools")) {
+ if (ImGui::Button("Bust Plot Cache"))
+ BustPlotCache();
+ ImGui::SameLine();
+ if (ImGui::Button("Bust Item Cache"))
+ BustItemCache();
+ ImGui::Checkbox("Show Plot Rects", &show_plot_rects);
+ ImGui::Checkbox("Show Axes Rects", &show_axes_rects);
+ ImGui::TreePop();
+ }
+ const int n_plots = gp.Plots.GetSize();
+ if (ImGui::TreeNode("Plots","Plots (%d)", n_plots)) {
+ for (int p = 0; p < n_plots; ++p) {
+ // plot
+ ImPlotPlot* plot = gp.Plots.GetByIndex(p);
+ ImGui::PushID(p);
+ if (ImGui::TreeNode("Plot", "Plot [ID=%u]", plot->ID)) {
+ int n_items = plot->Items.GetSize();
+ if (ImGui::TreeNode("Items", "Items (%d)", n_items)) {
+ for (int i = 0; i < n_items; ++i) {
+ ImPlotItem* item = plot->Items.GetByIndex(i);
+ ImGui::PushID(i);
+ if (ImGui::TreeNode("Item", "Item [ID=%u]", item->ID)) {
+ ImGui::Bullet(); ImGui::Checkbox("Show", &item->Show);
+ ImGui::Bullet();
+ ImVec4 temp = ImGui::ColorConvertU32ToFloat4(item->Color);
+ if (ImGui::ColorEdit4("Color",&temp.x, ImGuiColorEditFlags_NoInputs))
+ item->Color = ImGui::ColorConvertFloat4ToU32(temp);
+
+ ImGui::Bullet(); ImGui::Text("NameOffset: %d",item->NameOffset);
+ ImGui::Bullet(); ImGui::Text("Name: %s", item->NameOffset != -1 ? plot->LegendData.Labels.Buf.Data + item->NameOffset : "N/A");
+ ImGui::Bullet(); ImGui::Text("Hovered: %s",item->LegendHovered ? "true" : "false");
+ ImGui::TreePop();
+ }
+ ImGui::PopID();
+ }
+ ImGui::TreePop();
+ }
+ if (ImGui::TreeNode("X-Axis")) {
+ ShowAxisMetrics(&plot->XAxis, show_axes_rects);
+ ImGui::TreePop();
+ }
+ if (ImGui::TreeNode("Y-Axis")) {
+ ShowAxisMetrics(&plot->YAxis[0], show_axes_rects);
+ ImGui::TreePop();
+ }
+ if (ImHasFlag(plot->Flags, ImPlotFlags_YAxis2) && ImGui::TreeNode("Y-Axis 2")) {
+ ShowAxisMetrics(&plot->YAxis[1], show_axes_rects);
+ ImGui::TreePop();
+ }
+ if (ImHasFlag(plot->Flags, ImPlotFlags_YAxis3) && ImGui::TreeNode("Y-Axis 3")) {
+ ShowAxisMetrics(&plot->YAxis[2], show_axes_rects);
+ ImGui::TreePop();
+ }
+ ImGui::Bullet(); ImGui::Text("Flags: %d", plot->Flags);
+ ImGui::Bullet(); ImGui::Text("Initialized: %s", plot->Initialized ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("Selecting: %s", plot->Selecting ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("Selected: %s", plot->Selected ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("Querying: %s", plot->Querying ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("Queried: %s", plot->Queried ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("FrameHovered: %s", plot->FrameHovered ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("PlotHovered: %s", plot->PlotHovered ? "true" : "false");
+ ImGui::Bullet(); ImGui::Text("LegendHovered: %s", plot->LegendHovered ? "true" : "false");
+ ImGui::TreePop();
+ if (show_plot_rects)
+ fg.AddRect(plot->PlotRect.Min, plot->PlotRect.Max, IM_COL32(255,255,0,255));
+ }
+ ImGui::PopID();
+ }
+ ImGui::TreePop();
+ }
+ if (ImGui::TreeNode("Colormaps")) {
+ ImGui::BulletText("Colormaps: %d", gp.ColormapData.Count);
+ ImGui::BulletText("Memory: %d bytes", gp.ColormapData.Tables.Size * 4);
+ if (ImGui::TreeNode("Data")) {
+ for (int m = 0; m < gp.ColormapData.Count; ++m) {
+ if (ImGui::TreeNode(gp.ColormapData.GetName(m))) {
+ int count = gp.ColormapData.GetKeyCount(m);
+ int size = gp.ColormapData.GetTableSize(m);
+ bool qual = gp.ColormapData.IsQual(m);
+ ImGui::BulletText("Qualitative: %s", qual ? "true" : "false");
+ ImGui::BulletText("Key Count: %d", count);
+ ImGui::BulletText("Table Size: %d", size);
+ ImGui::Indent();
+
+ static float t = 0.5;
+ ImVec4 samp;
+ float wid = 32 * 10 - ImGui::GetFrameHeight() - ImGui::GetStyle().ItemSpacing.x;
+ ImGui::SetNextItemWidth(wid);
+ ImPlot::ColormapSlider("##Sample",&t,&samp,"%.3f",m);
+ ImGui::SameLine();
+ ImGui::ColorButton("Sampler",samp);
+ ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0,0,0,0));
+ ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0,0));
+ for (int c = 0; c < size; ++c) {
+ ImVec4 col = ImGui::ColorConvertU32ToFloat4(gp.ColormapData.GetTableColor(m,c));
+ ImGui::PushID(m*1000+c);
+ ImGui::ColorButton("",col,0,ImVec2(10,10));
+ ImGui::PopID();
+ if ((c + 1) % 32 != 0 && c != size - 1)
+ ImGui::SameLine();
+ }
+ ImGui::PopStyleVar();
+ ImGui::PopStyleColor();
+ ImGui::Unindent();
+ ImGui::TreePop();
+ }
+ }
+ ImGui::TreePop();
+ }
+ ImGui::TreePop();
+ }
+ ImGui::End();
+}
+
+bool ShowDatePicker(const char* id, int* level, ImPlotTime* t, const ImPlotTime* t1, const ImPlotTime* t2) {
+
+ ImGui::PushID(id);
+ ImGui::BeginGroup();
+
+ ImGuiStyle& style = ImGui::GetStyle();
+ ImVec4 col_txt = style.Colors[ImGuiCol_Text];
+ ImVec4 col_dis = style.Colors[ImGuiCol_TextDisabled];
+ ImVec4 col_btn = style.Colors[ImGuiCol_Button];
+ ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0,0,0,0));
+ ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0,0));
+
+ const float ht = ImGui::GetFrameHeight();
+ ImVec2 cell_size(ht*1.25f,ht);
+ char buff[32];
+ bool clk = false;
+ tm& Tm = GImPlot->Tm;
+
+ const int min_yr = 1970;
+ const int max_yr = 2999;
+
+ // t1 parts
+ int t1_mo = 0; int t1_md = 0; int t1_yr = 0;
+ if (t1 != NULL) {
+ GetTime(*t1,&Tm);
+ t1_mo = Tm.tm_mon;
+ t1_md = Tm.tm_mday;
+ t1_yr = Tm.tm_year + 1900;
+ }
+
+ // t2 parts
+ int t2_mo = 0; int t2_md = 0; int t2_yr = 0;
+ if (t2 != NULL) {
+ GetTime(*t2,&Tm);
+ t2_mo = Tm.tm_mon;
+ t2_md = Tm.tm_mday;
+ t2_yr = Tm.tm_year + 1900;
+ }
+
+ // day widget
+ if (*level == 0) {
+ *t = FloorTime(*t, ImPlotTimeUnit_Day);
+ GetTime(*t, &Tm);
+ const int this_year = Tm.tm_year + 1900;
+ const int last_year = this_year - 1;
+ const int next_year = this_year + 1;
+ const int this_mon = Tm.tm_mon;
+ const int last_mon = this_mon == 0 ? 11 : this_mon - 1;
+ const int next_mon = this_mon == 11 ? 0 : this_mon + 1;
+ const int days_this_mo = GetDaysInMonth(this_year, this_mon);
+ const int days_last_mo = GetDaysInMonth(this_mon == 0 ? last_year : this_year, last_mon);
+ ImPlotTime t_first_mo = FloorTime(*t,ImPlotTimeUnit_Mo);
+ GetTime(t_first_mo,&Tm);
+ const int first_wd = Tm.tm_wday;
+ // month year
+ snprintf(buff, 32, "%s %d", MONTH_NAMES[this_mon], this_year);
+ if (ImGui::Button(buff))
+ *level = 1;
+ ImGui::SameLine(5*cell_size.x);
+ BeginDisabledControls(this_year <= min_yr && this_mon == 0);
+ if (ImGui::ArrowButtonEx("##Up",ImGuiDir_Up,cell_size))
+ *t = AddTime(*t, ImPlotTimeUnit_Mo, -1);
+ EndDisabledControls(this_year <= min_yr && this_mon == 0);
+ ImGui::SameLine();
+ BeginDisabledControls(this_year >= max_yr && this_mon == 11);
+ if (ImGui::ArrowButtonEx("##Down",ImGuiDir_Down,cell_size))
+ *t = AddTime(*t, ImPlotTimeUnit_Mo, 1);
+ EndDisabledControls(this_year >= max_yr && this_mon == 11);
+ // render weekday abbreviations
+ ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
+ for (int i = 0; i < 7; ++i) {
+ ImGui::Button(WD_ABRVS[i],cell_size);
+ if (i != 6) { ImGui::SameLine(); }
+ }
+ ImGui::PopItemFlag();
+ // 0 = last mo, 1 = this mo, 2 = next mo
+ int mo = first_wd > 0 ? 0 : 1;
+ int day = mo == 1 ? 1 : days_last_mo - first_wd + 1;
+ for (int i = 0; i < 6; ++i) {
+ for (int j = 0; j < 7; ++j) {
+ if (mo == 0 && day > days_last_mo) {
+ mo = 1; day = 1;
+ }
+ else if (mo == 1 && day > days_this_mo) {
+ mo = 2; day = 1;
+ }
+ const int now_yr = (mo == 0 && this_mon == 0) ? last_year : ((mo == 2 && this_mon == 11) ? next_year : this_year);
+ const int now_mo = mo == 0 ? last_mon : (mo == 1 ? this_mon : next_mon);
+ const int now_md = day;
+
+ const bool off_mo = mo == 0 || mo == 2;
+ const bool t1_or_t2 = (t1 != NULL && t1_mo == now_mo && t1_yr == now_yr && t1_md == now_md) ||
+ (t2 != NULL && t2_mo == now_mo && t2_yr == now_yr && t2_md == now_md);
+
+ if (off_mo)
+ ImGui::PushStyleColor(ImGuiCol_Text, col_dis);
+ if (t1_or_t2) {
+ ImGui::PushStyleColor(ImGuiCol_Button, col_btn);
+ ImGui::PushStyleColor(ImGuiCol_Text, col_txt);
+ }
+ ImGui::PushID(i*7+j);
+ snprintf(buff,32,"%d",day);
+ if (now_yr == min_yr-1 || now_yr == max_yr+1) {
+ ImGui::Dummy(cell_size);
+ }
+ else if (ImGui::Button(buff,cell_size) && !clk) {
+ *t = MakeTime(now_yr, now_mo, now_md);
+ clk = true;
+ }
+ ImGui::PopID();
+ if (t1_or_t2)
+ ImGui::PopStyleColor(2);
+ if (off_mo)
+ ImGui::PopStyleColor();
+ if (j != 6)
+ ImGui::SameLine();
+ day++;
+ }
+ }
+ }
+ // month widget
+ else if (*level == 1) {
+ *t = FloorTime(*t, ImPlotTimeUnit_Mo);
+ GetTime(*t, &Tm);
+ int this_yr = Tm.tm_year + 1900;
+ snprintf(buff, 32, "%d", this_yr);
+ if (ImGui::Button(buff))
+ *level = 2;
+ BeginDisabledControls(this_yr <= min_yr);
+ ImGui::SameLine(5*cell_size.x);
+ if (ImGui::ArrowButtonEx("##Up",ImGuiDir_Up,cell_size))
+ *t = AddTime(*t, ImPlotTimeUnit_Yr, -1);
+ EndDisabledControls(this_yr <= min_yr);
+ ImGui::SameLine();
+ BeginDisabledControls(this_yr >= max_yr);
+ if (ImGui::ArrowButtonEx("##Down",ImGuiDir_Down,cell_size))
+ *t = AddTime(*t, ImPlotTimeUnit_Yr, 1);
+ EndDisabledControls(this_yr >= max_yr);
+ // ImGui::Dummy(cell_size);
+ cell_size.x *= 7.0f/4.0f;
+ cell_size.y *= 7.0f/3.0f;
+ int mo = 0;
+ for (int i = 0; i < 3; ++i) {
+ for (int j = 0; j < 4; ++j) {
+ const bool t1_or_t2 = (t1 != NULL && t1_yr == this_yr && t1_mo == mo) ||
+ (t2 != NULL && t2_yr == this_yr && t2_mo == mo);
+ if (t1_or_t2)
+ ImGui::PushStyleColor(ImGuiCol_Button, col_btn);
+ if (ImGui::Button(MONTH_ABRVS[mo],cell_size) && !clk) {
+ *t = MakeTime(this_yr, mo);
+ *level = 0;
+ }
+ if (t1_or_t2)
+ ImGui::PopStyleColor();
+ if (j != 3)
+ ImGui::SameLine();
+ mo++;
+ }
+ }
+ }
+ else if (*level == 2) {
+ *t = FloorTime(*t, ImPlotTimeUnit_Yr);
+ int this_yr = GetYear(*t);
+ int yr = this_yr - this_yr % 20;
+ ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
+ snprintf(buff,32,"%d-%d",yr,yr+19);
+ ImGui::Button(buff);
+ ImGui::PopItemFlag();
+ ImGui::SameLine(5*cell_size.x);
+ BeginDisabledControls(yr <= min_yr);
+ if (ImGui::ArrowButtonEx("##Up",ImGuiDir_Up,cell_size))
+ *t = MakeTime(yr-20);
+ EndDisabledControls(yr <= min_yr);
+ ImGui::SameLine();
+ BeginDisabledControls(yr + 20 >= max_yr);
+ if (ImGui::ArrowButtonEx("##Down",ImGuiDir_Down,cell_size))
+ *t = MakeTime(yr+20);
+ EndDisabledControls(yr+ 20 >= max_yr);
+ // ImGui::Dummy(cell_size);
+ cell_size.x *= 7.0f/4.0f;
+ cell_size.y *= 7.0f/5.0f;
+ for (int i = 0; i < 5; ++i) {
+ for (int j = 0; j < 4; ++j) {
+ const bool t1_or_t2 = (t1 != NULL && t1_yr == yr) || (t2 != NULL && t2_yr == yr);
+ if (t1_or_t2)
+ ImGui::PushStyleColor(ImGuiCol_Button, col_btn);
+ snprintf(buff,32,"%d",yr);
+ if (yr<1970||yr>3000) {
+ ImGui::Dummy(cell_size);
+ }
+ else if (ImGui::Button(buff,cell_size)) {
+ *t = MakeTime(yr);
+ *level = 1;
+ }
+ if (t1_or_t2)
+ ImGui::PopStyleColor();
+ if (j != 3)
+ ImGui::SameLine();
+ yr++;
+ }
+ }
+ }
+ ImGui::PopStyleVar();
+ ImGui::PopStyleColor();
+ ImGui::EndGroup();
+ ImGui::PopID();
+ return clk;
+}
+
+bool ShowTimePicker(const char* id, ImPlotTime* t) {
+ ImGui::PushID(id);
+ tm& Tm = GImPlot->Tm;
+ GetTime(*t,&Tm);
+
+ static const char* nums[] = { "00","01","02","03","04","05","06","07","08","09",
+ "10","11","12","13","14","15","16","17","18","19",
+ "20","21","22","23","24","25","26","27","28","29",
+ "30","31","32","33","34","35","36","37","38","39",
+ "40","41","42","43","44","45","46","47","48","49",
+ "50","51","52","53","54","55","56","57","58","59"};
+
+ static const char* am_pm[] = {"am","pm"};
+
+ bool hour24 = GImPlot->Style.Use24HourClock;
+
+ int hr = hour24 ? Tm.tm_hour : ((Tm.tm_hour == 0 || Tm.tm_hour == 12) ? 12 : Tm.tm_hour % 12);
+ int min = Tm.tm_min;
+ int sec = Tm.tm_sec;
+ int ap = Tm.tm_hour < 12 ? 0 : 1;
+
+ bool changed = false;
+
+ ImVec2 spacing = ImGui::GetStyle().ItemSpacing;
+ spacing.x = 0;
+ float width = ImGui::CalcTextSize("888").x;
+ float height = ImGui::GetFrameHeight();
+
+ ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, spacing);
+ ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarSize,2.0f);
+ ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0,0,0,0));
+ ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0,0,0,0));
+ ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, ImGui::GetStyleColorVec4(ImGuiCol_ButtonHovered));
+
+ ImGui::SetNextItemWidth(width);
+ if (ImGui::BeginCombo("##hr",nums[hr],ImGuiComboFlags_NoArrowButton)) {
+ const int ia = hour24 ? 0 : 1;
+ const int ib = hour24 ? 24 : 13;
+ for (int i = ia; i < ib; ++i) {
+ if (ImGui::Selectable(nums[i],i==hr)) {
+ hr = i;
+ changed = true;
+ }
+ }
+ ImGui::EndCombo();
+ }
+ ImGui::SameLine();
+ ImGui::Text(":");
+ ImGui::SameLine();
+ ImGui::SetNextItemWidth(width);
+ if (ImGui::BeginCombo("##min",nums[min],ImGuiComboFlags_NoArrowButton)) {
+ for (int i = 0; i < 60; ++i) {
+ if (ImGui::Selectable(nums[i],i==min)) {
+ min = i;
+ changed = true;
+ }
+ }
+ ImGui::EndCombo();
+ }
+ ImGui::SameLine();
+ ImGui::Text(":");
+ ImGui::SameLine();
+ ImGui::SetNextItemWidth(width);
+ if (ImGui::BeginCombo("##sec",nums[sec],ImGuiComboFlags_NoArrowButton)) {
+ for (int i = 0; i < 60; ++i) {
+ if (ImGui::Selectable(nums[i],i==sec)) {
+ sec = i;
+ changed = true;
+ }
+ }
+ ImGui::EndCombo();
+ }
+ if (!hour24) {
+ ImGui::SameLine();
+ if (ImGui::Button(am_pm[ap],ImVec2(height,height))) {
+ ap = 1 - ap;
+ changed = true;
+ }
+ }
+
+ ImGui::PopStyleColor(3);
+ ImGui::PopStyleVar(2);
+ ImGui::PopID();
+
+ if (changed) {
+ if (!hour24)
+ hr = hr % 12 + ap * 12;
+ Tm.tm_hour = hr;
+ Tm.tm_min = min;
+ Tm.tm_sec = sec;
+ *t = MkTime(&Tm);
+ }
+
+ return changed;
+}
+
+void StyleColorsAuto(ImPlotStyle* dst) {
+ ImPlotStyle* style = dst ? dst : &ImPlot::GetStyle();
+ ImVec4* colors = style->Colors;
+
+ style->MinorAlpha = 0.25f;
+
+ colors[ImPlotCol_Line] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_Fill] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_MarkerOutline] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_MarkerFill] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_ErrorBar] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_FrameBg] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_PlotBg] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_PlotBorder] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_LegendBg] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_LegendBorder] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_LegendText] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_TitleText] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_InlayText] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_PlotBorder] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_XAxis] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_XAxisGrid] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_YAxis] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_YAxisGrid] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_YAxis2] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_YAxisGrid2] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_YAxis3] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_YAxisGrid3] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_Selection] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_Query] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_Crosshairs] = IMPLOT_AUTO_COL;
+}
+
+void StyleColorsClassic(ImPlotStyle* dst) {
+ ImPlotStyle* style = dst ? dst : &ImPlot::GetStyle();
+ ImVec4* colors = style->Colors;
+
+ style->MinorAlpha = 0.5f;
+
+ colors[ImPlotCol_Line] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_Fill] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_MarkerOutline] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_MarkerFill] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_ErrorBar] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
+ colors[ImPlotCol_FrameBg] = ImVec4(0.43f, 0.43f, 0.43f, 0.39f);
+ colors[ImPlotCol_PlotBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.35f);
+ colors[ImPlotCol_PlotBorder] = ImVec4(0.50f, 0.50f, 0.50f, 0.50f);
+ colors[ImPlotCol_LegendBg] = ImVec4(0.11f, 0.11f, 0.14f, 0.92f);
+ colors[ImPlotCol_LegendBorder] = ImVec4(0.50f, 0.50f, 0.50f, 0.50f);
+ colors[ImPlotCol_LegendText] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
+ colors[ImPlotCol_TitleText] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
+ colors[ImPlotCol_InlayText] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
+ colors[ImPlotCol_XAxis] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
+ colors[ImPlotCol_XAxisGrid] = ImVec4(0.90f, 0.90f, 0.90f, 0.25f);
+ colors[ImPlotCol_YAxis] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
+ colors[ImPlotCol_YAxisGrid] = ImVec4(0.90f, 0.90f, 0.90f, 0.25f);
+ colors[ImPlotCol_YAxis2] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
+ colors[ImPlotCol_YAxisGrid2] = ImVec4(0.90f, 0.90f, 0.90f, 0.25f);
+ colors[ImPlotCol_YAxis3] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
+ colors[ImPlotCol_YAxisGrid3] = ImVec4(0.90f, 0.90f, 0.90f, 0.25f);
+ colors[ImPlotCol_Selection] = ImVec4(0.97f, 0.97f, 0.39f, 1.00f);
+ colors[ImPlotCol_Query] = ImVec4(0.00f, 1.00f, 0.59f, 1.00f);
+ colors[ImPlotCol_Crosshairs] = ImVec4(0.50f, 0.50f, 0.50f, 0.75f);
+}
+
+void StyleColorsDark(ImPlotStyle* dst) {
+ ImPlotStyle* style = dst ? dst : &ImPlot::GetStyle();
+ ImVec4* colors = style->Colors;
+
+ style->MinorAlpha = 0.25f;
+
+ colors[ImPlotCol_Line] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_Fill] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_MarkerOutline] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_MarkerFill] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_ErrorBar] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_FrameBg] = ImVec4(1.00f, 1.00f, 1.00f, 0.07f);
+ colors[ImPlotCol_PlotBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.50f);
+ colors[ImPlotCol_PlotBorder] = ImVec4(0.43f, 0.43f, 0.50f, 0.50f);
+ colors[ImPlotCol_LegendBg] = ImVec4(0.08f, 0.08f, 0.08f, 0.94f);
+ colors[ImPlotCol_LegendBorder] = ImVec4(0.43f, 0.43f, 0.50f, 0.50f);
+ colors[ImPlotCol_LegendText] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_TitleText] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_InlayText] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_XAxis] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_XAxisGrid] = ImVec4(1.00f, 1.00f, 1.00f, 0.25f);
+ colors[ImPlotCol_YAxis] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_YAxisGrid] = ImVec4(1.00f, 1.00f, 1.00f, 0.25f);
+ colors[ImPlotCol_YAxis2] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_YAxisGrid2] = ImVec4(1.00f, 1.00f, 1.00f, 0.25f);
+ colors[ImPlotCol_YAxis3] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_YAxisGrid3] = ImVec4(1.00f, 1.00f, 1.00f, 0.25f);
+ colors[ImPlotCol_Selection] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
+ colors[ImPlotCol_Query] = ImVec4(0.00f, 1.00f, 0.44f, 1.00f);
+ colors[ImPlotCol_Crosshairs] = ImVec4(1.00f, 1.00f, 1.00f, 0.50f);
+}
+
+void StyleColorsLight(ImPlotStyle* dst) {
+ ImPlotStyle* style = dst ? dst : &ImPlot::GetStyle();
+ ImVec4* colors = style->Colors;
+
+ style->MinorAlpha = 1.0f;
+
+ colors[ImPlotCol_Line] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_Fill] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_MarkerOutline] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_MarkerFill] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_ErrorBar] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_FrameBg] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_PlotBg] = ImVec4(0.42f, 0.57f, 1.00f, 0.13f);
+ colors[ImPlotCol_PlotBorder] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
+ colors[ImPlotCol_LegendBg] = ImVec4(1.00f, 1.00f, 1.00f, 0.98f);
+ colors[ImPlotCol_LegendBorder] = ImVec4(0.82f, 0.82f, 0.82f, 0.80f);
+ colors[ImPlotCol_LegendText] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_TitleText] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_InlayText] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_XAxis] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_XAxisGrid] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_YAxis] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_YAxisGrid] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_YAxis2] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_YAxisGrid2] = ImVec4(0.00f, 0.00f, 0.00f, 0.50f);
+ colors[ImPlotCol_YAxis3] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_YAxisGrid3] = ImVec4(0.00f, 0.00f, 0.00f, 0.50f);
+ colors[ImPlotCol_Selection] = ImVec4(0.82f, 0.64f, 0.03f, 1.00f);
+ colors[ImPlotCol_Query] = ImVec4(0.00f, 0.84f, 0.37f, 1.00f);
+ colors[ImPlotCol_Crosshairs] = ImVec4(0.00f, 0.00f, 0.00f, 0.50f);
+}
+
+} // namespace ImPlot
diff --git a/3rdparty/implot/implot.h b/3rdparty/implot/implot.h
new file mode 100644
index 0000000..e486748
--- /dev/null
+++ b/3rdparty/implot/implot.h
@@ -0,0 +1,836 @@
+// MIT License
+
+// Copyright (c) 2021 Evan Pezent
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// ImPlot v0.10 WIP
+
+#pragma once
+#include "imgui.h"
+
+//-----------------------------------------------------------------------------
+// Macros and Defines
+//-----------------------------------------------------------------------------
+
+// Define attributes of all API symbols declarations (e.g. for DLL under Windows)
+// Using ImPlot via a shared library is not recommended, because we don't guarantee
+// backward nor forward ABI compatibility and also function call overhead. If you
+// do use ImPlot as a DLL, be sure to call SetImGuiContext (see Miscellanous section).
+#ifndef IMPLOT_API
+#define IMPLOT_API
+#endif
+
+// ImPlot version string
+#define IMPLOT_VERSION "0.10 WIP"
+// Indicates variable should deduced automatically.
+#define IMPLOT_AUTO -1
+// Special color used to indicate that a color should be deduced automatically.
+#define IMPLOT_AUTO_COL ImVec4(0,0,0,-1)
+
+//-----------------------------------------------------------------------------
+// Forward Declarations and Basic Types
+//-----------------------------------------------------------------------------
+
+// Forward declarations
+struct ImPlotContext; // ImPlot context (opaque struct, see implot_internal.h)
+
+// Enums/Flags
+typedef int ImPlotFlags; // -> enum ImPlotFlags_
+typedef int ImPlotAxisFlags; // -> enum ImPlotAxisFlags_
+typedef int ImPlotCol; // -> enum ImPlotCol_
+typedef int ImPlotStyleVar; // -> enum ImPlotStyleVar_
+typedef int ImPlotMarker; // -> enum ImPlotMarker_
+typedef int ImPlotColormap; // -> enum ImPlotColormap_
+typedef int ImPlotLocation; // -> enum ImPlotLocation_
+typedef int ImPlotOrientation; // -> enum ImPlotOrientation_
+typedef int ImPlotYAxis; // -> enum ImPlotYAxis_;
+typedef int ImPlotBin; // -> enum ImPlotBin_
+
+// Options for plots.
+enum ImPlotFlags_ {
+ ImPlotFlags_None = 0, // default
+ ImPlotFlags_NoTitle = 1 << 0, // the plot title will not be displayed (titles are also hidden if preceeded by double hashes, e.g. "##MyPlot")
+ ImPlotFlags_NoLegend = 1 << 1, // the legend will not be displayed
+ ImPlotFlags_NoMenus = 1 << 2, // the user will not be able to open context menus with right-click
+ ImPlotFlags_NoBoxSelect = 1 << 3, // the user will not be able to box-select with right-click drag
+ ImPlotFlags_NoMousePos = 1 << 4, // the mouse position, in plot coordinates, will not be displayed inside of the plot
+ ImPlotFlags_NoHighlight = 1 << 5, // plot items will not be highlighted when their legend entry is hovered
+ ImPlotFlags_NoChild = 1 << 6, // a child window region will not be used to capture mouse scroll (can boost performance for single ImGui window applications)
+ ImPlotFlags_Equal = 1 << 7, // primary x and y axes will be constrained to have the same units/pixel (does not apply to auxiliary y-axes)
+ ImPlotFlags_YAxis2 = 1 << 8, // enable a 2nd y-axis on the right side
+ ImPlotFlags_YAxis3 = 1 << 9, // enable a 3rd y-axis on the right side
+ ImPlotFlags_Query = 1 << 10, // the user will be able to draw query rects with middle-mouse or CTRL + right-click drag
+ ImPlotFlags_Crosshairs = 1 << 11, // the default mouse cursor will be replaced with a crosshair when hovered
+ ImPlotFlags_AntiAliased = 1 << 12, // plot lines will be software anti-aliased (not recommended for high density plots, prefer MSAA)
+ ImPlotFlags_CanvasOnly = ImPlotFlags_NoTitle | ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect | ImPlotFlags_NoMousePos
+};
+
+// Options for plot axes (X and Y).
+enum ImPlotAxisFlags_ {
+ ImPlotAxisFlags_None = 0, // default
+ ImPlotAxisFlags_NoLabel = 1 << 0, // the axis label will not be displayed (axis labels also hidden if the supplied string name is NULL)
+ ImPlotAxisFlags_NoGridLines = 1 << 1, // no grid lines will be displayed
+ ImPlotAxisFlags_NoTickMarks = 1 << 2, // no tick marks will be displayed
+ ImPlotAxisFlags_NoTickLabels = 1 << 3, // no text labels will be displayed
+ ImPlotAxisFlags_Foreground = 1 << 4, // grid lines will be displayed in the foreground (i.e. on top of data) in stead of the background
+ ImPlotAxisFlags_LogScale = 1 << 5, // a logartithmic (base 10) axis scale will be used (mutually exclusive with ImPlotAxisFlags_Time)
+ ImPlotAxisFlags_Time = 1 << 6, // axis will display date/time formatted labels (mutually exclusive with ImPlotAxisFlags_LogScale)
+ ImPlotAxisFlags_Invert = 1 << 7, // the axis will be inverted
+ ImPlotAxisFlags_NoInitialFit = 1 << 8, // axis will not be initially fit to data extents on the first rendered frame (also the case if SetNextPlotLimits explicitly called)
+ ImPlotAxisFlags_AutoFit = 1 << 9, // axis will be auto-fitting to data extents
+ ImPlotAxisFlags_RangeFit = 1 << 10, // axis will only fit points if the point is in the visible range of the **orthoganol** axis
+ ImPlotAxisFlags_LockMin = 1 << 11, // the axis minimum value will be locked when panning/zooming
+ ImPlotAxisFlags_LockMax = 1 << 12, // the axis maximum value will be locked when panning/zooming
+ ImPlotAxisFlags_Lock = ImPlotAxisFlags_LockMin | ImPlotAxisFlags_LockMax,
+ ImPlotAxisFlags_NoDecorations = ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoTickMarks | ImPlotAxisFlags_NoTickLabels
+};
+
+// Plot styling colors.
+enum ImPlotCol_ {
+ // item styling colors
+ ImPlotCol_Line, // plot line/outline color (defaults to next unused color in current colormap)
+ ImPlotCol_Fill, // plot fill color for bars (defaults to the current line color)
+ ImPlotCol_MarkerOutline, // marker outline color (defaults to the current line color)
+ ImPlotCol_MarkerFill, // marker fill color (defaults to the current line color)
+ ImPlotCol_ErrorBar, // error bar color (defaults to ImGuiCol_Text)
+ // plot styling colors
+ ImPlotCol_FrameBg, // plot frame background color (defaults to ImGuiCol_FrameBg)
+ ImPlotCol_PlotBg, // plot area background color (defaults to ImGuiCol_WindowBg)
+ ImPlotCol_PlotBorder, // plot area border color (defaults to ImGuiCol_Border)
+ ImPlotCol_LegendBg, // legend background color (defaults to ImGuiCol_PopupBg)
+ ImPlotCol_LegendBorder, // legend border color (defaults to ImPlotCol_PlotBorder)
+ ImPlotCol_LegendText, // legend text color (defaults to ImPlotCol_InlayText)
+ ImPlotCol_TitleText, // plot title text color (defaults to ImGuiCol_Text)
+ ImPlotCol_InlayText, // color of text appearing inside of plots (defaults to ImGuiCol_Text)
+ ImPlotCol_XAxis, // x-axis label and tick lables color (defaults to ImGuiCol_Text)
+ ImPlotCol_XAxisGrid, // x-axis grid color (defaults to 25% ImPlotCol_XAxis)
+ ImPlotCol_YAxis, // y-axis label and tick labels color (defaults to ImGuiCol_Text)
+ ImPlotCol_YAxisGrid, // y-axis grid color (defaults to 25% ImPlotCol_YAxis)
+ ImPlotCol_YAxis2, // 2nd y-axis label and tick labels color (defaults to ImGuiCol_Text)
+ ImPlotCol_YAxisGrid2, // 2nd y-axis grid/label color (defaults to 25% ImPlotCol_YAxis2)
+ ImPlotCol_YAxis3, // 3rd y-axis label and tick labels color (defaults to ImGuiCol_Text)
+ ImPlotCol_YAxisGrid3, // 3rd y-axis grid/label color (defaults to 25% ImPlotCol_YAxis3)
+ ImPlotCol_Selection, // box-selection color (defaults to yellow)
+ ImPlotCol_Query, // box-query color (defaults to green)
+ ImPlotCol_Crosshairs, // crosshairs color (defaults to ImPlotCol_PlotBorder)
+ ImPlotCol_COUNT
+};
+
+// Plot styling variables.
+enum ImPlotStyleVar_ {
+ // item styling variables
+ ImPlotStyleVar_LineWeight, // float, plot item line weight in pixels
+ ImPlotStyleVar_Marker, // int, marker specification
+ ImPlotStyleVar_MarkerSize, // float, marker size in pixels (roughly the marker's "radius")
+ ImPlotStyleVar_MarkerWeight, // float, plot outline weight of markers in pixels
+ ImPlotStyleVar_FillAlpha, // float, alpha modifier applied to all plot item fills
+ ImPlotStyleVar_ErrorBarSize, // float, error bar whisker width in pixels
+ ImPlotStyleVar_ErrorBarWeight, // float, error bar whisker weight in pixels
+ ImPlotStyleVar_DigitalBitHeight, // float, digital channels bit height (at 1) in pixels
+ ImPlotStyleVar_DigitalBitGap, // float, digital channels bit padding gap in pixels
+ // plot styling variables
+ ImPlotStyleVar_PlotBorderSize, // float, thickness of border around plot area
+ ImPlotStyleVar_MinorAlpha, // float, alpha multiplier applied to minor axis grid lines
+ ImPlotStyleVar_MajorTickLen, // ImVec2, major tick lengths for X and Y axes
+ ImPlotStyleVar_MinorTickLen, // ImVec2, minor tick lengths for X and Y axes
+ ImPlotStyleVar_MajorTickSize, // ImVec2, line thickness of major ticks
+ ImPlotStyleVar_MinorTickSize, // ImVec2, line thickness of minor ticks
+ ImPlotStyleVar_MajorGridSize, // ImVec2, line thickness of major grid lines
+ ImPlotStyleVar_MinorGridSize, // ImVec2, line thickness of minor grid lines
+ ImPlotStyleVar_PlotPadding, // ImVec2, padding between widget frame and plot area, labels, or outside legends (i.e. main padding)
+ ImPlotStyleVar_LabelPadding, // ImVec2, padding between axes labels, tick labels, and plot edge
+ ImPlotStyleVar_LegendPadding, // ImVec2, legend padding from plot edges
+ ImPlotStyleVar_LegendInnerPadding, // ImVec2, legend inner padding from legend edges
+ ImPlotStyleVar_LegendSpacing, // ImVec2, spacing between legend entries
+ ImPlotStyleVar_MousePosPadding, // ImVec2, padding between plot edge and interior info text
+ ImPlotStyleVar_AnnotationPadding, // ImVec2, text padding around annotation labels
+ ImPlotStyleVar_FitPadding, // ImVec2, additional fit padding as a percentage of the fit extents (e.g. ImVec2(0.1f,0.1f) adds 10% to the fit extents of X and Y)
+ ImPlotStyleVar_PlotDefaultSize, // ImVec2, default size used when ImVec2(0,0) is passed to BeginPlot
+ ImPlotStyleVar_PlotMinSize, // ImVec2, minimum size plot frame can be when shrunk
+ ImPlotStyleVar_COUNT
+};
+
+// Marker specifications.
+enum ImPlotMarker_ {
+ ImPlotMarker_None = -1, // no marker
+ ImPlotMarker_Circle, // a circle marker
+ ImPlotMarker_Square, // a square maker
+ ImPlotMarker_Diamond, // a diamond marker
+ ImPlotMarker_Up, // an upward-pointing triangle marker
+ ImPlotMarker_Down, // an downward-pointing triangle marker
+ ImPlotMarker_Left, // an leftward-pointing triangle marker
+ ImPlotMarker_Right, // an rightward-pointing triangle marker
+ ImPlotMarker_Cross, // a cross marker (not fillable)
+ ImPlotMarker_Plus, // a plus marker (not fillable)
+ ImPlotMarker_Asterisk, // a asterisk marker (not fillable)
+ ImPlotMarker_COUNT
+};
+
+// Built-in colormaps
+enum ImPlotColormap_ {
+ ImPlotColormap_Deep = 0, // a.k.a. seaborn deep (qual=true, n=10) (default)
+ ImPlotColormap_Dark = 1, // a.k.a. matplotlib "Set1" (qual=true, n=9 )
+ ImPlotColormap_Pastel = 2, // a.k.a. matplotlib "Pastel1" (qual=true, n=9 )
+ ImPlotColormap_Paired = 3, // a.k.a. matplotlib "Paired" (qual=true, n=12)
+ ImPlotColormap_Viridis = 4, // a.k.a. matplotlib "viridis" (qual=false, n=11)
+ ImPlotColormap_Plasma = 5, // a.k.a. matplotlib "plasma" (qual=false, n=11)
+ ImPlotColormap_Hot = 6, // a.k.a. matplotlib/MATLAB "hot" (qual=false, n=11)
+ ImPlotColormap_Cool = 7, // a.k.a. matplotlib/MATLAB "cool" (qual=false, n=11)
+ ImPlotColormap_Pink = 8, // a.k.a. matplotlib/MATLAB "pink" (qual=false, n=11)
+ ImPlotColormap_Jet = 9, // a.k.a. MATLAB "jet" (qual=false, n=11)
+ ImPlotColormap_Twilight = 10, // a.k.a. matplotlib "twilight" (qual=false, n=11)
+ ImPlotColormap_RdBu = 11, // red/blue, Color Brewer (qual=false, n=11)
+ ImPlotColormap_BrBG = 12, // brown/blue-green, Color Brewer (qual=false, n=11)
+ ImPlotColormap_PiYG = 13, // pink/yellow-green, Color Brewer (qual=false, n=11)
+ ImPlotColormap_Spectral = 14, // color spectrum, Color Brewer (qual=false, n=11)
+ ImPlotColormap_Greys = 15, // white/black (qual=false, n=2 )
+};
+
+// Used to position items on a plot (e.g. legends, labels, etc.)
+enum ImPlotLocation_ {
+ ImPlotLocation_Center = 0, // center-center
+ ImPlotLocation_North = 1 << 0, // top-center
+ ImPlotLocation_South = 1 << 1, // bottom-center
+ ImPlotLocation_West = 1 << 2, // center-left
+ ImPlotLocation_East = 1 << 3, // center-right
+ ImPlotLocation_NorthWest = ImPlotLocation_North | ImPlotLocation_West, // top-left
+ ImPlotLocation_NorthEast = ImPlotLocation_North | ImPlotLocation_East, // top-right
+ ImPlotLocation_SouthWest = ImPlotLocation_South | ImPlotLocation_West, // bottom-left
+ ImPlotLocation_SouthEast = ImPlotLocation_South | ImPlotLocation_East // bottom-right
+};
+
+// Used to orient items on a plot (e.g. legends, labels, etc.)
+enum ImPlotOrientation_ {
+ ImPlotOrientation_Horizontal, // left/right
+ ImPlotOrientation_Vertical // up/down
+};
+
+// Enums for different y-axes.
+enum ImPlotYAxis_ {
+ ImPlotYAxis_1 = 0, // left (default)
+ ImPlotYAxis_2 = 1, // first on right side
+ ImPlotYAxis_3 = 2 // second on right side
+};
+
+// Enums for different automatic histogram binning methods (k = bin count or w = bin width)
+enum ImPlotBin_ {
+ ImPlotBin_Sqrt = -1, // k = sqrt(n)
+ ImPlotBin_Sturges = -2, // k = 1 + log2(n)
+ ImPlotBin_Rice = -3, // k = 2 * cbrt(n)
+ ImPlotBin_Scott = -4, // w = 3.49 * sigma / cbrt(n)
+};
+
+// Double precision version of ImVec2 used by ImPlot. Extensible by end users.
+struct ImPlotPoint {
+ double x, y;
+ ImPlotPoint() { x = y = 0.0; }
+ ImPlotPoint(double _x, double _y) { x = _x; y = _y; }
+ ImPlotPoint(const ImVec2& p) { x = p.x; y = p.y; }
+ double operator[] (size_t idx) const { return (&x)[idx]; }
+ double& operator[] (size_t idx) { return (&x)[idx]; }
+#ifdef IMPLOT_POINT_CLASS_EXTRA
+ IMPLOT_POINT_CLASS_EXTRA // Define additional constructors and implicit cast operators in imconfig.h
+ // to convert back and forth between your math types and ImPlotPoint.
+#endif
+};
+
+// A range defined by a min/max value. Used for plot axes ranges.
+struct ImPlotRange {
+ double Min, Max;
+ ImPlotRange() { Min = 0; Max = 0; }
+ ImPlotRange(double _min, double _max) { Min = _min; Max = _max; }
+ bool Contains(double value) const { return value >= Min && value <= Max; };
+ double Size() const { return Max - Min; };
+};
+
+// Combination of two ranges for X and Y axes.
+struct ImPlotLimits {
+ ImPlotRange X, Y;
+ ImPlotLimits() { }
+ ImPlotLimits(double x_min, double x_max, double y_min, double y_max) { X.Min = x_min; X.Max = x_max; Y.Min = y_min; Y.Max = y_max; }
+ bool Contains(const ImPlotPoint& p) const { return Contains(p.x, p.y); }
+ bool Contains(double x, double y) const { return X.Contains(x) && Y.Contains(y); }
+ ImPlotPoint Min() const { return ImPlotPoint(X.Min, Y.Min); }
+ ImPlotPoint Max() const { return ImPlotPoint(X.Max, Y.Max); }
+};
+
+// Plot style structure
+struct ImPlotStyle {
+ // item styling variables
+ float LineWeight; // = 1, item line weight in pixels
+ int Marker; // = ImPlotMarker_None, marker specification
+ float MarkerSize; // = 4, marker size in pixels (roughly the marker's "radius")
+ float MarkerWeight; // = 1, outline weight of markers in pixels
+ float FillAlpha; // = 1, alpha modifier applied to plot fills
+ float ErrorBarSize; // = 5, error bar whisker width in pixels
+ float ErrorBarWeight; // = 1.5, error bar whisker weight in pixels
+ float DigitalBitHeight; // = 8, digital channels bit height (at y = 1.0f) in pixels
+ float DigitalBitGap; // = 4, digital channels bit padding gap in pixels
+ // plot styling variables
+ float PlotBorderSize; // = 1, line thickness of border around plot area
+ float MinorAlpha; // = 0.25 alpha multiplier applied to minor axis grid lines
+ ImVec2 MajorTickLen; // = 10,10 major tick lengths for X and Y axes
+ ImVec2 MinorTickLen; // = 5,5 minor tick lengths for X and Y axes
+ ImVec2 MajorTickSize; // = 1,1 line thickness of major ticks
+ ImVec2 MinorTickSize; // = 1,1 line thickness of minor ticks
+ ImVec2 MajorGridSize; // = 1,1 line thickness of major grid lines
+ ImVec2 MinorGridSize; // = 1,1 line thickness of minor grid lines
+ ImVec2 PlotPadding; // = 10,10 padding between widget frame and plot area, labels, or outside legends (i.e. main padding)
+ ImVec2 LabelPadding; // = 5,5 padding between axes labels, tick labels, and plot edge
+ ImVec2 LegendPadding; // = 10,10 legend padding from plot edges
+ ImVec2 LegendInnerPadding; // = 5,5 legend inner padding from legend edges
+ ImVec2 LegendSpacing; // = 5,0 spacing between legend entries
+ ImVec2 MousePosPadding; // = 10,10 padding between plot edge and interior mouse location text
+ ImVec2 AnnotationPadding; // = 2,2 text padding around annotation labels
+ ImVec2 FitPadding; // = 0,0 additional fit padding as a percentage of the fit extents (e.g. ImVec2(0.1f,0.1f) adds 10% to the fit extents of X and Y)
+ ImVec2 PlotDefaultSize; // = 400,300 default size used when ImVec2(0,0) is passed to BeginPlot
+ ImVec2 PlotMinSize; // = 300,225 minimum size plot frame can be when shrunk
+ // style colors
+ ImVec4 Colors[ImPlotCol_COUNT]; // Array of styling colors. Indexable with ImPlotCol_ enums.
+ // colormap
+ ImPlotColormap Colormap; // The current colormap. Set this to either an ImPlotColormap_ enum or an index returned by AddColormap.
+ // settings/flags
+ bool AntiAliasedLines; // = false, enable global anti-aliasing on plot lines (overrides ImPlotFlags_AntiAliased)
+ bool UseLocalTime; // = false, axis labels will be formatted for your timezone when ImPlotAxisFlag_Time is enabled
+ bool UseISO8601; // = false, dates will be formatted according to ISO 8601 where applicable (e.g. YYYY-MM-DD, YYYY-MM, --MM-DD, etc.)
+ bool Use24HourClock; // = false, times will be formatted using a 24 hour clock
+ IMPLOT_API ImPlotStyle();
+};
+
+//-----------------------------------------------------------------------------
+// ImPlot End-User API
+//-----------------------------------------------------------------------------
+
+namespace ImPlot {
+
+//-----------------------------------------------------------------------------
+// ImPlot Context
+//-----------------------------------------------------------------------------
+
+// Creates a new ImPlot context. Call this after ImGui::CreateContext.
+IMPLOT_API ImPlotContext* CreateContext();
+// Destroys an ImPlot context. Call this before ImGui::DestroyContext. NULL = destroy current context.
+IMPLOT_API void DestroyContext(ImPlotContext* ctx = NULL);
+// Returns the current ImPlot context. NULL if no context has ben set.
+IMPLOT_API ImPlotContext* GetCurrentContext();
+// Sets the current ImPlot context.
+IMPLOT_API void SetCurrentContext(ImPlotContext* ctx);
+
+// Sets the current **ImGui** context. This is ONLY necessary if you are compiling
+// ImPlot as a DLL (not recommended) separate from your ImGui compilation. It
+// sets the global variable GImGui, which is not shared across DLL boundaries.
+// See GImGui documentation in imgui.cpp for more details.
+IMPLOT_API void SetImGuiContext(ImGuiContext* ctx);
+
+//-----------------------------------------------------------------------------
+// Begin/End Plot
+//-----------------------------------------------------------------------------
+
+// Starts a 2D plotting context. If this function returns true, EndPlot() MUST
+// be called! You are encouraged to use the following convention:
+//
+// if (BeginPlot(...)) {
+// ImPlot::PlotLine(...);
+// ...
+// EndPlot();
+// }
+//
+// Important notes:
+//
+// - #title_id must be unique to the current ImGui ID scope. If you need to avoid ID
+// collisions or don't want to display a title in the plot, use double hashes
+// (e.g. "MyPlot##HiddenIdText" or "##NoTitle").
+// - If #x_label and/or #y_label are provided, axes labels will be displayed.
+// - #size is the **frame** size of the plot widget, not the plot area. The default
+// size of plots (i.e. when ImVec2(0,0)) can be modified in your ImPlotStyle
+// (default is 400x300 px).
+// - Auxiliary y-axes must be enabled with ImPlotFlags_YAxis2/3 to be displayed.
+// - See ImPlotFlags and ImPlotAxisFlags for more available options.
+
+IMPLOT_API bool BeginPlot(const char* title_id,
+ const char* x_label = NULL,
+ const char* y_label = NULL,
+ const ImVec2& size = ImVec2(-1,0),
+ ImPlotFlags flags = ImPlotFlags_None,
+ ImPlotAxisFlags x_flags = ImPlotAxisFlags_None,
+ ImPlotAxisFlags y_flags = ImPlotAxisFlags_None,
+ ImPlotAxisFlags y2_flags = ImPlotAxisFlags_NoGridLines,
+ ImPlotAxisFlags y3_flags = ImPlotAxisFlags_NoGridLines,
+ const char* y2_label = NULL,
+ const char* y3_label = NULL);
+
+// Only call EndPlot() if BeginPlot() returns true! Typically called at the end
+// of an if statement conditioned on BeginPlot(). See example above.
+IMPLOT_API void EndPlot();
+
+//-----------------------------------------------------------------------------
+// Plot Items
+//-----------------------------------------------------------------------------
+
+// The template functions below are explicitly instantiated in implot_items.cpp.
+// They are not intended to be used generically with custom types. You will get
+// a linker error if you try! All functions support the following scalar types:
+//
+// float, double, ImS8, ImU8, ImS16, ImU16, ImS32, ImU32, ImS64, ImU64
+//
+//
+// If you need to plot custom or non-homogenous data you have a few options:
+//
+// 1. If your data is a simple struct/class (e.g. Vector2f), you can use striding.
+// This is the most performant option if applicable.
+//
+// struct Vector2f { float X, Y; };
+// ...
+// Vector2f data[42];
+// ImPlot::PlotLine("line", &data[0].x, &data[0].y, 42, 0, sizeof(Vector2f)); // or sizeof(float)*2
+//
+// 2. Write a custom getter C function or C++ lambda and pass it and optionally your data to
+// an ImPlot function post-fixed with a G (e.g. PlotScatterG). This has a slight performance
+// cost, but probably not enough to worry about unless your data is very large. Examples:
+//
+// ImPlotPoint MyDataGetter(void* data, int idx) {
+// MyData* my_data = (MyData*)data;
+// ImPlotPoint p;
+// p.x = my_data->GetTime(idx);
+// p.y = my_data->GetValue(idx);
+// return p
+// }
+// ...
+// auto my_lambda = [](void*, int idx) {
+// double t = idx / 999.0;
+// return ImPlotPoint(t, 0.5+0.5*std::sin(2*PI*10*t));
+// };
+// ...
+// if (ImPlot::BeginPlot("MyPlot")) {
+// MyData my_data;
+// ImPlot::PlotScatterG("scatter", MyDataGetter, &my_data, my_data.Size());
+// ImPlot::PlotLineG("line", my_lambda, nullptr, 1000);
+// ImPlot::EndPlot();
+// }
+//
+// NB: All types are converted to double before plotting. You may lose information
+// if you try plotting extremely large 64-bit integral types. Proceed with caution!
+
+// Plots a standard 2D line plot.
+template <typename T> IMPLOT_API void PlotLine(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotLine(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
+ IMPLOT_API void PlotLineG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset=0);
+
+// Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
+template <typename T> IMPLOT_API void PlotScatter(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotScatter(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
+ IMPLOT_API void PlotScatterG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset=0);
+
+// Plots a a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
+template <typename T> IMPLOT_API void PlotStairs(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotStairs(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
+ IMPLOT_API void PlotStairsG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset=0);
+
+// Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
+template <typename T> IMPLOT_API void PlotShaded(const char* label_id, const T* values, int count, double y_ref=0, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotShaded(const char* label_id, const T* xs, const T* ys, int count, double y_ref=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotShaded(const char* label_id, const T* xs, const T* ys1, const T* ys2, int count, int offset=0, int stride=sizeof(T));
+ IMPLOT_API void PlotShadedG(const char* label_id, ImPlotPoint (*getter1)(void* data, int idx), void* data1, ImPlotPoint (*getter2)(void* data, int idx), void* data2, int count, int offset=0);
+
+// Plots a vertical bar graph. #width and #shift are in X units.
+template <typename T> IMPLOT_API void PlotBars(const char* label_id, const T* values, int count, double width=0.67, double shift=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotBars(const char* label_id, const T* xs, const T* ys, int count, double width, int offset=0, int stride=sizeof(T));
+ IMPLOT_API void PlotBarsG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, double width, int offset=0);
+
+// Plots a horizontal bar graph. #height and #shift are in Y units.
+template <typename T> IMPLOT_API void PlotBarsH(const char* label_id, const T* values, int count, double height=0.67, double shift=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotBarsH(const char* label_id, const T* xs, const T* ys, int count, double height, int offset=0, int stride=sizeof(T));
+ IMPLOT_API void PlotBarsHG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, double height, int offset=0);
+
+// Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
+template <typename T> IMPLOT_API void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset=0, int stride=sizeof(T));
+
+// Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
+template <typename T> IMPLOT_API void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset=0, int stride=sizeof(T));
+
+/// Plots vertical stems.
+template <typename T> IMPLOT_API void PlotStems(const char* label_id, const T* values, int count, double y_ref=0, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotStems(const char* label_id, const T* xs, const T* ys, int count, double y_ref=0, int offset=0, int stride=sizeof(T));
+
+/// Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
+template <typename T> IMPLOT_API void PlotVLines(const char* label_id, const T* xs, int count, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotHLines(const char* label_id, const T* ys, int count, int offset=0, int stride=sizeof(T));
+
+// Plots a pie chart. If the sum of values > 1 or normalize is true, each value will be normalized. Center and radius are in plot units. #label_fmt can be set to NULL for no labels.
+template <typename T> IMPLOT_API void PlotPieChart(const char* const label_ids[], const T* values, int count, double x, double y, double radius, bool normalize=false, const char* label_fmt="%.1f", double angle0=90);
+
+// Plots a 2D heatmap chart. Values are expected to be in row-major order. Leave #scale_min and scale_max both at 0 for automatic color scaling, or set them to a predefined range. #label_fmt can be set to NULL for no labels.
+template <typename T> IMPLOT_API void PlotHeatmap(const char* label_id, const T* values, int rows, int cols, double scale_min=0, double scale_max=0, const char* label_fmt="%.1f", const ImPlotPoint& bounds_min=ImPlotPoint(0,0), const ImPlotPoint& bounds_max=ImPlotPoint(1,1));
+
+// Plots a horizontal histogram. #bins can be a positive integer or an ImPlotBin_ method. If #cumulative is true, each bin contains its count plus the counts of all previous bins.
+// If #density is true, the PDF is visualized. If both are true, the CDF is visualized. If #range is left unspecified, the min/max of #values will be used as the range.
+// If #range is specified, outlier values outside of the range are not binned. However, outliers still count toward normalizing and cumulative counts unless #outliers is false. The largest bin count or density is returned.
+template <typename T> IMPLOT_API double PlotHistogram(const char* label_id, const T* values, int count, int bins=ImPlotBin_Sturges, bool cumulative=false, bool density=false, ImPlotRange range=ImPlotRange(), bool outliers=true, double bar_scale=1.0);
+
+// Plots two dimensional, bivariate histogram as a heatmap. #x_bins and #y_bins can be a positive integer or an ImPlotBin. If #density is true, the PDF is visualized.
+// If #range is left unspecified, the min/max of #xs an #ys will be used as the ranges. If #range is specified, outlier values outside of range are not binned.
+// However, outliers still count toward the normalizing count for density plots unless #outliers is false. The largest bin count or density is returned.
+template <typename T> IMPLOT_API double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count, int x_bins=ImPlotBin_Sturges, int y_bins=ImPlotBin_Sturges, bool density=false, ImPlotLimits range=ImPlotLimits(), bool outliers=true);
+
+// Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
+template <typename T> IMPLOT_API void PlotDigital(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
+ IMPLOT_API void PlotDigitalG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset=0);
+
+// Plots an axis-aligned image. #bounds_min/bounds_max are in plot coordinates (y-up) and #uv0/uv1 are in texture coordinates (y-down).
+IMPLOT_API void PlotImage(const char* label_id, ImTextureID user_texture_id, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max, const ImVec2& uv0=ImVec2(0,0), const ImVec2& uv1=ImVec2(1,1), const ImVec4& tint_col=ImVec4(1,1,1,1));
+
+// Plots a centered text label at point x,y with an optional pixel offset. Text color can be changed with ImPlot::PushStyleColor(ImPlotCol_InlayText, ...).
+IMPLOT_API void PlotText(const char* text, double x, double y, bool vertical=false, const ImVec2& pix_offset=ImVec2(0,0));
+
+// Plots a dummy item (i.e. adds a legend entry colored by ImPlotCol_Line)
+IMPLOT_API void PlotDummy(const char* label_id);
+
+//-----------------------------------------------------------------------------
+// Plot Utils
+//-----------------------------------------------------------------------------
+
+// The following functions MUST be called BEFORE BeginPlot!
+
+// Set the axes range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the axes limits will be locked.
+IMPLOT_API void SetNextPlotLimits(double xmin, double xmax, double ymin, double ymax, ImGuiCond cond = ImGuiCond_Once);
+// Set the X axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the X axis limits will be locked.
+IMPLOT_API void SetNextPlotLimitsX(double xmin, double xmax, ImGuiCond cond = ImGuiCond_Once);
+// Set the Y axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the Y axis limits will be locked.
+IMPLOT_API void SetNextPlotLimitsY(double ymin, double ymax, ImGuiCond cond = ImGuiCond_Once, ImPlotYAxis y_axis = ImPlotYAxis_1);
+// Links the next plot limits to external values. Set to NULL for no linkage. The pointer data must remain valid until the matching call to EndPlot.
+IMPLOT_API void LinkNextPlotLimits(double* xmin, double* xmax, double* ymin, double* ymax, double* ymin2 = NULL, double* ymax2 = NULL, double* ymin3 = NULL, double* ymax3 = NULL);
+// Fits the next plot axes to all plotted data if they are unlocked (equivalent to double-clicks).
+IMPLOT_API void FitNextPlotAxes(bool x = true, bool y = true, bool y2 = true, bool y3 = true);
+
+// Set the X axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
+IMPLOT_API void SetNextPlotTicksX(const double* values, int n_ticks, const char* const labels[] = NULL, bool keep_default = false);
+IMPLOT_API void SetNextPlotTicksX(double x_min, double x_max, int n_ticks, const char* const labels[] = NULL, bool keep_default = false);
+// Set the Y axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
+IMPLOT_API void SetNextPlotTicksY(const double* values, int n_ticks, const char* const labels[] = NULL, bool keep_default = false, ImPlotYAxis y_axis = ImPlotYAxis_1);
+IMPLOT_API void SetNextPlotTicksY(double y_min, double y_max, int n_ticks, const char* const labels[] = NULL, bool keep_default = false, ImPlotYAxis y_axis = ImPlotYAxis_1);
+
+// Set the format for numeric X axis labels (default="%g"). Formated values will be doubles (i.e. don't supply %d, %i, etc.). Not applicable if ImPlotAxisFlags_Time enabled.
+IMPLOT_API void SetNextPlotFormatX(const char* fmt);
+// Set the format for numeric Y axis labels (default="%g"). Formated values will be doubles (i.e. don't supply %d, %i, etc.).
+IMPLOT_API void SetNextPlotFormatY(const char* fmt, ImPlotYAxis y_axis=ImPlotYAxis_1);
+
+// The following functions MUST be called BETWEEN Begin/EndPlot!
+
+// Select which Y axis will be used for subsequent plot elements. The default is ImPlotYAxis_1, or the first (left) Y axis. Enable 2nd and 3rd axes with ImPlotFlags_YAxisX.
+IMPLOT_API void SetPlotYAxis(ImPlotYAxis y_axis);
+// Hides or shows the next plot item (i.e. as if it were toggled from the legend). Use ImGuiCond_Always if you need to forcefully set this every frame.
+IMPLOT_API void HideNextItem(bool hidden = true, ImGuiCond cond = ImGuiCond_Once);
+
+// Convert pixels to a position in the current plot's coordinate system. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
+IMPLOT_API ImPlotPoint PixelsToPlot(const ImVec2& pix, ImPlotYAxis y_axis = IMPLOT_AUTO);
+IMPLOT_API ImPlotPoint PixelsToPlot(float x, float y, ImPlotYAxis y_axis = IMPLOT_AUTO);
+// Convert a position in the current plot's coordinate system to pixels. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
+IMPLOT_API ImVec2 PlotToPixels(const ImPlotPoint& plt, ImPlotYAxis y_axis = IMPLOT_AUTO);
+IMPLOT_API ImVec2 PlotToPixels(double x, double y, ImPlotYAxis y_axis = IMPLOT_AUTO);
+// Get the current Plot position (top-left) in pixels.
+IMPLOT_API ImVec2 GetPlotPos();
+// Get the curent Plot size in pixels.
+IMPLOT_API ImVec2 GetPlotSize();
+// Returns true if the plot area in the current plot is hovered.
+IMPLOT_API bool IsPlotHovered();
+// Returns true if the XAxis plot area in the current plot is hovered.
+IMPLOT_API bool IsPlotXAxisHovered();
+// Returns true if the YAxis[n] plot area in the current plot is hovered.
+IMPLOT_API bool IsPlotYAxisHovered(ImPlotYAxis y_axis = 0);
+// Returns the mouse position in x,y coordinates of the current plot. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
+IMPLOT_API ImPlotPoint GetPlotMousePos(ImPlotYAxis y_axis = IMPLOT_AUTO);
+// Returns the current plot axis range. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
+IMPLOT_API ImPlotLimits GetPlotLimits(ImPlotYAxis y_axis = IMPLOT_AUTO);
+
+// Returns true if the current plot is being box selected.
+IMPLOT_API bool IsPlotSelected();
+// Returns the current plot box selection bounds.
+IMPLOT_API ImPlotLimits GetPlotSelection(ImPlotYAxis y_axis = IMPLOT_AUTO);
+
+// Returns true if the current plot is being queried or has an active query. Query must be enabled with ImPlotFlags_Query.
+IMPLOT_API bool IsPlotQueried();
+// Returns the current plot query bounds. Query must be enabled with ImPlotFlags_Query.
+IMPLOT_API ImPlotLimits GetPlotQuery(ImPlotYAxis y_axis = IMPLOT_AUTO);
+// Set the current plot query bounds. Query must be enabled with ImPlotFlags_Query.
+IMPLOT_API void SetPlotQuery(const ImPlotLimits& query, ImPlotYAxis y_axis = IMPLOT_AUTO);
+
+//-----------------------------------------------------------------------------
+// Plot Tools
+//-----------------------------------------------------------------------------
+
+// The following functions MUST be called BETWEEN Begin/EndPlot!
+
+// Shows an annotation callout at a chosen point.
+IMPLOT_API void Annotate(double x, double y, const ImVec2& pix_offset, const char* fmt, ...) IM_FMTARGS(4);
+IMPLOT_API void Annotate(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, ...) IM_FMTARGS(5);
+IMPLOT_API void AnnotateV(double x, double y, const ImVec2& pix_offset, const char* fmt, va_list args) IM_FMTLIST(4);
+IMPLOT_API void AnnotateV(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, va_list args) IM_FMTLIST(5);
+
+// Same as above, but the annotation will always be clamped to stay inside the plot area.
+IMPLOT_API void AnnotateClamped(double x, double y, const ImVec2& pix_offset, const char* fmt, ...) IM_FMTARGS(4);
+IMPLOT_API void AnnotateClamped(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, ...) IM_FMTARGS(5);
+IMPLOT_API void AnnotateClampedV(double x, double y, const ImVec2& pix_offset, const char* fmt, va_list args) IM_FMTLIST(4);
+IMPLOT_API void AnnotateClampedV(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, va_list args) IM_FMTLIST(5);
+
+// Shows a draggable vertical guide line at an x-value. #col defaults to ImGuiCol_Text.
+IMPLOT_API bool DragLineX(const char* id, double* x_value, bool show_label = true, const ImVec4& col = IMPLOT_AUTO_COL, float thickness = 1);
+// Shows a draggable horizontal guide line at a y-value. #col defaults to ImGuiCol_Text.
+IMPLOT_API bool DragLineY(const char* id, double* y_value, bool show_label = true, const ImVec4& col = IMPLOT_AUTO_COL, float thickness = 1);
+// Shows a draggable point at x,y. #col defaults to ImGuiCol_Text.
+IMPLOT_API bool DragPoint(const char* id, double* x, double* y, bool show_label = true, const ImVec4& col = IMPLOT_AUTO_COL, float radius = 4);
+
+//-----------------------------------------------------------------------------
+// Legend Utils and Tools
+//-----------------------------------------------------------------------------
+
+// The following functions MUST be called BETWEEN Begin/EndPlot!
+
+// Set the location of the current plot's legend (default = North|West).
+IMPLOT_API void SetLegendLocation(ImPlotLocation location, ImPlotOrientation orientation = ImPlotOrientation_Vertical, bool outside = false);
+// Set the location of the current plot's mouse position text (default = South|East).
+IMPLOT_API void SetMousePosLocation(ImPlotLocation location);
+// Returns true if a plot item legend entry is hovered.
+IMPLOT_API bool IsLegendEntryHovered(const char* label_id);
+
+// Begin a popup for a legend entry.
+IMPLOT_API bool BeginLegendPopup(const char* label_id, ImGuiMouseButton mouse_button = 1);
+// End a popup for a legend entry.
+IMPLOT_API void EndLegendPopup();
+
+//-----------------------------------------------------------------------------
+// Drag and Drop Utils
+//-----------------------------------------------------------------------------
+
+// The following functions MUST be called BETWEEN Begin/EndPlot!
+
+// Turns the current plot's plotting area into a drag and drop target. Don't forget to call EndDragDropTarget!
+IMPLOT_API bool BeginDragDropTarget();
+// Turns the current plot's X-axis into a drag and drop target. Don't forget to call EndDragDropTarget!
+IMPLOT_API bool BeginDragDropTargetX();
+// Turns the current plot's Y-Axis into a drag and drop target. Don't forget to call EndDragDropTarget!
+IMPLOT_API bool BeginDragDropTargetY(ImPlotYAxis axis = ImPlotYAxis_1);
+// Turns the current plot's legend into a drag and drop target. Don't forget to call EndDragDropTarget!
+IMPLOT_API bool BeginDragDropTargetLegend();
+// Ends a drag and drop target (currently just an alias for ImGui::EndDragDropTarget).
+IMPLOT_API void EndDragDropTarget();
+
+// NB: By default, plot and axes drag and drop *sources* require holding the Ctrl modifier to initiate the drag.
+// You can change the modifier if desired. If ImGuiKeyModFlags_None is provided, the axes will be locked from panning.
+
+// Turns the current plot's plotting area into a drag and drop source. Don't forget to call EndDragDropSource!
+IMPLOT_API bool BeginDragDropSource(ImGuiKeyModFlags key_mods = ImGuiKeyModFlags_Ctrl, ImGuiDragDropFlags flags = 0);
+// Turns the current plot's X-axis into a drag and drop source. Don't forget to call EndDragDropSource!
+IMPLOT_API bool BeginDragDropSourceX(ImGuiKeyModFlags key_mods = ImGuiKeyModFlags_Ctrl, ImGuiDragDropFlags flags = 0);
+// Turns the current plot's Y-axis into a drag and drop source. Don't forget to call EndDragDropSource!
+IMPLOT_API bool BeginDragDropSourceY(ImPlotYAxis axis = ImPlotYAxis_1, ImGuiKeyModFlags key_mods = ImGuiKeyModFlags_Ctrl, ImGuiDragDropFlags flags = 0);
+// Turns an item in the current plot's legend into drag and drop source. Don't forget to call EndDragDropSource!
+IMPLOT_API bool BeginDragDropSourceItem(const char* label_id, ImGuiDragDropFlags flags = 0);
+// Ends a drag and drop source (currently just an alias for ImGui::EndDragDropSource).
+IMPLOT_API void EndDragDropSource();
+
+//-----------------------------------------------------------------------------
+// Plot and Item Styling
+//-----------------------------------------------------------------------------
+
+// Styling colors in ImPlot works similarly to styling colors in ImGui, but
+// with one important difference. Like ImGui, all style colors are stored in an
+// indexable array in ImPlotStyle. You can permanently modify these values through
+// GetStyle().Colors, or temporarily modify them with Push/Pop functions below.
+// However, by default all style colors in ImPlot default to a special color
+// IMPLOT_AUTO_COL. The behavior of this color depends upon the style color to
+// which it as applied:
+//
+// 1) For style colors associated with plot items (e.g. ImPlotCol_Line),
+// IMPLOT_AUTO_COL tells ImPlot to color the item with the next unused
+// color in the current colormap. Thus, every item will have a different
+// color up to the number of colors in the colormap, at which point the
+// colormap will roll over. For most use cases, you should not need to
+// set these style colors to anything but IMPLOT_COL_AUTO; you are
+// probably better off changing the current colormap. However, if you
+// need to explicitly color a particular item you may either Push/Pop
+// the style color around the item in question, or use the SetNextXXXStyle
+// API below. If you permanently set one of these style colors to a specific
+// color, or forget to call Pop, then all subsequent items will be styled
+// with the color you set.
+//
+// 2) For style colors associated with plot styling (e.g. ImPlotCol_PlotBg),
+// IMPLOT_AUTO_COL tells ImPlot to set that color from color data in your
+// **ImGuiStyle**. The ImGuiCol_ that these style colors default to are
+// detailed above, and in general have been mapped to produce plots visually
+// consistent with your current ImGui style. Of course, you are free to
+// manually set these colors to whatever you like, and further can Push/Pop
+// them around individual plots for plot-specific styling (e.g. coloring axes).
+
+// Provides access to plot style structure for permanant modifications to colors, sizes, etc.
+IMPLOT_API ImPlotStyle& GetStyle();
+
+// Style plot colors for current ImGui style (default).
+IMPLOT_API void StyleColorsAuto(ImPlotStyle* dst = NULL);
+// Style plot colors for ImGui "Classic".
+IMPLOT_API void StyleColorsClassic(ImPlotStyle* dst = NULL);
+// Style plot colors for ImGui "Dark".
+IMPLOT_API void StyleColorsDark(ImPlotStyle* dst = NULL);
+// Style plot colors for ImGui "Light".
+IMPLOT_API void StyleColorsLight(ImPlotStyle* dst = NULL);
+
+// Use PushStyleX to temporarily modify your ImPlotStyle. The modification
+// will last until the matching call to PopStyleX. You MUST call a pop for
+// every push, otherwise you will leak memory! This behaves just like ImGui.
+
+// Temporarily modify a style color. Don't forget to call PopStyleColor!
+IMPLOT_API void PushStyleColor(ImPlotCol idx, ImU32 col);
+IMPLOT_API void PushStyleColor(ImPlotCol idx, const ImVec4& col);
+// Undo temporary style color modification(s). Undo multiple pushes at once by increasing count.
+IMPLOT_API void PopStyleColor(int count = 1);
+
+// Temporarily modify a style variable of float type. Don't forget to call PopStyleVar!
+IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, float val);
+// Temporarily modify a style variable of int type. Don't forget to call PopStyleVar!
+IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, int val);
+// Temporarily modify a style variable of ImVec2 type. Don't forget to call PopStyleVar!
+IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, const ImVec2& val);
+// Undo temporary style variable modification(s). Undo multiple pushes at once by increasing count.
+IMPLOT_API void PopStyleVar(int count = 1);
+
+// The following can be used to modify the style of the next plot item ONLY. They do
+// NOT require calls to PopStyleX. Leave style attributes you don't want modified to
+// IMPLOT_AUTO or IMPLOT_AUTO_COL. Automatic styles will be deduced from the current
+// values in your ImPlotStyle or from Colormap data.
+
+// Set the line color and weight for the next item only.
+IMPLOT_API void SetNextLineStyle(const ImVec4& col = IMPLOT_AUTO_COL, float weight = IMPLOT_AUTO);
+// Set the fill color for the next item only.
+IMPLOT_API void SetNextFillStyle(const ImVec4& col = IMPLOT_AUTO_COL, float alpha_mod = IMPLOT_AUTO);
+// Set the marker style for the next item only.
+IMPLOT_API void SetNextMarkerStyle(ImPlotMarker marker = IMPLOT_AUTO, float size = IMPLOT_AUTO, const ImVec4& fill = IMPLOT_AUTO_COL, float weight = IMPLOT_AUTO, const ImVec4& outline = IMPLOT_AUTO_COL);
+// Set the error bar style for the next item only.
+IMPLOT_API void SetNextErrorBarStyle(const ImVec4& col = IMPLOT_AUTO_COL, float size = IMPLOT_AUTO, float weight = IMPLOT_AUTO);
+
+// Gets the last item primary color (i.e. its legend icon color)
+IMPLOT_API ImVec4 GetLastItemColor();
+
+// Returns the null terminated string name for an ImPlotCol.
+IMPLOT_API const char* GetStyleColorName(ImPlotCol idx);
+// Returns the null terminated string name for an ImPlotMarker.
+IMPLOT_API const char* GetMarkerName(ImPlotMarker idx);
+
+//-----------------------------------------------------------------------------
+// Colormaps
+//-----------------------------------------------------------------------------
+
+// Item styling is based on colormaps when the relevant ImPlotCol_XXX is set to
+// IMPLOT_AUTO_COL (default). Several built-in colormaps are available. You can
+// add and then push/pop your own colormaps as well. To permanently set a colormap,
+// modify the Colormap index member of your ImPlotStyle.
+
+// Colormap data will be ignored and a custom color will be used if you have done one of the following:
+// 1) Modified an item style color in your ImPlotStyle to anything other than IMPLOT_AUTO_COL.
+// 2) Pushed an item style color using PushStyleColor().
+// 3) Set the next item style with a SetNextXXXStyle function.
+
+// Add a new colormap. The color data will be copied. The colormap can be used by pushing either the returned index or the
+// string name with PushColormap. The colormap name must be unique and the size must be greater than 1. You will receive
+// an assert otherwise! By default colormaps are considered to be qualitative (i.e. discrete). If you want to create a
+// continuous colormap, set #qual=false. This will treat the colors you provide as keys, and ImPlot will build a linearly
+// interpolated lookup table. The memory footprint of this table will be exactly ((size-1)*255+1)*4 bytes.
+IMPLOT_API ImPlotColormap AddColormap(const char* name, const ImVec4* cols, int size, bool qual=true);
+IMPLOT_API ImPlotColormap AddColormap(const char* name, const ImU32* cols, int size, bool qual=true);
+
+// Returns the number of available colormaps (i.e. the built-in + user-added count).
+IMPLOT_API int GetColormapCount();
+// Returns a null terminated string name for a colormap given an index. Returns NULL if index is invalid.
+IMPLOT_API const char* GetColormapName(ImPlotColormap cmap);
+// Returns an index number for a colormap given a valid string name. Returns -1 if name is invalid.
+IMPLOT_API ImPlotColormap GetColormapIndex(const char* name);
+
+// Temporarily switch to one of the built-in (i.e. ImPlotColormap_XXX) or user-added colormaps (i.e. a return value of AddColormap). Don't forget to call PopColormap!
+IMPLOT_API void PushColormap(ImPlotColormap cmap);
+// Push a colormap by string name. Use built-in names such as "Default", "Deep", "Jet", etc. or a string you provided to AddColormap. Don't forget to call PopColormap!
+IMPLOT_API void PushColormap(const char* name);
+// Undo temporary colormap modification(s). Undo multiple pushes at once by increasing count.
+IMPLOT_API void PopColormap(int count = 1);
+
+// Returns the next color from the current colormap and advances the colormap for the current plot.
+// Can also be used with no return value to skip colors if desired. You need to call this between Begin/EndPlot!
+IMPLOT_API ImVec4 NextColormapColor();
+
+// Colormap utils. If cmap = IMPLOT_AUTO (default), the current colormap is assumed.
+// Pass an explicit colormap index (built-in or user-added) to specify otherwise.
+
+// Returns the size of a colormap.
+IMPLOT_API int GetColormapSize(ImPlotColormap cmap = IMPLOT_AUTO);
+// Returns a color from a colormap given an index >= 0 (modulo will be performed).
+IMPLOT_API ImVec4 GetColormapColor(int idx, ImPlotColormap cmap = IMPLOT_AUTO);
+// Sample a color from the current colormap given t between 0 and 1.
+IMPLOT_API ImVec4 SampleColormap(float t, ImPlotColormap cmap = IMPLOT_AUTO);
+
+// Shows a vertical color scale with linear spaced ticks using the specified color map. Use double hashes to hide label (e.g. "##NoLabel").
+IMPLOT_API void ColormapScale(const char* label, double scale_min, double scale_max, const ImVec2& size = ImVec2(0,0), ImPlotColormap cmap = IMPLOT_AUTO, const char* fmt = "%g");
+// Shows a horizontal slider with a colormap gradient background. Optionally returns the color sampled at t in [0 1].
+IMPLOT_API bool ColormapSlider(const char* label, float* t, ImVec4* out = NULL, const char* format = "", ImPlotColormap cmap = IMPLOT_AUTO);
+// Shows a button with a colormap gradient brackground.
+IMPLOT_API bool ColormapButton(const char* label, const ImVec2& size = ImVec2(0,0), ImPlotColormap cmap = IMPLOT_AUTO);
+
+// When items in a plot sample their color from a colormap, the color is cached and does not change
+// unless explicitly overriden. Therefore, if you change the colormap after the item has already been plotted,
+// item colors will NOT update. If you need item colors to resample the new colormap, then use this
+// function to bust the cached colors. If #plot_title_id is NULL, then every item in EVERY existing plot
+// will be cache busted. Otherwise only the plot specified by #plot_title_id will be busted. For the
+// latter, this function must be called in the same ImGui ID scope that the plot is in. You should rarely if ever
+// need this function, but it is available for applications that require runtime colormap swaps (e.g. Heatmaps demo).
+IMPLOT_API void BustColorCache(const char* plot_title_id = NULL);
+
+//-----------------------------------------------------------------------------
+// Miscellaneous
+//-----------------------------------------------------------------------------
+
+// Render icons similar to those that appear in legends (nifty for data lists).
+IMPLOT_API void ItemIcon(const ImVec4& col);
+IMPLOT_API void ItemIcon(ImU32 col);
+IMPLOT_API void ColormapIcon(ImPlotColormap cmap);
+
+// Get the plot draw list for custom rendering to the current plot area. Call between Begin/EndPlot.
+IMPLOT_API ImDrawList* GetPlotDrawList();
+// Push clip rect for rendering to current plot area. The rect can be expanded or contracted by #expand pixels. Call between Begin/EndPlot.
+IMPLOT_API void PushPlotClipRect(float expand=0);
+// Pop plot clip rect. Call between Begin/EndPlot.
+IMPLOT_API void PopPlotClipRect();
+
+// Shows ImPlot style selector dropdown menu.
+IMPLOT_API bool ShowStyleSelector(const char* label);
+// Shows ImPlot colormap selector dropdown menu.
+IMPLOT_API bool ShowColormapSelector(const char* label);
+// Shows ImPlot style editor block (not a window).
+IMPLOT_API void ShowStyleEditor(ImPlotStyle* ref = NULL);
+// Add basic help/info block for end users (not a window).
+IMPLOT_API void ShowUserGuide();
+// Shows ImPlot metrics/debug information window.
+IMPLOT_API void ShowMetricsWindow(bool* p_popen = NULL);
+
+//-----------------------------------------------------------------------------
+// Demo (add implot_demo.cpp to your sources!)
+//-----------------------------------------------------------------------------
+
+// Shows the ImPlot demo window.
+IMPLOT_API void ShowDemoWindow(bool* p_open = NULL);
+
+} // namespace ImPlot
diff --git a/3rdparty/implot/implot_demo.cpp b/3rdparty/implot/implot_demo.cpp
new file mode 100644
index 0000000..53989df
--- /dev/null
+++ b/3rdparty/implot/implot_demo.cpp
@@ -0,0 +1,1928 @@
+// MIT License
+
+// Copyright (c) 2021 Evan Pezent
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// ImPlot v0.10 WIP
+
+#include "implot.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#ifdef _MSC_VER
+#define sprintf sprintf_s
+#endif
+
+#ifndef PI
+#define PI 3.14159265358979323846
+#endif
+
+// Encapsulates examples for customizing ImPlot.
+namespace MyImPlot {
+
+// Example for Custom Data and Getters section.
+struct Vector2f {
+ Vector2f(float _x, float _y) { x = _x; y = _y; }
+ float x, y;
+};
+
+// Example for Custom Data and Getters section.
+struct WaveData {
+ double X, Amp, Freq, Offset;
+ WaveData(double x, double amp, double freq, double offset) { X = x; Amp = amp; Freq = freq; Offset = offset; }
+};
+ImPlotPoint SineWave(void* wave_data, int idx);
+ImPlotPoint SawWave(void* wave_data, int idx);
+ImPlotPoint Spiral(void*, int idx);
+
+// Example for Tables section.
+void Sparkline(const char* id, const float* values, int count, float min_v, float max_v, int offset, const ImVec4& col, const ImVec2& size);
+
+// Example for Custom Plotters and Tooltips section.
+void PlotCandlestick(const char* label_id, const double* xs, const double* opens, const double* closes, const double* lows, const double* highs, int count, bool tooltip = true, float width_percent = 0.25f, ImVec4 bullCol = ImVec4(0,1,0,1), ImVec4 bearCol = ImVec4(1,0,0,1));
+
+// Example for Custom Styles section.
+void StyleSeaborn();
+
+} // namespace MyImPlot
+
+namespace ImPlot {
+
+void ShowBenchmarkTool();
+
+template <typename T>
+inline T RandomRange(T min, T max) {
+ T scale = rand() / (T) RAND_MAX;
+ return min + scale * ( max - min );
+}
+
+ImVec4 RandomColor() {
+ ImVec4 col;
+ col.x = RandomRange(0.0f,1.0f);
+ col.y = RandomRange(0.0f,1.0f);
+ col.z = RandomRange(0.0f,1.0f);
+ col.w = 1.0f;
+ return col;
+}
+
+double RandomGauss() {
+ static double V1, V2, S;
+ static int phase = 0;
+ double X;
+ if(phase == 0) {
+ do {
+ double U1 = (double)rand() / RAND_MAX;
+ double U2 = (double)rand() / RAND_MAX;
+ V1 = 2 * U1 - 1;
+ V2 = 2 * U2 - 1;
+ S = V1 * V1 + V2 * V2;
+ } while(S >= 1 || S == 0);
+
+ X = V1 * sqrt(-2 * log(S) / S);
+ } else
+ X = V2 * sqrt(-2 * log(S) / S);
+ phase = 1 - phase;
+ return X;
+}
+
+template <int N>
+struct NormalDistribution {
+ NormalDistribution(double mean, double sd) {
+ for (int i = 0; i < N; ++i)
+ Data[i] = RandomGauss()*sd + mean;
+ }
+ double Data[N];
+};
+
+// utility structure for realtime plot
+struct ScrollingBuffer {
+ int MaxSize;
+ int Offset;
+ ImVector<ImVec2> Data;
+ ScrollingBuffer(int max_size = 2000) {
+ MaxSize = max_size;
+ Offset = 0;
+ Data.reserve(MaxSize);
+ }
+ void AddPoint(float x, float y) {
+ if (Data.size() < MaxSize)
+ Data.push_back(ImVec2(x,y));
+ else {
+ Data[Offset] = ImVec2(x,y);
+ Offset = (Offset + 1) % MaxSize;
+ }
+ }
+ void Erase() {
+ if (Data.size() > 0) {
+ Data.shrink(0);
+ Offset = 0;
+ }
+ }
+};
+
+// utility structure for realtime plot
+struct RollingBuffer {
+ float Span;
+ ImVector<ImVec2> Data;
+ RollingBuffer() {
+ Span = 10.0f;
+ Data.reserve(2000);
+ }
+ void AddPoint(float x, float y) {
+ float xmod = fmodf(x, Span);
+ if (!Data.empty() && xmod < Data.back().x)
+ Data.shrink(0);
+ Data.push_back(ImVec2(xmod, y));
+ }
+};
+
+// Huge data used by Time Formatting example (~500 MB allocation!)
+struct HugeTimeData {
+ HugeTimeData(double min) {
+ Ts = new double[Size];
+ Ys = new double[Size];
+ for (int i = 0; i < Size; ++i) {
+ Ts[i] = min + i;
+ Ys[i] = GetY(Ts[i]);
+ }
+ }
+ ~HugeTimeData() { delete[] Ts; delete[] Ys; }
+ static double GetY(double t) {
+ return 0.5 + 0.25 * sin(t/86400/12) + 0.005 * sin(t/3600);
+ }
+ double* Ts;
+ double* Ys;
+ static const int Size = 60*60*24*366;
+};
+
+void ShowDemoWindow(bool* p_open) {
+ double DEMO_TIME = ImGui::GetTime();
+ static bool show_imgui_metrics = false;
+ static bool show_implot_metrics = false;
+ static bool show_imgui_style_editor = false;
+ static bool show_implot_style_editor = false;
+ static bool show_implot_benchmark = false;
+ if (show_imgui_metrics) {
+ ImGui::ShowMetricsWindow(&show_imgui_metrics);
+ }
+ if (show_implot_metrics) {
+ ImPlot::ShowMetricsWindow(&show_implot_metrics);
+ }
+ if (show_imgui_style_editor) {
+ ImGui::Begin("Style Editor (ImGui)", &show_imgui_style_editor);
+ ImGui::ShowStyleEditor();
+ ImGui::End();
+ }
+ if (show_implot_style_editor) {
+ ImGui::SetNextWindowSize(ImVec2(415,762), ImGuiCond_Appearing);
+ ImGui::Begin("Style Editor (ImPlot)", &show_implot_style_editor);
+ ImPlot::ShowStyleEditor();
+ ImGui::End();
+ }
+ if (show_implot_benchmark) {
+ ImGui::SetNextWindowSize(ImVec2(530,740), ImGuiCond_Appearing);
+ ImGui::Begin("ImPlot Benchmark Tool", &show_implot_benchmark);
+ ImPlot::ShowBenchmarkTool();
+ ImGui::End();
+ return;
+ }
+ ImGui::SetNextWindowPos(ImVec2(50, 50), ImGuiCond_FirstUseEver);
+ ImGui::SetNextWindowSize(ImVec2(600, 750), ImGuiCond_FirstUseEver);
+ ImGui::Begin("ImPlot Demo", p_open, ImGuiWindowFlags_MenuBar);
+ if (ImGui::BeginMenuBar()) {
+ if (ImGui::BeginMenu("Tools")) {
+ ImGui::MenuItem("Metrics (ImGui)", NULL, &show_imgui_metrics);
+ ImGui::MenuItem("Metrics (ImPlot)", NULL, &show_implot_metrics);
+ ImGui::MenuItem("Style Editor (ImGui)", NULL, &show_imgui_style_editor);
+ ImGui::MenuItem("Style Editor (ImPlot)", NULL, &show_implot_style_editor);
+ ImGui::MenuItem("Benchmark", NULL, &show_implot_benchmark);
+ ImGui::EndMenu();
+ }
+ ImGui::EndMenuBar();
+ }
+ //-------------------------------------------------------------------------
+ ImGui::Text("ImPlot says hello. (%s)", IMPLOT_VERSION);
+ ImGui::Spacing();
+
+ if (ImGui::CollapsingHeader("Help")) {
+ ImGui::Text("ABOUT THIS DEMO:");
+ ImGui::BulletText("Sections below are demonstrating many aspects of the library.");
+ ImGui::BulletText("The \"Tools\" menu above gives access to: Style Editors (ImPlot/ImGui)\n"
+ "and Metrics (general purpose Dear ImGui debugging tool).");
+ ImGui::Separator();
+ ImGui::Text("PROGRAMMER GUIDE:");
+ ImGui::BulletText("See the ShowDemoWindow() code in implot_demo.cpp. <- you are here!");
+ ImGui::BulletText("By default, anti-aliased lines are turned OFF.");
+ ImGui::Indent();
+ ImGui::BulletText("Software AA can be enabled globally with ImPlotStyle.AntiAliasedLines.");
+ ImGui::BulletText("Software AA can be enabled per plot with ImPlotFlags_AntiAliased.");
+ ImGui::BulletText("AA for plots can be toggled from the plot's context menu.");
+ ImGui::BulletText("If permitable, you are better off using hardware AA (e.g. MSAA).");
+ ImGui::Unindent();
+ ImGui::BulletText("If you see visual artifacts, do one of the following:");
+ ImGui::Indent();
+ ImGui::BulletText("Handle ImGuiBackendFlags_RendererHasVtxOffset for 16-bit indices in your backend.");
+ ImGui::BulletText("Or, enable 32-bit indices in imconfig.h.");
+ ImGui::BulletText("Your current configuration is:");
+ ImGui::Indent();
+ ImGui::BulletText("ImDrawIdx: %d-bit", (int)(sizeof(ImDrawIdx) * 8));
+ ImGui::BulletText("ImGuiBackendFlags_RendererHasVtxOffset: %s", (ImGui::GetIO().BackendFlags & ImGuiBackendFlags_RendererHasVtxOffset) ? "True" : "False");
+ ImGui::Unindent();
+ ImGui::Unindent();
+ ImGui::Separator();
+ ImGui::Text("USER GUIDE:");
+ ShowUserGuide();
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Configuration")) {
+ ImGui::ShowFontSelector("Font");
+ ImGui::ShowStyleSelector("ImGui Style");
+ ImPlot::ShowStyleSelector("ImPlot Style");
+ ImPlot::ShowColormapSelector("ImPlot Colormap");
+ float indent = ImGui::CalcItemWidth() - ImGui::GetFrameHeight();
+ ImGui::Indent(ImGui::CalcItemWidth() - ImGui::GetFrameHeight());
+ ImGui::Checkbox("Anti-Aliased Lines", &ImPlot::GetStyle().AntiAliasedLines);
+ ImGui::Unindent(indent);
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Line Plots")) {
+ static float xs1[1001], ys1[1001];
+ for (int i = 0; i < 1001; ++i) {
+ xs1[i] = i * 0.001f;
+ ys1[i] = 0.5f + 0.5f * sinf(50 * (xs1[i] + (float)DEMO_TIME / 10));
+ }
+ static double xs2[11], ys2[11];
+ for (int i = 0; i < 11; ++i) {
+ xs2[i] = i * 0.1f;
+ ys2[i] = xs2[i] * xs2[i];
+ }
+ ImGui::BulletText("Anti-aliasing can be enabled from the plot's context menu (see Help).");
+ if (ImPlot::BeginPlot("Line Plot", "x", "f(x)")) {
+ ImPlot::PlotLine("sin(x)", xs1, ys1, 1001);
+ ImPlot::SetNextMarkerStyle(ImPlotMarker_Circle);
+ ImPlot::PlotLine("x^2", xs2, ys2, 11);
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Filled Line Plots")) {
+ static double xs1[101], ys1[101], ys2[101], ys3[101];
+ srand(0);
+ for (int i = 0; i < 101; ++i) {
+ xs1[i] = (float)i;
+ ys1[i] = RandomRange(400.0,450.0);
+ ys2[i] = RandomRange(275.0,350.0);
+ ys3[i] = RandomRange(150.0,225.0);
+ }
+ static bool show_lines = true;
+ static bool show_fills = true;
+ static float fill_ref = 0;
+ static int shade_mode = 0;
+ ImGui::Checkbox("Lines",&show_lines); ImGui::SameLine();
+ ImGui::Checkbox("Fills",&show_fills);
+ if (show_fills) {
+ ImGui::SameLine();
+ if (ImGui::RadioButton("To -INF",shade_mode == 0))
+ shade_mode = 0;
+ ImGui::SameLine();
+ if (ImGui::RadioButton("To +INF",shade_mode == 1))
+ shade_mode = 1;
+ ImGui::SameLine();
+ if (ImGui::RadioButton("To Ref",shade_mode == 2))
+ shade_mode = 2;
+ if (shade_mode == 2) {
+ ImGui::SameLine();
+ ImGui::SetNextItemWidth(100);
+ ImGui::DragFloat("##Ref",&fill_ref, 1, -100, 500);
+ }
+ }
+
+
+ ImPlot::SetNextPlotLimits(0,100,0,500);
+ if (ImPlot::BeginPlot("Stock Prices", "Days", "Price")) {
+ if (show_fills) {
+ ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, 0.25f);
+ ImPlot::PlotShaded("Stock 1", xs1, ys1, 101, shade_mode == 0 ? -INFINITY : shade_mode == 1 ? INFINITY : fill_ref);
+ ImPlot::PlotShaded("Stock 2", xs1, ys2, 101, shade_mode == 0 ? -INFINITY : shade_mode == 1 ? INFINITY : fill_ref);
+ ImPlot::PlotShaded("Stock 3", xs1, ys3, 101, shade_mode == 0 ? -INFINITY : shade_mode == 1 ? INFINITY : fill_ref);
+ ImPlot::PopStyleVar();
+ }
+ if (show_lines) {
+ ImPlot::PlotLine("Stock 1", xs1, ys1, 101);
+ ImPlot::PlotLine("Stock 2", xs1, ys2, 101);
+ ImPlot::PlotLine("Stock 3", xs1, ys3, 101);
+ }
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Shaded Plots##")) {
+ static float xs[1001], ys[1001], ys1[1001], ys2[1001], ys3[1001], ys4[1001];
+ srand(0);
+ for (int i = 0; i < 1001; ++i) {
+ xs[i] = i * 0.001f;
+ ys[i] = 0.25f + 0.25f * sinf(25 * xs[i]) * sinf(5 * xs[i]) + RandomRange(-0.01f, 0.01f);
+ ys1[i] = ys[i] + RandomRange(0.1f, 0.12f);
+ ys2[i] = ys[i] - RandomRange(0.1f, 0.12f);
+ ys3[i] = 0.75f + 0.2f * sinf(25 * xs[i]);
+ ys4[i] = 0.75f + 0.1f * cosf(25 * xs[i]);
+ }
+ static float alpha = 0.25f;
+ ImGui::DragFloat("Alpha",&alpha,0.01f,0,1);
+
+ if (ImPlot::BeginPlot("Shaded Plots", "X-Axis", "Y-Axis")) {
+ ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, alpha);
+ ImPlot::PlotShaded("Uncertain Data",xs,ys1,ys2,1001);
+ ImPlot::PlotLine("Uncertain Data", xs, ys, 1001);
+ ImPlot::PlotShaded("Overlapping",xs,ys3,ys4,1001);
+ ImPlot::PlotLine("Overlapping",xs,ys3,1001);
+ ImPlot::PlotLine("Overlapping",xs,ys4,1001);
+ ImPlot::PopStyleVar();
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Scatter Plots")) {
+ srand(0);
+ static float xs1[100], ys1[100];
+ for (int i = 0; i < 100; ++i) {
+ xs1[i] = i * 0.01f;
+ ys1[i] = xs1[i] + 0.1f * ((float)rand() / (float)RAND_MAX);
+ }
+ static float xs2[50], ys2[50];
+ for (int i = 0; i < 50; i++) {
+ xs2[i] = 0.25f + 0.2f * ((float)rand() / (float)RAND_MAX);
+ ys2[i] = 0.75f + 0.2f * ((float)rand() / (float)RAND_MAX);
+ }
+
+ if (ImPlot::BeginPlot("Scatter Plot", NULL, NULL)) {
+ ImPlot::PlotScatter("Data 1", xs1, ys1, 100);
+ ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, 0.25f);
+ ImPlot::SetNextMarkerStyle(ImPlotMarker_Square, 6, ImVec4(0,1,0,0.5f), IMPLOT_AUTO, ImVec4(0,1,0,1));
+ ImPlot::PlotScatter("Data 2", xs2, ys2, 50);
+ ImPlot::PopStyleVar();
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Stairstep Plots")) {
+ static float ys1[101], ys2[101];
+ for (int i = 0; i < 101; ++i) {
+ ys1[i] = 0.5f + 0.4f * sinf(50 * i * 0.01f);
+ ys2[i] = 0.5f + 0.2f * sinf(25 * i * 0.01f);
+ }
+ if (ImPlot::BeginPlot("Stairstep Plot", "x", "f(x)")) {
+ ImPlot::PlotStairs("Signal 1", ys1, 101, 0.01f);
+ ImPlot::SetNextMarkerStyle(ImPlotMarker_Square, 2.0f);
+ ImPlot::PlotStairs("Signal 2", ys2, 101, 0.01f);
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Bar Plots")) {
+
+ static bool horz = false;
+ static ImS8 midtm[10] = {83, 67, 23, 89, 83, 78, 91, 82, 85, 90};
+ static ImS16 final[10] = {80, 62, 56, 99, 55, 78, 88, 78, 90, 100};
+ static ImS32 grade[10] = {80, 69, 52, 92, 72, 78, 75, 76, 89, 95};
+
+ static const char* labels[] = {"S1","S2","S3","S4","S5","S6","S7","S8","S9","S10"};
+ static const double positions[] = {0,1,2,3,4,5,6,7,8,9};
+
+ ImGui::Checkbox("Horizontal",&horz);
+
+ if (horz) {
+ ImPlot::SetNextPlotLimits(0, 110, -0.5, 9.5, ImGuiCond_Always);
+ ImPlot::SetNextPlotTicksY(positions, 10, labels);
+ }
+ else {
+ ImPlot::SetNextPlotLimits(-0.5, 9.5, 0, 110, ImGuiCond_Always);
+ ImPlot::SetNextPlotTicksX(positions, 10, labels);
+ }
+ if (ImPlot::BeginPlot("Bar Plot", horz ? "Score" : "Student", horz ? "Student" : "Score",
+ ImVec2(-1,0), 0, 0, horz ? ImPlotAxisFlags_Invert : 0))
+ {
+ if (horz) {
+ ImPlot::SetLegendLocation(ImPlotLocation_West, ImPlotOrientation_Vertical);
+ ImPlot::PlotBarsH("Midterm Exam", midtm, 10, 0.2, -0.2);
+ ImPlot::PlotBarsH("Final Exam", final, 10, 0.2, 0);
+ ImPlot::PlotBarsH("Course Grade", grade, 10, 0.2, 0.2);
+ }
+ else {
+ ImPlot::SetLegendLocation(ImPlotLocation_South, ImPlotOrientation_Horizontal);
+ ImPlot::PlotBars("Midterm Exam", midtm, 10, 0.2, -0.2);
+ ImPlot::PlotBars("Final Exam", final, 10, 0.2, 0);
+ ImPlot::PlotBars("Course Grade", grade, 10, 0.2, 0.2);
+ }
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Error Bars")) {
+ static float xs[5] = {1,2,3,4,5};
+ static float bar[5] = {1,2,5,3,4};
+ static float lin1[5] = {8,8,9,7,8};
+ static float lin2[5] = {6,7,6,9,6};
+ static float err1[5] = {0.2f, 0.4f, 0.2f, 0.6f, 0.4f};
+ static float err2[5] = {0.4f, 0.2f, 0.4f, 0.8f, 0.6f};
+ static float err3[5] = {0.09f, 0.14f, 0.09f, 0.12f, 0.16f};
+ static float err4[5] = {0.02f, 0.08f, 0.15f, 0.05f, 0.2f};
+
+
+ ImPlot::SetNextPlotLimits(0, 6, 0, 10);
+ if (ImPlot::BeginPlot("##ErrorBars",NULL,NULL)) {
+
+ ImPlot::PlotBars("Bar", xs, bar, 5, 0.5f);
+ ImPlot::PlotErrorBars("Bar", xs, bar, err1, 5);
+
+ ImPlot::SetNextErrorBarStyle(ImPlot::GetColormapColor(1), 0);
+ ImPlot::PlotErrorBars("Line", xs, lin1, err1, err2, 5);
+ ImPlot::SetNextMarkerStyle(ImPlotMarker_Circle);
+ ImPlot::PlotLine("Line", xs, lin1, 5);
+
+ ImPlot::PushStyleColor(ImPlotCol_ErrorBar, ImPlot::GetColormapColor(2));
+ ImPlot::PlotErrorBars("Scatter", xs, lin2, err2, 5);
+ ImPlot::PlotErrorBarsH("Scatter", xs, lin2, err3, err4, 5);
+ ImPlot::PopStyleColor();
+ ImPlot::PlotScatter("Scatter", xs, lin2, 5);
+
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Stem Plots##")) {
+ static double xs[51], ys1[51], ys2[51];
+ for (int i = 0; i < 51; ++i) {
+ xs[i] = i * 0.02;
+ ys1[i] = 1.0 + 0.5 * sin(25*xs[i])*cos(2*xs[i]);
+ ys2[i] = 0.5 + 0.25 * sin(10*xs[i]) * sin(xs[i]);
+ }
+ ImPlot::SetNextPlotLimits(0,1,0,1.6);
+ if (ImPlot::BeginPlot("Stem Plots")) {
+ ImPlot::PlotStems("Stems 1",xs,ys1,51);
+ ImPlot::SetNextLineStyle(ImVec4(1,0.5f,0,0.75f));
+ ImPlot::SetNextMarkerStyle(ImPlotMarker_Square,5,ImVec4(1,0.5f,0,0.25f));
+ ImPlot::PlotStems("Stems 2", xs, ys2,51);
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Infinite Lines")) {
+ static double vals[] = {0.25, 0.5, 0.75};
+ if (ImPlot::BeginPlot("##Infinite",0,0,ImVec2(-1,0),0,ImPlotAxisFlags_NoInitialFit,ImPlotAxisFlags_NoInitialFit)) {
+ ImPlot::PlotVLines("VLines",vals,3);
+ ImPlot::PlotHLines("HLines",vals,3);
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Pie Charts")) {
+ static const char* labels1[] = {"Frogs","Hogs","Dogs","Logs"};
+ static float data1[] = {0.15f, 0.30f, 0.2f, 0.05f};
+ static bool normalize = false;
+ ImGui::SetNextItemWidth(250);
+ ImGui::DragFloat4("Values", data1, 0.01f, 0, 1);
+ if ((data1[0] + data1[1] + data1[2] + data1[3]) < 1) {
+ ImGui::SameLine();
+ ImGui::Checkbox("Normalize", &normalize);
+ }
+
+ ImPlot::SetNextPlotLimits(0,1,0,1,ImGuiCond_Always);
+ if (ImPlot::BeginPlot("##Pie1", NULL, NULL, ImVec2(250,250), ImPlotFlags_Equal | ImPlotFlags_NoMousePos, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations)) {
+ ImPlot::PlotPieChart(labels1, data1, 4, 0.5, 0.5, 0.4, normalize, "%.2f");
+ ImPlot::EndPlot();
+ }
+
+ ImGui::SameLine();
+
+ static const char* labels2[] = {"A","B","C","D","E"};
+ static int data2[] = {1,1,2,3,5};
+
+ ImPlot::PushColormap(ImPlotColormap_Pastel);
+ ImPlot::SetNextPlotLimits(0,1,0,1,ImGuiCond_Always);
+ if (ImPlot::BeginPlot("##Pie2", NULL, NULL, ImVec2(250,250), ImPlotFlags_Equal | ImPlotFlags_NoMousePos, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations)) {
+ ImPlot::PlotPieChart(labels2, data2, 5, 0.5, 0.5, 0.4, true, "%.0f", 180);
+ ImPlot::EndPlot();
+ }
+ ImPlot::PopColormap();
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Heatmaps")) {
+ static float values1[7][7] = {{0.8f, 2.4f, 2.5f, 3.9f, 0.0f, 4.0f, 0.0f},
+ {2.4f, 0.0f, 4.0f, 1.0f, 2.7f, 0.0f, 0.0f},
+ {1.1f, 2.4f, 0.8f, 4.3f, 1.9f, 4.4f, 0.0f},
+ {0.6f, 0.0f, 0.3f, 0.0f, 3.1f, 0.0f, 0.0f},
+ {0.7f, 1.7f, 0.6f, 2.6f, 2.2f, 6.2f, 0.0f},
+ {1.3f, 1.2f, 0.0f, 0.0f, 0.0f, 3.2f, 5.1f},
+ {0.1f, 2.0f, 0.0f, 1.4f, 0.0f, 1.9f, 6.3f}};
+ static float scale_min = 0;
+ static float scale_max = 6.3f;
+ static const char* xlabels[] = {"C1","C2","C3","C4","C5","C6","C7"};
+ static const char* ylabels[] = {"R1","R2","R3","R4","R5","R6","R7"};
+
+ static ImPlotColormap map = ImPlotColormap_Viridis;
+ if (ImPlot::ColormapButton(ImPlot::GetColormapName(map),ImVec2(225,0),map)) {
+ map = (map + 1) % ImPlot::GetColormapCount();
+ // We bust the color cache of our plots so that item colors will
+ // resample the new colormap in the event that they have already
+ // been created. See documentation in implot.h.
+ BustColorCache("##Heatmap1");
+ BustColorCache("##Heatmap2");
+ }
+
+ ImGui::SameLine();
+ ImGui::LabelText("##Colormap Index", "%s", "Change Colormap");
+ ImGui::SetNextItemWidth(225);
+ ImGui::DragFloatRange2("Min / Max",&scale_min, &scale_max, 0.01f, -20, 20);
+ static ImPlotAxisFlags axes_flags = ImPlotAxisFlags_Lock | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoTickMarks;
+
+ ImPlot::PushColormap(map);
+ SetNextPlotTicksX(0 + 1.0/14.0, 1 - 1.0/14.0, 7, xlabels);
+ SetNextPlotTicksY(1 - 1.0/14.0, 0 + 1.0/14.0, 7, ylabels);
+ if (ImPlot::BeginPlot("##Heatmap1",NULL,NULL,ImVec2(225,225),ImPlotFlags_NoLegend|ImPlotFlags_NoMousePos,axes_flags,axes_flags)) {
+ ImPlot::PlotHeatmap("heat",values1[0],7,7,scale_min,scale_max);
+ ImPlot::EndPlot();
+ }
+ ImGui::SameLine();
+ ImPlot::ColormapScale("##HeatScale",scale_min, scale_max, ImVec2(60,225));
+
+ ImGui::SameLine();
+
+ const int size = 200;
+ static double values2[size*size];
+ srand((unsigned int)(DEMO_TIME*1000000));
+ for (int i = 0; i < size*size; ++i)
+ values2[i] = RandomRange(0.0,1.0);
+
+ ImPlot::SetNextPlotLimits(-1,1,-1,1);
+ if (ImPlot::BeginPlot("##Heatmap2",NULL,NULL,ImVec2(225,225),0,ImPlotAxisFlags_NoDecorations,ImPlotAxisFlags_NoDecorations)) {
+ ImPlot::PlotHeatmap("heat1",values2,size,size,0,1,NULL);
+ ImPlot::PlotHeatmap("heat2",values2,size,size,0,1,NULL, ImPlotPoint(-1,-1), ImPlotPoint(0,0));
+ ImPlot::EndPlot();
+ }
+ ImPlot::PopColormap();
+
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Histograms")) {
+ static int bins = 50;
+ static bool cumulative = false;
+ static bool density = true;
+ static bool outliers = true;
+ static double mu = 5;
+ static double sigma = 2;
+
+ ImGui::SetNextItemWidth(200);
+ if (ImGui::RadioButton("Sqrt",bins==ImPlotBin_Sqrt)) { bins = ImPlotBin_Sqrt; } ImGui::SameLine();
+ if (ImGui::RadioButton("Sturges",bins==ImPlotBin_Sturges)) { bins = ImPlotBin_Sturges; } ImGui::SameLine();
+ if (ImGui::RadioButton("Rice",bins==ImPlotBin_Rice)) { bins = ImPlotBin_Rice; } ImGui::SameLine();
+ if (ImGui::RadioButton("Scott",bins==ImPlotBin_Scott)) { bins = ImPlotBin_Scott; } ImGui::SameLine();
+ if (ImGui::RadioButton("N Bins",bins>=0)) bins = 50;
+ if (bins>=0) {
+ ImGui::SameLine();
+ ImGui::SetNextItemWidth(200);
+ ImGui::SliderInt("##Bins", &bins, 1, 100);
+ }
+ if (ImGui::Checkbox("Density", &density))
+ ImPlot::FitNextPlotAxes();
+ ImGui::SameLine();
+ if (ImGui::Checkbox("Cumulative", &cumulative))
+ ImPlot::FitNextPlotAxes();
+ ImGui::SameLine();
+ static bool range = false;
+ ImGui::Checkbox("Range", &range);
+ static float rmin = -3;
+ static float rmax = 13;
+ if (range) {
+ ImGui::SameLine();
+ ImGui::SetNextItemWidth(200);
+ ImGui::DragFloat2("##Range",&rmin,0.1f,-3,13);
+ ImGui::SameLine();
+ ImGui::Checkbox("Outliers",&outliers);
+ }
+
+ static NormalDistribution<10000> dist(mu, sigma);
+ static double x[100];
+ static double y[100];
+ if (density) {
+ for (int i = 0; i < 100; ++i) {
+ x[i] = -3 + 16 * (double)i/99.0;
+ y[i] = exp( - (x[i]-mu)*(x[i]-mu) / (2*sigma*sigma)) / (sigma * sqrt(2*3.141592653589793238));
+ }
+ if (cumulative) {
+ for (int i = 1; i < 100; ++i)
+ y[i] += y[i-1];
+ for (int i = 0; i < 100; ++i)
+ y[i] /= y[99];
+ }
+ }
+
+ if (ImPlot::BeginPlot("##Histograms")) {
+ ImPlot::SetNextFillStyle(IMPLOT_AUTO_COL, 0.5f);
+ ImPlot::PlotHistogram("Empirical", dist.Data, 10000, bins, cumulative, density, range ? ImPlotRange(rmin,rmax) : ImPlotRange(), outliers);
+ if (density && outliers)
+ ImPlot::PlotLine("Theoretical",x,y,100);
+ ImPlot::EndPlot();
+ }
+
+ static int count = 500000;
+ static int xybins[2] = {200,200};
+ static bool density2 = false;
+ ImGui::SliderInt("Count",&count,100,500000);
+ ImGui::SliderInt2("Bins",xybins,1,500);
+ ImGui::SameLine();
+ ImGui::Checkbox("Density##2",&density2);
+ static NormalDistribution<500000> dist1(1, 2);
+ static NormalDistribution<500000> dist2(1, 1);
+ double max_count = 0;
+ ImPlotAxisFlags flags = ImPlotAxisFlags_AutoFit|ImPlotAxisFlags_Foreground;
+ ImPlot::PushColormap("Hot");
+ if (ImPlot::BeginPlot("##Hist2D",0,0,ImVec2(ImGui::GetContentRegionAvail().x-100-ImGui::GetStyle().ItemSpacing.x,0),0,flags,flags)) {
+ max_count = ImPlot::PlotHistogram2D("Hist2D",dist1.Data,dist2.Data,count,xybins[0],xybins[1],density2,ImPlotLimits(-6,6,-6,6));
+ ImPlot::EndPlot();
+ }
+ ImGui::SameLine();
+ ImPlot::ColormapScale(density2 ? "Density" : "Count",0,max_count,ImVec2(100,0));
+ ImPlot::PopColormap();
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Digital Plots")) {
+ ImGui::BulletText("Digital plots do not respond to Y drag and zoom, so that");
+ ImGui::Indent();
+ ImGui::Text("you can drag analog plots over the rising/falling digital edge.");
+ ImGui::Unindent();
+
+ static bool paused = false;
+ static ScrollingBuffer dataDigital[2];
+ static ScrollingBuffer dataAnalog[2];
+ static bool showDigital[2] = {true, false};
+ static bool showAnalog[2] = {true, false};
+
+ char label[32];
+ ImGui::Checkbox("digital_0", &showDigital[0]); ImGui::SameLine();
+ ImGui::Checkbox("digital_1", &showDigital[1]); ImGui::SameLine();
+ ImGui::Checkbox("analog_0", &showAnalog[0]); ImGui::SameLine();
+ ImGui::Checkbox("analog_1", &showAnalog[1]);
+
+ static float t = 0;
+ if (!paused) {
+ t += ImGui::GetIO().DeltaTime;
+ //digital signal values
+ if (showDigital[0])
+ dataDigital[0].AddPoint(t, sinf(2*t) > 0.45);
+ if (showDigital[1])
+ dataDigital[1].AddPoint(t, sinf(2*t) < 0.45);
+ //Analog signal values
+ if (showAnalog[0])
+ dataAnalog[0].AddPoint(t, sinf(2*t));
+ if (showAnalog[1])
+ dataAnalog[1].AddPoint(t, cosf(2*t));
+ }
+ ImPlot::SetNextPlotLimitsY(-1, 1);
+ ImPlot::SetNextPlotLimitsX(t - 10.0, t, paused ? ImGuiCond_Once : ImGuiCond_Always);
+ if (ImPlot::BeginPlot("##Digital")) {
+ for (int i = 0; i < 2; ++i) {
+ if (showDigital[i] && dataDigital[i].Data.size() > 0) {
+ sprintf(label, "digital_%d", i);
+ ImPlot::PlotDigital(label, &dataDigital[i].Data[0].x, &dataDigital[i].Data[0].y, dataDigital[i].Data.size(), dataDigital[i].Offset, 2 * sizeof(float));
+ }
+ }
+ for (int i = 0; i < 2; ++i) {
+ if (showAnalog[i]) {
+ sprintf(label, "analog_%d", i);
+ if (dataAnalog[i].Data.size() > 0)
+ ImPlot::PlotLine(label, &dataAnalog[i].Data[0].x, &dataAnalog[i].Data[0].y, dataAnalog[i].Data.size(), dataAnalog[i].Offset, 2 * sizeof(float));
+ }
+ }
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Images")) {
+ ImGui::BulletText("Below we are displaying the font texture, which is the only texture we have\naccess to in this demo.");
+ ImGui::BulletText("Use the 'ImTextureID' type as storage to pass pointers or identifiers to your\nown texture data.");
+ ImGui::BulletText("See ImGui Wiki page 'Image Loading and Displaying Examples'.");
+ static ImVec2 bmin(0,0);
+ static ImVec2 bmax(1,1);
+ static ImVec2 uv0(0,0);
+ static ImVec2 uv1(1,1);
+ static ImVec4 tint(1,1,1,1);
+ ImGui::SliderFloat2("Min", &bmin.x, -2, 2, "%.1f");
+ ImGui::SliderFloat2("Max", &bmax.x, -2, 2, "%.1f");
+ ImGui::SliderFloat2("UV0", &uv0.x, -2, 2, "%.1f");
+ ImGui::SliderFloat2("UV1", &uv1.x, -2, 2, "%.1f");
+ ImGui::ColorEdit4("Tint",&tint.x);
+ if (ImPlot::BeginPlot("##image")) {
+ ImPlot::PlotImage("my image",ImGui::GetIO().Fonts->TexID, bmin, bmax, uv0, uv1, tint);
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Realtime Plots")) {
+ ImGui::BulletText("Move your mouse to change the data!");
+ ImGui::BulletText("This example assumes 60 FPS. Higher FPS requires larger buffer size.");
+ static ScrollingBuffer sdata1, sdata2;
+ static RollingBuffer rdata1, rdata2;
+ ImVec2 mouse = ImGui::GetMousePos();
+ static float t = 0;
+ t += ImGui::GetIO().DeltaTime;
+ sdata1.AddPoint(t, mouse.x * 0.0005f);
+ rdata1.AddPoint(t, mouse.x * 0.0005f);
+ sdata2.AddPoint(t, mouse.y * 0.0005f);
+ rdata2.AddPoint(t, mouse.y * 0.0005f);
+
+ static float history = 10.0f;
+ ImGui::SliderFloat("History",&history,1,30,"%.1f s");
+ rdata1.Span = history;
+ rdata2.Span = history;
+
+ static ImPlotAxisFlags flags = ImPlotAxisFlags_NoTickLabels;
+ ImPlot::SetNextPlotLimitsX(t - history, t, ImGuiCond_Always);
+ ImPlot::SetNextPlotLimitsY(0,1);
+ if (ImPlot::BeginPlot("##Scrolling", NULL, NULL, ImVec2(-1,150), 0, flags, flags)) {
+ ImPlot::SetNextFillStyle(IMPLOT_AUTO_COL,0.5f);
+ ImPlot::PlotShaded("Mouse X", &sdata1.Data[0].x, &sdata1.Data[0].y, sdata1.Data.size(), -INFINITY, sdata1.Offset, 2 * sizeof(float));
+ ImPlot::PlotLine("Mouse Y", &sdata2.Data[0].x, &sdata2.Data[0].y, sdata2.Data.size(), sdata2.Offset, 2*sizeof(float));
+ ImPlot::EndPlot();
+ }
+ ImPlot::SetNextPlotLimitsX(0, history, ImGuiCond_Always);
+ ImPlot::SetNextPlotLimitsY(0,1);
+ if (ImPlot::BeginPlot("##Rolling", NULL, NULL, ImVec2(-1,150), 0, flags, flags)) {
+ ImPlot::PlotLine("Mouse X", &rdata1.Data[0].x, &rdata1.Data[0].y, rdata1.Data.size(), 0, 2 * sizeof(float));
+ ImPlot::PlotLine("Mouse Y", &rdata2.Data[0].x, &rdata2.Data[0].y, rdata2.Data.size(), 0, 2 * sizeof(float));
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Markers and Text")) {
+ static float mk_size = ImPlot::GetStyle().MarkerSize;
+ static float mk_weight = ImPlot::GetStyle().MarkerWeight;
+ ImGui::DragFloat("Marker Size",&mk_size,0.1f,2.0f,10.0f,"%.2f px");
+ ImGui::DragFloat("Marker Weight", &mk_weight,0.05f,0.5f,3.0f,"%.2f px");
+
+ ImPlot::SetNextPlotLimits(0, 10, 0, 12);
+ if (ImPlot::BeginPlot("##MarkerStyles", NULL, NULL, ImVec2(-1,0), ImPlotFlags_CanvasOnly, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations)) {
+ ImS8 xs[2] = {1,4};
+ ImS8 ys[2] = {10,11};
+
+ // filled markers
+ for (int m = 0; m < ImPlotMarker_COUNT; ++m) {
+ ImGui::PushID(m);
+ ImPlot::SetNextMarkerStyle(m, mk_size, IMPLOT_AUTO_COL, mk_weight);
+ ImPlot::PlotLine("##Filled", xs, ys, 2);
+ ImGui::PopID();
+ ys[0]--; ys[1]--;
+ }
+ xs[0] = 6; xs[1] = 9; ys[0] = 10; ys[1] = 11;
+ // open markers
+ for (int m = 0; m < ImPlotMarker_COUNT; ++m) {
+ ImGui::PushID(m);
+ ImPlot::SetNextMarkerStyle(m, mk_size, ImVec4(0,0,0,0), mk_weight);
+ ImPlot::PlotLine("##Open", xs, ys, 2);
+ ImGui::PopID();
+ ys[0]--; ys[1]--;
+ }
+
+ ImPlot::PlotText("Filled Markers", 2.5f, 6.0f);
+ ImPlot::PlotText("Open Markers", 7.5f, 6.0f);
+
+ ImPlot::PushStyleColor(ImPlotCol_InlayText, ImVec4(1,0,1,1));
+ ImPlot::PlotText("Vertical Text", 5.0f, 6.0f, true);
+ ImPlot::PopStyleColor();
+
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Log Scale")) {
+ static double xs[1001], ys1[1001], ys2[1001], ys3[1001];
+ for (int i = 0; i < 1001; ++i) {
+ xs[i] = i*0.1f;
+ ys1[i] = sin(xs[i]) + 1;
+ ys2[i] = log(xs[i]);
+ ys3[i] = pow(10.0, xs[i]);
+ }
+ ImGui::BulletText("Open the plot context menu (right click) to change scales.");
+
+ ImPlot::SetNextPlotLimits(0.1, 100, 0, 10);
+ if (ImPlot::BeginPlot("Log Plot", NULL, NULL, ImVec2(-1,0), 0, ImPlotAxisFlags_LogScale )) {
+ ImPlot::PlotLine("f(x) = x", xs, xs, 1001);
+ ImPlot::PlotLine("f(x) = sin(x)+1", xs, ys1, 1001);
+ ImPlot::PlotLine("f(x) = log(x)", xs, ys2, 1001);
+ ImPlot::PlotLine("f(x) = 10^x", xs, ys3, 21);
+ ImPlot::EndPlot();
+ }
+ }
+ if (ImGui::CollapsingHeader("Time Formatted Axes")) {
+
+ static double t_min = 1609459200; // 01/01/2021 @ 12:00:00am (UTC)
+ static double t_max = 1640995200; // 01/01/2022 @ 12:00:00am (UTC)
+
+ ImGui::BulletText("When ImPlotAxisFlags_Time is enabled on the X-Axis, values are interpreted as\n"
+ "UNIX timestamps in seconds and axis labels are formated as date/time.");
+ ImGui::BulletText("By default, labels are in UTC time but can be set to use local time instead.");
+
+ ImGui::Checkbox("Local Time",&ImPlot::GetStyle().UseLocalTime);
+ ImGui::SameLine();
+ ImGui::Checkbox("ISO 8601",&ImPlot::GetStyle().UseISO8601);
+ ImGui::SameLine();
+ ImGui::Checkbox("24 Hour Clock",&ImPlot::GetStyle().Use24HourClock);
+
+ static HugeTimeData* data = NULL;
+ if (data == NULL) {
+ ImGui::SameLine();
+ if (ImGui::Button("Generate Huge Data (~500MB!)")) {
+ static HugeTimeData sdata(t_min);
+ data = &sdata;
+ }
+ }
+
+ ImPlot::SetNextPlotLimits(t_min,t_max,0,1);
+ if (ImPlot::BeginPlot("##Time", NULL, NULL, ImVec2(-1,0), 0, ImPlotAxisFlags_Time)) {
+ if (data != NULL) {
+ // downsample our data
+ int downsample = (int)ImPlot::GetPlotLimits().X.Size() / 1000 + 1;
+ int start = (int)(ImPlot::GetPlotLimits().X.Min - t_min);
+ start = start < 0 ? 0 : start > HugeTimeData::Size - 1 ? HugeTimeData::Size - 1 : start;
+ int end = (int)(ImPlot::GetPlotLimits().X.Max - t_min) + 1000;
+ end = end < 0 ? 0 : end > HugeTimeData::Size - 1 ? HugeTimeData::Size - 1 : end;
+ int size = (end - start)/downsample;
+ // plot it
+ ImPlot::PlotLine("Time Series", &data->Ts[start], &data->Ys[start], size, 0, sizeof(double)*downsample);
+ }
+ // plot time now
+ double t_now = (double)time(0);
+ double y_now = HugeTimeData::GetY(t_now);
+ ImPlot::PlotScatter("Now",&t_now,&y_now,1);
+ ImPlot::Annotate(t_now,y_now,ImVec2(10,10),ImPlot::GetLastItemColor(),"Now");
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Multiple Y-Axes")) {
+ static float xs[1001], xs2[1001], ys1[1001], ys2[1001], ys3[1001];
+ for (int i = 0; i < 1001; ++i) {
+ xs[i] = (i*0.1f);
+ ys1[i] = sinf(xs[i]) * 3 + 1;
+ ys2[i] = cosf(xs[i]) * 0.2f + 0.5f;
+ ys3[i] = sinf(xs[i]+0.5f) * 100 + 200;
+ xs2[i] = xs[i] + 10.0f;
+ }
+ static bool y2_axis = true;
+ static bool y3_axis = true;
+ ImGui::Checkbox("Y-Axis 2", &y2_axis);
+ ImGui::SameLine();
+ ImGui::Checkbox("Y-Axis 3", &y3_axis);
+ ImGui::SameLine();
+
+ // you can fit axes programatically
+ ImGui::SameLine(); if (ImGui::Button("Fit X")) ImPlot::FitNextPlotAxes(true, false, false, false);
+ ImGui::SameLine(); if (ImGui::Button("Fit Y")) ImPlot::FitNextPlotAxes(false, true, false, false);
+ ImGui::SameLine(); if (ImGui::Button("Fit Y2")) ImPlot::FitNextPlotAxes(false, false, true, false);
+ ImGui::SameLine(); if (ImGui::Button("Fit Y3")) ImPlot::FitNextPlotAxes(false, false, false, true);
+
+ ImPlot::SetNextPlotLimits(0.1, 100, 0, 10);
+ ImPlot::SetNextPlotLimitsY(0, 1, ImGuiCond_Once, 1);
+ ImPlot::SetNextPlotLimitsY(0, 300, ImGuiCond_Once, 2);
+ if (ImPlot::BeginPlot("Multi-Axis Plot", NULL, "Y-Axis 1", ImVec2(-1,0),
+ (y2_axis ? ImPlotFlags_YAxis2 : 0) |
+ (y3_axis ? ImPlotFlags_YAxis3 : 0),
+ ImPlotAxisFlags_None, ImPlotAxisFlags_None, ImPlotAxisFlags_NoGridLines, ImPlotAxisFlags_NoGridLines,
+ "Y-Axis 2", "Y-Axis 3")) {
+ ImPlot::PlotLine("f(x) = x", xs, xs, 1001);
+ ImPlot::PlotLine("f(x) = sin(x)*3+1", xs, ys1, 1001);
+ if (y2_axis) {
+ ImPlot::SetPlotYAxis(ImPlotYAxis_2);
+ ImPlot::PlotLine("f(x) = cos(x)*.2+.5 (Y2)", xs, ys2, 1001);
+ }
+ if (y3_axis) {
+ ImPlot::SetPlotYAxis(ImPlotYAxis_3);
+ ImPlot::PlotLine("f(x) = sin(x+.5)*100+200 (Y3)", xs2, ys3, 1001);
+ }
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Linked Axes")) {
+ static double xmin = 0, xmax = 1, ymin = 0, ymax = 1;
+ static bool linkx = true, linky = true;
+ int data[2] = {0,1};
+ ImGui::Checkbox("Link X", &linkx);
+ ImGui::SameLine();
+ ImGui::Checkbox("Link Y", &linky);
+ ImPlot::LinkNextPlotLimits(linkx ? &xmin : NULL , linkx ? &xmax : NULL, linky ? &ymin : NULL, linky ? &ymax : NULL);
+ if (ImPlot::BeginPlot("Plot A")) {
+ ImPlot::PlotLine("Line",data,2);
+ ImPlot::EndPlot();
+ }
+ ImPlot::LinkNextPlotLimits(linkx ? &xmin : NULL , linkx ? &xmax : NULL, linky ? &ymin : NULL, linky ? &ymax : NULL);
+ if (ImPlot::BeginPlot("Plot B")) {
+ ImPlot::PlotLine("Line",data,2);
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Equal Axes")) {
+ static double xs[1000], ys[1000];
+ for (int i = 0; i < 1000; ++i) {
+ double angle = i * 2 * PI / 999.0;
+ xs[i] = cos(angle); ys[i] = sin(angle);
+ }
+ if (ImPlot::BeginPlot("",0,0,ImVec2(-1,0),ImPlotFlags_Equal)) {
+ ImPlot::PlotLine("Circle",xs,ys,1000);
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Auto-Fitting Data")) {
+
+ ImGui::BulletText("The Y-axis has been configured to auto-fit to only the data visible in X-axis range.");
+ ImGui::BulletText("Zoom and pan the X-axis. Disable Stems to see a difference in fit.");
+ ImGui::BulletText("If ImPlotAxisFlags_RangeFit is disabled, the axis will fit ALL data.");
+
+ static ImPlotAxisFlags xflags = ImPlotAxisFlags_None;
+ static ImPlotAxisFlags yflags = ImPlotAxisFlags_AutoFit|ImPlotAxisFlags_RangeFit;
+
+ ImGui::TextUnformatted("X: "); ImGui::SameLine();
+ ImGui::CheckboxFlags("ImPlotAxisFlags_AutoFit##X", (unsigned int*)&xflags, ImPlotAxisFlags_AutoFit); ImGui::SameLine();
+ ImGui::CheckboxFlags("ImPlotAxisFlags_RangeFit##X", (unsigned int*)&xflags, ImPlotAxisFlags_RangeFit);
+
+ ImGui::TextUnformatted("Y: "); ImGui::SameLine();
+ ImGui::CheckboxFlags("ImPlotAxisFlags_AutoFit##Y", (unsigned int*)&yflags, ImPlotAxisFlags_AutoFit); ImGui::SameLine();
+ ImGui::CheckboxFlags("ImPlotAxisFlags_RangeFit##Y", (unsigned int*)&yflags, ImPlotAxisFlags_RangeFit);
+
+ static double data[101];
+ srand(0);
+ for (int i = 0; i < 101; ++i)
+ data[i] = 1 + sin(i/10.0f);
+
+ if (ImPlot::BeginPlot("##DataFitting","X","Y",ImVec2(-1,0),0,xflags,yflags)) {
+ ImPlot::PlotLine("Line",data,101);
+ ImPlot::PlotStems("Stems",data,101);
+ ImPlot::EndPlot();
+ };
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Querying")) {
+ static ImVector<ImPlotPoint> data;
+ static ImPlotLimits range, query, select;
+
+ ImGui::BulletText("Ctrl + click in the plot area to draw points.");
+ ImGui::BulletText("Middle click (or Ctrl + right click) and drag to create a query rect.");
+ ImGui::Indent();
+ ImGui::BulletText("Hold Alt to expand query horizontally.");
+ ImGui::BulletText("Hold Shift to expand query vertically.");
+ ImGui::BulletText("The query rect can be dragged after it's created.");
+ ImGui::Unindent();
+
+ if (ImPlot::BeginPlot("##Drawing", NULL, NULL, ImVec2(-1,0), ImPlotFlags_Query, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations)) {
+ if (ImPlot::IsPlotHovered() && ImGui::IsMouseClicked(0) && ImGui::GetIO().KeyCtrl) {
+ ImPlotPoint pt = ImPlot::GetPlotMousePos();
+ data.push_back(pt);
+ }
+ if (data.size() > 0)
+ ImPlot::PlotScatter("Points", &data[0].x, &data[0].y, data.size(), 0, 2 * sizeof(double));
+ if (ImPlot::IsPlotQueried() && data.size() > 0) {
+ ImPlotLimits range2 = ImPlot::GetPlotQuery();
+ int cnt = 0;
+ ImPlotPoint avg;
+ for (int i = 0; i < data.size(); ++i) {
+ if (range2.Contains(data[i].x, data[i].y)) {
+ avg.x += data[i].x;
+ avg.y += data[i].y;
+ cnt++;
+ }
+ }
+ if (cnt > 0) {
+ avg.x = avg.x / cnt;
+ avg.y = avg.y / cnt;
+ ImPlot::SetNextMarkerStyle(ImPlotMarker_Square);
+ ImPlot::PlotScatter("Average", &avg.x, &avg.y, 1);
+ }
+ }
+ range = ImPlot::GetPlotLimits();
+ query = ImPlot::GetPlotQuery();
+ select = ImPlot::GetPlotSelection();
+ ImPlot::EndPlot();
+ }
+ ImGui::Text("Limits: [%g,%g,%g,%g]", range.X.Min, range.X.Max, range.Y.Min, range.Y.Max);
+ ImGui::Text("Query: [%g,%g,%g,%g]", query.X.Min, query.X.Max, query.Y.Min, query.Y.Max);
+ ImGui::Text("Selection: [%g,%g,%g,%g]", select.X.Min, select.X.Max, select.Y.Min, select.Y.Max);
+
+ ImGui::Separator();
+
+ // mimic's soulthread's imgui_plot demo
+ static float x_data[512];
+ static float y_data1[512];
+ static float y_data2[512];
+ static float y_data3[512];
+ static float sampling_freq = 44100;
+ static float freq = 500;
+ for (size_t i = 0; i < 512; ++i) {
+ const float t = i / sampling_freq;
+ x_data[i] = t;
+ const float arg = 2 * 3.14f * freq * t;
+ y_data1[i] = sinf(arg);
+ y_data2[i] = y_data1[i] * -0.6f + sinf(2 * arg) * 0.4f;
+ y_data3[i] = y_data2[i] * -0.6f + sinf(3 * arg) * 0.4f;
+ }
+ ImGui::BulletText("Query the first plot to render a subview in the second plot (see above for controls).");
+ ImPlotAxisFlags flags = ImPlotAxisFlags_NoTickLabels;
+ static bool use_selection = false;
+ ImGui::Checkbox("Use Box Selection",&use_selection);
+ bool is_viewed = false;
+ ImPlotLimits view;
+ ImPlot::SetNextPlotLimits(0,0.01,-1,1);
+ if (ImPlot::BeginPlot("##View1",NULL,NULL,ImVec2(-1,150), ImPlotFlags_Query, flags, flags)) {
+ ImPlot::PlotLine("Signal 1", x_data, y_data1, 512);
+ ImPlot::PlotLine("Signal 2", x_data, y_data2, 512);
+ ImPlot::PlotLine("Signal 3", x_data, y_data3, 512);
+ is_viewed = use_selection ? ImPlot::IsPlotSelected() : ImPlot::IsPlotQueried();
+ view = use_selection ? ImPlot::GetPlotSelection() : ImPlot::GetPlotQuery();
+ ImPlot::EndPlot();
+ }
+ ImPlot::SetNextPlotLimits(view.X.Min, view.X.Max, view.Y.Min, view.Y.Max, ImGuiCond_Always);
+ if (ImPlot::BeginPlot("##View2",NULL,NULL,ImVec2(-1,150), ImPlotFlags_CanvasOnly, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations)) {
+ if (is_viewed) {
+ ImPlot::PlotLine("Signal 1", x_data, y_data1, 512);
+ ImPlot::PlotLine("Signal 2", x_data, y_data2, 512);
+ ImPlot::PlotLine("Signal 3", x_data, y_data3, 512);
+ }
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Legend")) {
+ static ImPlotLocation loc = ImPlotLocation_East;
+ static bool h = false; static bool o = true;
+ ImGui::CheckboxFlags("North", (unsigned int*)&loc, ImPlotLocation_North); ImGui::SameLine();
+ ImGui::CheckboxFlags("South", (unsigned int*)&loc, ImPlotLocation_South); ImGui::SameLine();
+ ImGui::CheckboxFlags("West", (unsigned int*)&loc, ImPlotLocation_West); ImGui::SameLine();
+ ImGui::CheckboxFlags("East", (unsigned int*)&loc, ImPlotLocation_East); ImGui::SameLine();
+ ImGui::Checkbox("Horizontal##2", &h); ImGui::SameLine();
+ ImGui::Checkbox("Outside", &o);
+
+ ImGui::SliderFloat2("LegendPadding", (float*)&GetStyle().LegendPadding, 0.0f, 20.0f, "%.0f");
+ ImGui::SliderFloat2("LegendInnerPadding", (float*)&GetStyle().LegendInnerPadding, 0.0f, 10.0f, "%.0f");
+ ImGui::SliderFloat2("LegendSpacing", (float*)&GetStyle().LegendSpacing, 0.0f, 5.0f, "%.0f");
+
+ if (ImPlot::BeginPlot("##Legend","x","y",ImVec2(-1,0))) {
+ ImPlot::SetLegendLocation(loc, h ? ImPlotOrientation_Horizontal : ImPlotOrientation_Vertical, o);
+ static MyImPlot::WaveData data1(0.001, 0.2, 2, 0.75);
+ static MyImPlot::WaveData data2(0.001, 0.2, 4, 0.25);
+ static MyImPlot::WaveData data3(0.001, 0.2, 6, 0.5);
+ ImPlot::PlotLineG("Item 1", MyImPlot::SineWave, &data1, 1000); // "Item 1" added to legend
+ ImPlot::PlotLineG("Item 2##IDText", MyImPlot::SawWave, &data2, 1000); // "Item 2" added to legend, text after ## used for ID only
+ ImPlot::PlotLineG("##NotListed", MyImPlot::SawWave, &data3, 1000); // plotted, but not added to legend
+ ImPlot::PlotLineG("Item 3", MyImPlot::SineWave, &data1, 1000); // "Item 3" added to legend
+ ImPlot::PlotLineG("Item 3", MyImPlot::SawWave, &data2, 1000); // combined with previous "Item 3"
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Drag Lines and Points")) {
+ ImGui::BulletText("Click and drag the horizontal and vertical lines.");
+ static double x1 = 0.2;
+ static double x2 = 0.8;
+ static double y1 = 0.25;
+ static double y2 = 0.75;
+ static double f = 0.1;
+ static bool show_labels = true;
+ ImGui::Checkbox("Show Labels##1",&show_labels);
+ ImPlot::SetNextPlotLimits(0,1,0,1);
+ if (ImPlot::BeginPlot("##guides",0,0,ImVec2(-1,0),ImPlotFlags_YAxis2)) {
+ ImPlot::DragLineX("x1",&x1,show_labels);
+ ImPlot::DragLineX("x2",&x2,show_labels);
+ ImPlot::DragLineY("y1",&y1,show_labels);
+ ImPlot::DragLineY("y2",&y2,show_labels);
+ double xs[1000], ys[1000];
+ for (int i = 0; i < 1000; ++i) {
+ xs[i] = (x2+x1)/2+fabs(x2-x1)*(i/1000.0f - 0.5f);
+ ys[i] = (y1+y2)/2+fabs(y2-y1)/2*sin(f*i/10);
+ }
+ ImPlot::PlotLine("Interactive Data", xs, ys, 1000);
+ ImPlot::SetPlotYAxis(ImPlotYAxis_2);
+ ImPlot::DragLineY("f",&f,show_labels,ImVec4(1,0.5f,1,1));
+ ImPlot::EndPlot();
+ }
+ ImGui::BulletText("Click and drag any point.");
+ ImGui::Checkbox("Show Labels##2",&show_labels);
+ ImPlotAxisFlags flags = ImPlotAxisFlags_NoTickLabels | ImPlotAxisFlags_NoTickMarks;
+ ImPlot::SetNextPlotLimits(0,1,0,1);
+ if (ImPlot::BeginPlot("##Bezier",0,0,ImVec2(-1,0),ImPlotFlags_CanvasOnly,flags,flags)) {
+ static ImPlotPoint P[] = {ImPlotPoint(.05f,.05f), ImPlotPoint(0.2,0.4), ImPlotPoint(0.8,0.6), ImPlotPoint(.95f,.95f)};
+ static ImPlotPoint B[100];
+ for (int i = 0; i < 100; ++i) {
+ double t = i / 99.0;
+ double u = 1 - t;
+ double w1 = u*u*u;
+ double w2 = 3*u*u*t;
+ double w3 = 3*u*t*t;
+ double w4 = t*t*t;
+ B[i] = ImPlotPoint(w1*P[0].x + w2*P[1].x + w3*P[2].x + w4*P[3].x, w1*P[0].y + w2*P[1].y + w3*P[2].y + w4*P[3].y);
+ }
+ ImPlot::SetNextLineStyle(ImVec4(0,0.9f,0,1), 2);
+ ImPlot::PlotLine("##bez",&B[0].x, &B[0].y, 100, 0, sizeof(ImPlotPoint));
+ ImPlot::SetNextLineStyle(ImVec4(1,0.5f,1,1));
+ ImPlot::PlotLine("##h1",&P[0].x, &P[0].y, 2, 0, sizeof(ImPlotPoint));
+ ImPlot::SetNextLineStyle(ImVec4(0,0.5f,1,1));
+ ImPlot::PlotLine("##h2",&P[2].x, &P[2].y, 2, 0, sizeof(ImPlotPoint));
+ ImPlot::DragPoint("P0",&P[0].x,&P[0].y, show_labels, ImVec4(0,0.9f,0,1));
+ ImPlot::DragPoint("P1",&P[1].x,&P[1].y, show_labels, ImVec4(1,0.5f,1,1));
+ ImPlot::DragPoint("P2",&P[2].x,&P[2].y, show_labels, ImVec4(0,0.5f,1,1));
+ ImPlot::DragPoint("P3",&P[3].x,&P[3].y, show_labels, ImVec4(0,0.9f,0,1));
+ ImPlot::EndPlot();
+ }
+ }
+ if (ImGui::CollapsingHeader("Annotations")) {
+ static bool clamp = false;
+ ImGui::Checkbox("Clamp",&clamp);
+ ImPlot::SetNextPlotLimits(0,2,0,1);
+ if (ImPlot::BeginPlot("##Annotations")) {
+
+ static float p[] = {0.25f, 0.25f, 0.75f, 0.75f, 0.25f};
+ ImPlot::PlotScatter("##Points",&p[0],&p[1],4);
+ ImVec4 col = GetLastItemColor();
+ clamp ? ImPlot::AnnotateClamped(0.25,0.25,ImVec2(-15,15),col,"BL") : ImPlot::Annotate(0.25,0.25,ImVec2(-15,15),col,"BL");
+ clamp ? ImPlot::AnnotateClamped(0.75,0.25,ImVec2(15,15),col,"BR") : ImPlot::Annotate(0.75,0.25,ImVec2(15,15),col,"BR");
+ clamp ? ImPlot::AnnotateClamped(0.75,0.75,ImVec2(15,-15),col,"TR") : ImPlot::Annotate(0.75,0.75,ImVec2(15,-15),col,"TR");
+ clamp ? ImPlot::AnnotateClamped(0.25,0.75,ImVec2(-15,-15),col,"TL") : ImPlot::Annotate(0.25,0.75,ImVec2(-15,-15),col,"TL");
+ clamp ? ImPlot::AnnotateClamped(0.5,0.5,ImVec2(0,0),col,"Center") : ImPlot::Annotate(0.5,0.5,ImVec2(0,0),col,"Center");
+
+ float bx[] = {1.2f,1.5f,1.8f};
+ float by[] = {0.25f, 0.5f, 0.75f};
+ ImPlot::PlotBars("##Bars",bx,by,3,0.2);
+ for (int i = 0; i < 3; ++i)
+ ImPlot::Annotate(bx[i],by[i],ImVec2(0,-5),"B[%d]=%.2f",i,by[i]);
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Drag and Drop")) {
+ ImGui::BulletText("Drag/drop items from the left column.");
+ ImGui::BulletText("Drag/drop items between plots.");
+ ImGui::Indent();
+ ImGui::BulletText("Plot 1 Targets: Plot, Y-Axes, Legend");
+ ImGui::BulletText("Plot 1 Sources: Legend Items");
+ ImGui::BulletText("Plot 2 Targets: Plot, X-Axis, Y-Axis");
+ ImGui::BulletText("Plot 2 Sources: Plot, X-Axis, Y-Axis (hold Ctrl)");
+ ImGui::Unindent();
+
+ // convenience struct to manage DND items; do this however you like
+ struct MyDndItem {
+ int Idx;
+ int Plt;
+ int Yax;
+ char Label[16];
+ ImVector<ImVec2> Data;
+ ImVec4 Color;
+ MyDndItem() {
+ static int i = 0;
+ Idx = i++;
+ Plt = 0;
+ Yax = ImPlotYAxis_1;
+ sprintf(Label, "%02d Hz", Idx+1);
+ Color = RandomColor();
+ Data.reserve(1001);
+ for (int k = 0; k < 1001; ++k) {
+ float t = k * 1.0f / 999;
+ Data.push_back(ImVec2(t, 0.5f + 0.5f * sinf(2*3.14f*t*(Idx+1))));
+ }
+ }
+ void Reset() { Plt = 0; Yax = ImPlotYAxis_1; }
+ };
+
+ const int k_dnd = 20;
+ static MyDndItem dnd[k_dnd];
+ static MyDndItem* dndx = NULL; // for plot 2
+ static MyDndItem* dndy = NULL; // for plot 2
+
+ // child window to serve as initial source for our DND items
+ ImGui::BeginChild("DND_LEFT",ImVec2(100,400));
+ if (ImGui::Button("Reset Data", ImVec2(100, 0))) {
+ for (int k = 0; k < k_dnd; ++k)
+ dnd[k].Reset();
+ dndx = dndy = NULL;
+ }
+ for (int k = 0; k < k_dnd; ++k) {
+ if (dnd[k].Plt > 0)
+ continue;
+ ImPlot::ItemIcon(dnd[k].Color); ImGui::SameLine();
+ ImGui::Selectable(dnd[k].Label, false, 0, ImVec2(100, 0));
+ if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_None)) {
+ ImGui::SetDragDropPayload("MY_DND", &k, sizeof(int));
+ ImPlot::ItemIcon(dnd[k].Color); ImGui::SameLine();
+ ImGui::TextUnformatted(dnd[k].Label);
+ ImGui::EndDragDropSource();
+ }
+ }
+ ImGui::EndChild();
+ if (ImGui::BeginDragDropTarget()) {
+ if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
+ int i = *(int*)payload->Data; dnd[i].Reset();
+ }
+ ImGui::EndDragDropTarget();
+ }
+
+ ImGui::SameLine();
+ ImGui::BeginChild("DND_RIGHT",ImVec2(-1,400));
+ // plot 1 (time series)
+ ImPlotAxisFlags flags = ImPlotAxisFlags_NoTickLabels | ImPlotAxisFlags_NoGridLines;
+ if (ImPlot::BeginPlot("##DND1", NULL, "[drop here]", ImVec2(-1,195), ImPlotFlags_YAxis2 | ImPlotFlags_YAxis3, flags | ImPlotAxisFlags_Lock, flags, flags, flags, "[drop here]", "[drop here]")) {
+ for (int k = 0; k < k_dnd; ++k) {
+ if (dnd[k].Plt == 1 && dnd[k].Data.size() > 0) {
+ ImPlot::SetPlotYAxis(dnd[k].Yax);
+ ImPlot::SetNextLineStyle(dnd[k].Color);
+ static char label[32];
+ sprintf(label,"%s (Y%d)", dnd[k].Label, dnd[k].Yax+1);
+ ImPlot::PlotLine(label, &dnd[k].Data[0].x, &dnd[k].Data[0].y, dnd[k].Data.size(), 0, 2 * sizeof(float));
+ // allow legend item labels to be DND sources
+ if (ImPlot::BeginDragDropSourceItem(label)) {
+ ImGui::SetDragDropPayload("MY_DND", &k, sizeof(int));
+ ImPlot::ItemIcon(dnd[k].Color); ImGui::SameLine();
+ ImGui::TextUnformatted(dnd[k].Label);
+ ImPlot::EndDragDropSource();
+ }
+ }
+ }
+ // allow the main plot area to be a DND target
+ if (ImPlot::BeginDragDropTarget()) {
+ if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
+ int i = *(int*)payload->Data; dnd[i].Plt = 1; dnd[i].Yax = 0;
+ }
+ ImPlot::EndDragDropTarget();
+ }
+ // allow each y-axis to be a DND target
+ for (int y = 0; y < 3; ++y) {
+ if (ImPlot::BeginDragDropTargetY(y)) {
+ if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
+ int i = *(int*)payload->Data; dnd[i].Plt = 1; dnd[i].Yax = y;
+ }
+ ImPlot::EndDragDropTarget();
+ }
+ }
+ // allow the legend to be a DND target
+ if (ImPlot::BeginDragDropTargetLegend()) {
+ if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
+ int i = *(int*)payload->Data; dnd[i].Plt = 1; dnd[i].Yax = 0;
+ }
+ ImPlot::EndDragDropTarget();
+ }
+ ImPlot::EndPlot();
+ }
+ // plot 2 (Lissajous)
+ ImPlot::PushStyleColor(ImPlotCol_XAxis, dndx == NULL ? ImPlot::GetStyle().Colors[ImPlotCol_XAxis] : dndx->Color);
+ ImPlot::PushStyleColor(ImPlotCol_YAxis, dndy == NULL ? ImPlot::GetStyle().Colors[ImPlotCol_YAxis] : dndy->Color);
+ if (ImPlot::BeginPlot("##DND2", dndx == NULL ? "[drop here]" : dndx->Label, dndy == NULL ? "[drop here]" : dndy->Label, ImVec2(-1,195), 0, flags, flags )) {
+ if (dndx != NULL && dndy != NULL) {
+ ImVec4 mixed((dndx->Color.x + dndy->Color.x)/2,(dndx->Color.y + dndy->Color.y)/2,(dndx->Color.z + dndy->Color.z)/2,(dndx->Color.w + dndy->Color.w)/2);
+ ImPlot::SetNextLineStyle(mixed);
+ ImPlot::PlotLine("##dndxy", &dndx->Data[0].y, &dndy->Data[0].y, dndx->Data.size(), 0, 2 * sizeof(float));
+ }
+ // allow the x-axis to be a DND target
+ if (ImPlot::BeginDragDropTargetX()) {
+ if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
+ int i = *(int*)payload->Data; dndx = &dnd[i];
+ }
+ ImPlot::EndDragDropTarget();
+ }
+ // allow the x-axis to be a DND source
+ if (dndx != NULL && ImPlot::BeginDragDropSourceX()) {
+ ImGui::SetDragDropPayload("MY_DND", &dndx->Idx, sizeof(int));
+ ImPlot::ItemIcon(dndx->Color); ImGui::SameLine();
+ ImGui::TextUnformatted(dndx->Label);
+ ImPlot::EndDragDropSource();
+ }
+ // allow the y-axis to be a DND target
+ if (ImPlot::BeginDragDropTargetY()) {
+ if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
+ int i = *(int*)payload->Data; dndy = &dnd[i];
+ }
+ ImPlot::EndDragDropTarget();
+ }
+ // allow the y-axis to be a DND source
+ if (dndy != NULL && ImPlot::BeginDragDropSourceY()) {
+ ImGui::SetDragDropPayload("MY_DND", &dndy->Idx, sizeof(int));
+ ImPlot::ItemIcon(dndy->Color); ImGui::SameLine();
+ ImGui::TextUnformatted(dndy->Label);
+ ImPlot::EndDragDropSource();
+ }
+ // allow the plot area to be a DND target
+ if (ImPlot::BeginDragDropTarget()) {
+ if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
+ int i = *(int*)payload->Data; dndx = dndy = &dnd[i];
+ }
+ }
+ // allow the plot area to be a DND source
+ if (ImPlot::BeginDragDropSource()) {
+ ImGui::TextUnformatted("Yes, you can\ndrag this!");
+ ImPlot::EndDragDropSource();
+ }
+ ImPlot::EndPlot();
+ }
+ ImPlot::PopStyleColor(2);
+ ImGui::EndChild();
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Tables")) {
+#ifdef IMGUI_HAS_TABLE
+ static ImGuiTableFlags flags = ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersV | ImGuiTableFlags_RowBg;
+ static bool anim = true;
+ static int offset = 0;
+ ImGui::BulletText("Plots can be used inside of ImGui tables.");
+ ImGui::Checkbox("Animate",&anim);
+ if (anim)
+ offset = (offset + 1) % 100;
+ if (ImGui::BeginTable("##table", 3, flags, ImVec2(-1,0))) {
+ ImGui::TableSetupColumn("Electrode", ImGuiTableColumnFlags_WidthFixed, 75.0f);
+ ImGui::TableSetupColumn("Voltage", ImGuiTableColumnFlags_WidthFixed, 75.0f);
+ ImGui::TableSetupColumn("EMG Signal");
+ ImGui::TableHeadersRow();
+ ImPlot::PushColormap(ImPlotColormap_Cool);
+ for (int row = 0; row < 10; row++) {
+ ImGui::TableNextRow();
+ static float data[100];
+ srand(row);
+ for (int i = 0; i < 100; ++i)
+ data[i] = RandomRange(0.0f,10.0f);
+ ImGui::TableSetColumnIndex(0);
+ ImGui::Text("EMG %d", row);
+ ImGui::TableSetColumnIndex(1);
+ ImGui::Text("%.3f V", data[offset]);
+ ImGui::TableSetColumnIndex(2);
+ ImGui::PushID(row);
+ MyImPlot::Sparkline("##spark",data,100,0,11.0f,offset,ImPlot::GetColormapColor(row),ImVec2(-1, 35));
+ ImGui::PopID();
+ }
+ ImPlot::PopColormap();
+ ImGui::EndTable();
+ }
+#else
+ ImGui::BulletText("You need to merge the ImGui 'tables' branch for this section.");
+#endif
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Offset and Stride")) {
+ static const int k_circles = 11;
+ static const int k_points_per = 50;
+ static const int k_size = 2 * k_points_per * k_circles;
+ static double interleaved_data[k_size];
+ for (int p = 0; p < k_points_per; ++p) {
+ for (int c = 0; c < k_circles; ++c) {
+ double r = (double)c / (k_circles - 1) * 0.2 + 0.2;
+ interleaved_data[p*2*k_circles + 2*c + 0] = 0.5 + r * cos((double)p/k_points_per * 6.28);
+ interleaved_data[p*2*k_circles + 2*c + 1] = 0.5 + r * sin((double)p/k_points_per * 6.28);
+ }
+ }
+ static int offset = 0;
+ ImGui::BulletText("Offsetting is useful for realtime plots (see above) and circular buffers.");
+ ImGui::BulletText("Striding is useful for interleaved data (e.g. audio) or plotting structs.");
+ ImGui::BulletText("Here, all circle data is stored in a single interleaved buffer:");
+ ImGui::BulletText("[c0.x0 c0.y0 ... cn.x0 cn.y0 c0.x1 c0.y1 ... cn.x1 cn.y1 ... cn.xm cn.ym]");
+ ImGui::BulletText("The offset value indicates which circle point index is considered the first.");
+ ImGui::BulletText("Offsets can be negative and/or larger than the actual data count.");
+ ImGui::SliderInt("Offset", &offset, -2*k_points_per, 2*k_points_per);
+ if (ImPlot::BeginPlot("##strideoffset",0,0,ImVec2(-1,0), ImPlotFlags_Equal)) {
+ ImPlot::PushColormap(ImPlotColormap_Jet);
+ char buff[16];
+ for (int c = 0; c < k_circles; ++c) {
+ sprintf(buff, "Circle %d", c);
+ ImPlot::PlotLine(buff, &interleaved_data[c*2 + 0], &interleaved_data[c*2 + 1], k_points_per, offset, 2*k_circles*sizeof(double));
+ }
+ ImPlot::EndPlot();
+ ImPlot::PopColormap();
+ }
+ // offset++; uncomment for animation!
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Custom Data and Getters")) {
+ ImGui::BulletText("You can plot custom structs using the stride feature.");
+ ImGui::BulletText("Most plotters can also be passed a function pointer for getting data.");
+ ImGui::Indent();
+ ImGui::BulletText("You can optionally pass user data to be given to your getter function.");
+ ImGui::BulletText("C++ lambdas can be passed as function pointers as well!");
+ ImGui::Unindent();
+
+ MyImPlot::Vector2f vec2_data[2] = { MyImPlot::Vector2f(0,0), MyImPlot::Vector2f(1,1) };
+
+ if (ImPlot::BeginPlot("##Custom Data")) {
+
+ // custom structs using stride example:
+ ImPlot::PlotLine("Vector2f", &vec2_data[0].x, &vec2_data[0].y, 2, 0, sizeof(MyImPlot::Vector2f) /* or sizeof(float) * 2 */);
+
+ // custom getter example 1:
+ ImPlot::PlotLineG("Spiral", MyImPlot::Spiral, NULL, 1000);
+
+ // custom getter example 2:
+ static MyImPlot::WaveData data1(0.001, 0.2, 2, 0.75);
+ static MyImPlot::WaveData data2(0.001, 0.2, 4, 0.25);
+ ImPlot::PlotLineG("Waves", MyImPlot::SineWave, &data1, 1000);
+ ImPlot::PlotLineG("Waves", MyImPlot::SawWave, &data2, 1000);
+ ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, 0.25f);
+ ImPlot::PlotShadedG("Waves", MyImPlot::SineWave, &data1, MyImPlot::SawWave, &data2, 1000);
+ ImPlot::PopStyleVar();
+
+ // you can also pass C++ lambdas:
+ // auto lamda = [](void* data, int idx) { ... return ImPlotPoint(x,y); };
+ // ImPlot::PlotLine("My Lambda", lambda, data, 1000);
+
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Custom Ticks##")) {
+ static bool custom_fmt = true;
+ static bool custom_ticks = false;
+ static bool custom_labels = true;
+ ImGui::Checkbox("Show Custom Format", &custom_fmt);
+ ImGui::SameLine();
+ ImGui::Checkbox("Show Custom Ticks", &custom_ticks);
+ if (custom_ticks) {
+ ImGui::SameLine();
+ ImGui::Checkbox("Show Custom Labels", &custom_labels);
+ }
+ double pi = 3.14;
+ const char* pi_str[] = {"PI"};
+ static double yticks[] = {1,3,7,9};
+ static const char* ylabels[] = {"One","Three","Seven","Nine"};
+ static double yticks_aux[] = {0.2,0.4,0.6};
+ static const char* ylabels_aux[] = {"A","B","C","D","E","F"};
+ if (custom_fmt) {
+ ImPlot::SetNextPlotFormatX("%g ms");
+ ImPlot::SetNextPlotFormatY("%g Hz", ImPlotYAxis_1);
+ ImPlot::SetNextPlotFormatY("%g dB", ImPlotYAxis_2);
+ ImPlot::SetNextPlotFormatY("%g km", ImPlotYAxis_3);
+ }
+ if (custom_ticks) {
+ ImPlot::SetNextPlotTicksX(&pi,1,custom_labels ? pi_str : NULL, true);
+ ImPlot::SetNextPlotTicksY(yticks, 4, custom_labels ? ylabels : NULL, ImPlotYAxis_1);
+ ImPlot::SetNextPlotTicksY(yticks_aux, 3, custom_labels ? ylabels_aux : NULL, false, ImPlotYAxis_2);
+ ImPlot::SetNextPlotTicksY(0, 1, 6, custom_labels ? ylabels_aux : NULL, false, ImPlotYAxis_3);
+ }
+ ImPlot::SetNextPlotLimits(2.5,5,0,10);
+ if (ImPlot::BeginPlot("Custom Ticks", NULL, NULL, ImVec2(-1,0), ImPlotFlags_YAxis2 | ImPlotFlags_YAxis3)) {
+ // nothing to see here, just the ticks
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Custom Styles")) {
+ ImPlot::PushColormap(ImPlotColormap_Deep);
+ // normally you wouldn't change the entire style each frame
+ ImPlotStyle backup = ImPlot::GetStyle();
+ MyImPlot::StyleSeaborn();
+ ImPlot::SetNextPlotLimits(-0.5f, 9.5f, 0, 10);
+ if (ImPlot::BeginPlot("seaborn style", "x-axis", "y-axis")) {
+ unsigned int lin[10] = {8,8,9,7,8,8,8,9,7,8};
+ unsigned int bar[10] = {1,2,5,3,4,1,2,5,3,4};
+ unsigned int dot[10] = {7,6,6,7,8,5,6,5,8,7};
+ ImPlot::PlotBars("Bars", bar, 10, 0.5f);
+ ImPlot::PlotLine("Line", lin, 10);
+ ImPlot::NextColormapColor(); // skip green
+ ImPlot::PlotScatter("Scatter", dot, 10);
+ ImPlot::EndPlot();
+ }
+ ImPlot::GetStyle() = backup;
+ ImPlot::PopColormap();
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Custom Rendering")) {
+ if (ImPlot::BeginPlot("##CustomRend")) {
+ ImVec2 cntr = ImPlot::PlotToPixels(ImPlotPoint(0.5f, 0.5f));
+ ImVec2 rmin = ImPlot::PlotToPixels(ImPlotPoint(0.25f, 0.75f));
+ ImVec2 rmax = ImPlot::PlotToPixels(ImPlotPoint(0.75f, 0.25f));
+ ImPlot::PushPlotClipRect();
+ ImPlot::GetPlotDrawList()->AddCircleFilled(cntr,20,IM_COL32(255,255,0,255),20);
+ ImPlot::GetPlotDrawList()->AddRect(rmin, rmax, IM_COL32(128,0,255,255));
+ ImPlot::PopPlotClipRect();
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Custom Context Menus")) {
+ ImGui::BulletText("You can implement legend context menus to inject per-item controls and widgets.");
+ ImGui::BulletText("Right click the legend label/icon to edit custom item attributes.");
+
+ static float frequency = 0.1f;
+ static float amplitude = 0.5f;
+ static ImVec4 color = ImVec4(1,1,0,1);
+ static float alpha = 1.0f;
+ static bool line = false;
+ static float thickness = 1;
+ static bool markers = false;
+ static bool shaded = false;
+
+ static float vals[101];
+ for (int i = 0; i < 101; ++i)
+ vals[i] = amplitude * sinf(frequency * i);
+
+ ImPlot::SetNextPlotLimits(0,100,-1,1);
+ if (ImPlot::BeginPlot("Right Click the Legend")) {
+ // rendering logic
+ ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, alpha);
+ if (!line) {
+ ImPlot::SetNextFillStyle(color);
+ ImPlot::PlotBars("Right Click Me", vals, 101);
+ }
+ else {
+ if (markers) ImPlot::SetNextMarkerStyle(ImPlotMarker_Circle);
+ ImPlot::SetNextLineStyle(color, thickness);
+ ImPlot::PlotLine("Right Click Me", vals, 101);
+ if (shaded) ImPlot::PlotShaded("Right Click Me",vals,101);
+ }
+ ImPlot::PopStyleVar();
+ // custom legend context menu
+ if (ImPlot::BeginLegendPopup("Right Click Me")) {
+ ImGui::SliderFloat("Frequency",&frequency,0,1,"%0.2f");
+ ImGui::SliderFloat("Amplitude",&amplitude,0,1,"%0.2f");
+ ImGui::Separator();
+ ImGui::ColorEdit3("Color",&color.x);
+ ImGui::SliderFloat("Transparency",&alpha,0,1,"%.2f");
+ ImGui::Checkbox("Line Plot", &line);
+ if (line) {
+ ImGui::SliderFloat("Thickness", &thickness, 0, 5);
+ ImGui::Checkbox("Markers", &markers);
+ ImGui::Checkbox("Shaded",&shaded);
+ }
+ ImPlot::EndLegendPopup();
+ }
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ if (ImGui::CollapsingHeader("Custom Plotters and Tooltips")) {
+ ImGui::BulletText("You can create custom plotters or extend ImPlot using implot_internal.h.");
+ double dates[] = {1546300800,1546387200,1546473600,1546560000,1546819200,1546905600,1546992000,1547078400,1547164800,1547424000,1547510400,1547596800,1547683200,1547769600,1547942400,1548028800,1548115200,1548201600,1548288000,1548374400,1548633600,1548720000,1548806400,1548892800,1548979200,1549238400,1549324800,1549411200,1549497600,1549584000,1549843200,1549929600,1550016000,1550102400,1550188800,1550361600,1550448000,1550534400,1550620800,1550707200,1550793600,1551052800,1551139200,1551225600,1551312000,1551398400,1551657600,1551744000,1551830400,1551916800,1552003200,1552262400,1552348800,1552435200,1552521600,1552608000,1552867200,1552953600,1553040000,1553126400,1553212800,1553472000,1553558400,1553644800,1553731200,1553817600,1554076800,1554163200,1554249600,1554336000,1554422400,1554681600,1554768000,1554854400,1554940800,1555027200,1555286400,1555372800,1555459200,1555545600,1555632000,1555891200,1555977600,1556064000,1556150400,1556236800,1556496000,1556582400,1556668800,1556755200,1556841600,1557100800,1557187200,1557273600,1557360000,1557446400,1557705600,1557792000,1557878400,1557964800,1558051200,1558310400,1558396800,1558483200,1558569600,1558656000,1558828800,1558915200,1559001600,1559088000,1559174400,1559260800,1559520000,1559606400,1559692800,1559779200,1559865600,1560124800,1560211200,1560297600,1560384000,1560470400,1560729600,1560816000,1560902400,1560988800,1561075200,1561334400,1561420800,1561507200,1561593600,1561680000,1561939200,1562025600,1562112000,1562198400,1562284800,1562544000,1562630400,1562716800,1562803200,1562889600,1563148800,1563235200,1563321600,1563408000,1563494400,1563753600,1563840000,1563926400,1564012800,1564099200,1564358400,1564444800,1564531200,1564617600,1564704000,1564963200,1565049600,1565136000,1565222400,1565308800,1565568000,1565654400,1565740800,1565827200,1565913600,1566172800,1566259200,1566345600,1566432000,1566518400,1566777600,1566864000,1566950400,1567036800,1567123200,1567296000,1567382400,1567468800,1567555200,1567641600,1567728000,1567987200,1568073600,1568160000,1568246400,1568332800,1568592000,1568678400,1568764800,1568851200,1568937600,1569196800,1569283200,1569369600,1569456000,1569542400,1569801600,1569888000,1569974400,1570060800,1570147200,1570406400,1570492800,1570579200,1570665600,1570752000,1571011200,1571097600,1571184000,1571270400,1571356800,1571616000,1571702400,1571788800,1571875200,1571961600};
+ double opens[] = {1284.7,1319.9,1318.7,1328,1317.6,1321.6,1314.3,1325,1319.3,1323.1,1324.7,1321.3,1323.5,1322,1281.3,1281.95,1311.1,1315,1314,1313.1,1331.9,1334.2,1341.3,1350.6,1349.8,1346.4,1343.4,1344.9,1335.6,1337.9,1342.5,1337,1338.6,1337,1340.4,1324.65,1324.35,1349.5,1371.3,1367.9,1351.3,1357.8,1356.1,1356,1347.6,1339.1,1320.6,1311.8,1314,1312.4,1312.3,1323.5,1319.1,1327.2,1332.1,1320.3,1323.1,1328,1330.9,1338,1333,1335.3,1345.2,1341.1,1332.5,1314,1314.4,1310.7,1314,1313.1,1315,1313.7,1320,1326.5,1329.2,1314.2,1312.3,1309.5,1297.4,1293.7,1277.9,1295.8,1295.2,1290.3,1294.2,1298,1306.4,1299.8,1302.3,1297,1289.6,1302,1300.7,1303.5,1300.5,1303.2,1306,1318.7,1315,1314.5,1304.1,1294.7,1293.7,1291.2,1290.2,1300.4,1284.2,1284.25,1301.8,1295.9,1296.2,1304.4,1323.1,1340.9,1341,1348,1351.4,1351.4,1343.5,1342.3,1349,1357.6,1357.1,1354.7,1361.4,1375.2,1403.5,1414.7,1433.2,1438,1423.6,1424.4,1418,1399.5,1435.5,1421.25,1434.1,1412.4,1409.8,1412.2,1433.4,1418.4,1429,1428.8,1420.6,1441,1460.4,1441.7,1438.4,1431,1439.3,1427.4,1431.9,1439.5,1443.7,1425.6,1457.5,1451.2,1481.1,1486.7,1512.1,1515.9,1509.2,1522.3,1513,1526.6,1533.9,1523,1506.3,1518.4,1512.4,1508.8,1545.4,1537.3,1551.8,1549.4,1536.9,1535.25,1537.95,1535.2,1556,1561.4,1525.6,1516.4,1507,1493.9,1504.9,1506.5,1513.1,1506.5,1509.7,1502,1506.8,1521.5,1529.8,1539.8,1510.9,1511.8,1501.7,1478,1485.4,1505.6,1511.6,1518.6,1498.7,1510.9,1510.8,1498.3,1492,1497.7,1484.8,1494.2,1495.6,1495.6,1487.5,1491.1,1495.1,1506.4};
+ double highs[] = {1284.75,1320.6,1327,1330.8,1326.8,1321.6,1326,1328,1325.8,1327.1,1326,1326,1323.5,1322.1,1282.7,1282.95,1315.8,1316.3,1314,1333.2,1334.7,1341.7,1353.2,1354.6,1352.2,1346.4,1345.7,1344.9,1340.7,1344.2,1342.7,1342.1,1345.2,1342,1350,1324.95,1330.75,1369.6,1374.3,1368.4,1359.8,1359,1357,1356,1353.4,1340.6,1322.3,1314.1,1316.1,1312.9,1325.7,1323.5,1326.3,1336,1332.1,1330.1,1330.4,1334.7,1341.1,1344.2,1338.8,1348.4,1345.6,1342.8,1334.7,1322.3,1319.3,1314.7,1316.6,1316.4,1315,1325.4,1328.3,1332.2,1329.2,1316.9,1312.3,1309.5,1299.6,1296.9,1277.9,1299.5,1296.2,1298.4,1302.5,1308.7,1306.4,1305.9,1307,1297.2,1301.7,1305,1305.3,1310.2,1307,1308,1319.8,1321.7,1318.7,1316.2,1305.9,1295.8,1293.8,1293.7,1304.2,1302,1285.15,1286.85,1304,1302,1305.2,1323,1344.1,1345.2,1360.1,1355.3,1363.8,1353,1344.7,1353.6,1358,1373.6,1358.2,1369.6,1377.6,1408.9,1425.5,1435.9,1453.7,1438,1426,1439.1,1418,1435,1452.6,1426.65,1437.5,1421.5,1414.1,1433.3,1441.3,1431.4,1433.9,1432.4,1440.8,1462.3,1467,1443.5,1444,1442.9,1447,1437.6,1440.8,1445.7,1447.8,1458.2,1461.9,1481.8,1486.8,1522.7,1521.3,1521.1,1531.5,1546.1,1534.9,1537.7,1538.6,1523.6,1518.8,1518.4,1514.6,1540.3,1565,1554.5,1556.6,1559.8,1541.9,1542.9,1540.05,1558.9,1566.2,1561.9,1536.2,1523.8,1509.1,1506.2,1532.2,1516.6,1519.7,1515,1519.5,1512.1,1524.5,1534.4,1543.3,1543.3,1542.8,1519.5,1507.2,1493.5,1511.4,1525.8,1522.2,1518.8,1515.3,1518,1522.3,1508,1501.5,1503,1495.5,1501.1,1497.9,1498.7,1492.1,1499.4,1506.9,1520.9};
+ double lows[] = {1282.85,1315,1318.7,1309.6,1317.6,1312.9,1312.4,1319.1,1319,1321,1318.1,1321.3,1319.9,1312,1280.5,1276.15,1308,1309.9,1308.5,1312.3,1329.3,1333.1,1340.2,1347,1345.9,1338,1340.8,1335,1332,1337.9,1333,1336.8,1333.2,1329.9,1340.4,1323.85,1324.05,1349,1366.3,1351.2,1349.1,1352.4,1350.7,1344.3,1338.9,1316.3,1308.4,1306.9,1309.6,1306.7,1312.3,1315.4,1319,1327.2,1317.2,1320,1323,1328,1323,1327.8,1331.7,1335.3,1336.6,1331.8,1311.4,1310,1309.5,1308,1310.6,1302.8,1306.6,1313.7,1320,1322.8,1311,1312.1,1303.6,1293.9,1293.5,1291,1277.9,1294.1,1286,1289.1,1293.5,1296.9,1298,1299.6,1292.9,1285.1,1288.5,1296.3,1297.2,1298.4,1298.6,1302,1300.3,1312,1310.8,1301.9,1292,1291.1,1286.3,1289.2,1289.9,1297.4,1283.65,1283.25,1292.9,1295.9,1290.8,1304.2,1322.7,1336.1,1341,1343.5,1345.8,1340.3,1335.1,1341.5,1347.6,1352.8,1348.2,1353.7,1356.5,1373.3,1398,1414.7,1427,1416.4,1412.7,1420.1,1396.4,1398.8,1426.6,1412.85,1400.7,1406,1399.8,1404.4,1415.5,1417.2,1421.9,1415,1413.7,1428.1,1434,1435.7,1427.5,1429.4,1423.9,1425.6,1427.5,1434.8,1422.3,1412.1,1442.5,1448.8,1468.2,1484.3,1501.6,1506.2,1498.6,1488.9,1504.5,1518.3,1513.9,1503.3,1503,1506.5,1502.1,1503,1534.8,1535.3,1541.4,1528.6,1525.6,1535.25,1528.15,1528,1542.6,1514.3,1510.7,1505.5,1492.1,1492.9,1496.8,1493.1,1503.4,1500.9,1490.7,1496.3,1505.3,1505.3,1517.9,1507.4,1507.1,1493.3,1470.5,1465,1480.5,1501.7,1501.4,1493.3,1492.1,1505.1,1495.7,1478,1487.1,1480.8,1480.6,1487,1488.3,1484.8,1484,1490.7,1490.4,1503.1};
+ double closes[] = {1283.35,1315.3,1326.1,1317.4,1321.5,1317.4,1323.5,1319.2,1321.3,1323.3,1319.7,1325.1,1323.6,1313.8,1282.05,1279.05,1314.2,1315.2,1310.8,1329.1,1334.5,1340.2,1340.5,1350,1347.1,1344.3,1344.6,1339.7,1339.4,1343.7,1337,1338.9,1340.1,1338.7,1346.8,1324.25,1329.55,1369.6,1372.5,1352.4,1357.6,1354.2,1353.4,1346,1341,1323.8,1311.9,1309.1,1312.2,1310.7,1324.3,1315.7,1322.4,1333.8,1319.4,1327.1,1325.8,1330.9,1325.8,1331.6,1336.5,1346.7,1339.2,1334.7,1313.3,1316.5,1312.4,1313.4,1313.3,1312.2,1313.7,1319.9,1326.3,1331.9,1311.3,1313.4,1309.4,1295.2,1294.7,1294.1,1277.9,1295.8,1291.2,1297.4,1297.7,1306.8,1299.4,1303.6,1302.2,1289.9,1299.2,1301.8,1303.6,1299.5,1303.2,1305.3,1319.5,1313.6,1315.1,1303.5,1293,1294.6,1290.4,1291.4,1302.7,1301,1284.15,1284.95,1294.3,1297.9,1304.1,1322.6,1339.3,1340.1,1344.9,1354,1357.4,1340.7,1342.7,1348.2,1355.1,1355.9,1354.2,1362.1,1360.1,1408.3,1411.2,1429.5,1430.1,1426.8,1423.4,1425.1,1400.8,1419.8,1432.9,1423.55,1412.1,1412.2,1412.8,1424.9,1419.3,1424.8,1426.1,1423.6,1435.9,1440.8,1439.4,1439.7,1434.5,1436.5,1427.5,1432.2,1433.3,1441.8,1437.8,1432.4,1457.5,1476.5,1484.2,1519.6,1509.5,1508.5,1517.2,1514.1,1527.8,1531.2,1523.6,1511.6,1515.7,1515.7,1508.5,1537.6,1537.2,1551.8,1549.1,1536.9,1529.4,1538.05,1535.15,1555.9,1560.4,1525.5,1515.5,1511.1,1499.2,1503.2,1507.4,1499.5,1511.5,1513.4,1515.8,1506.2,1515.1,1531.5,1540.2,1512.3,1515.2,1506.4,1472.9,1489,1507.9,1513.8,1512.9,1504.4,1503.9,1512.8,1500.9,1488.7,1497.6,1483.5,1494,1498.3,1494.1,1488.1,1487.5,1495.7,1504.7,1505.3};
+ static bool tooltip = true;
+ ImGui::Checkbox("Show Tooltip", &tooltip);
+ ImGui::SameLine();
+ static ImVec4 bullCol = ImVec4(0.000f, 1.000f, 0.441f, 1.000f);
+ static ImVec4 bearCol = ImVec4(0.853f, 0.050f, 0.310f, 1.000f);
+ ImGui::SameLine(); ImGui::ColorEdit4("##Bull", &bullCol.x, ImGuiColorEditFlags_NoInputs);
+ ImGui::SameLine(); ImGui::ColorEdit4("##Bear", &bearCol.x, ImGuiColorEditFlags_NoInputs);
+ ImPlot::GetStyle().UseLocalTime = false;
+ ImPlot::SetNextPlotFormatY("$%.0f");
+ ImPlot::SetNextPlotLimits(1546300800, 1571961600, 1250, 1600);
+ if (ImPlot::BeginPlot("Candlestick Chart",NULL,NULL,ImVec2(-1,0),0,ImPlotAxisFlags_Time,ImPlotAxisFlags_AutoFit|ImPlotAxisFlags_RangeFit)) {
+ MyImPlot::PlotCandlestick("GOOGL",dates, opens, closes, lows, highs, 218, tooltip, 0.25f, bullCol, bearCol);
+ ImPlot::EndPlot();
+ }
+ }
+ //-------------------------------------------------------------------------
+ ImGui::End();
+}
+
+} // namespace ImPlot
+
+namespace MyImPlot {
+
+ImPlotPoint SineWave(void* data , int idx) {
+ WaveData* wd = (WaveData*)data;
+ double x = idx * wd->X;
+ return ImPlotPoint(x, wd->Offset + wd->Amp * sin(2 * 3.14 * wd->Freq * x));
+}
+
+ImPlotPoint SawWave(void* data, int idx) {
+ WaveData* wd = (WaveData*)data;
+ double x = idx * wd->X;
+ return ImPlotPoint(x, wd->Offset + wd->Amp * (-2 / 3.14 * atan(cos(3.14 * wd->Freq * x) / sin(3.14 * wd->Freq * x))));
+}
+
+ImPlotPoint Spiral(void*, int idx) {
+ float r = 0.9f; // outer radius
+ float a = 0; // inner radius
+ float b = 0.05f; // increment per rev
+ float n = (r - a) / b; // number of revolutions
+ double th = 2 * n * 3.14; // angle
+ float Th = float(th * idx / (1000 - 1));
+ return ImPlotPoint(0.5f+(a + b*Th / (2.0f * (float) 3.14))*cos(Th),
+ 0.5f + (a + b*Th / (2.0f * (float)3.14))*sin(Th));
+}
+
+// Example for Tables section. Generates a quick and simple shaded line plot. See implementation at bottom.
+void Sparkline(const char* id, const float* values, int count, float min_v, float max_v, int offset, const ImVec4& col, const ImVec2& size) {
+ ImPlot::PushStyleVar(ImPlotStyleVar_PlotPadding, ImVec2(0,0));
+ ImPlot::SetNextPlotLimits(0, count - 1, min_v, max_v, ImGuiCond_Always);
+ if (ImPlot::BeginPlot(id,0,0,size,ImPlotFlags_CanvasOnly|ImPlotFlags_NoChild,ImPlotAxisFlags_NoDecorations,ImPlotAxisFlags_NoDecorations)) {
+ ImPlot::PushStyleColor(ImPlotCol_Line, col);
+ ImPlot::PlotLine(id, values, count, 1, 0, offset);
+ ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, 0.25f);
+ ImPlot::PlotShaded(id, values, count, 0, 1, 0, offset);
+ ImPlot::PopStyleVar();
+ ImPlot::PopStyleColor();
+ ImPlot::EndPlot();
+ }
+ ImPlot::PopStyleVar();
+}
+
+void StyleSeaborn() {
+
+ ImPlotStyle& style = ImPlot::GetStyle();
+
+ ImVec4* colors = style.Colors;
+ colors[ImPlotCol_Line] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_Fill] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_MarkerOutline] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_MarkerFill] = IMPLOT_AUTO_COL;
+ colors[ImPlotCol_ErrorBar] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_FrameBg] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_PlotBg] = ImVec4(0.92f, 0.92f, 0.95f, 1.00f);
+ colors[ImPlotCol_PlotBorder] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
+ colors[ImPlotCol_LegendBg] = ImVec4(0.92f, 0.92f, 0.95f, 1.00f);
+ colors[ImPlotCol_LegendBorder] = ImVec4(0.80f, 0.81f, 0.85f, 1.00f);
+ colors[ImPlotCol_LegendText] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_TitleText] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_InlayText] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_XAxis] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_XAxisGrid] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_YAxis] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_YAxisGrid] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_YAxis2] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_YAxisGrid2] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_YAxis3] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+ colors[ImPlotCol_YAxisGrid3] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+ colors[ImPlotCol_Selection] = ImVec4(1.00f, 0.65f, 0.00f, 1.00f);
+ colors[ImPlotCol_Query] = ImVec4(0.23f, 0.10f, 0.64f, 1.00f);
+ colors[ImPlotCol_Crosshairs] = ImVec4(0.23f, 0.10f, 0.64f, 0.50f);
+
+ style.LineWeight = 1.5;
+ style.Marker = ImPlotMarker_None;
+ style.MarkerSize = 4;
+ style.MarkerWeight = 1;
+ style.FillAlpha = 1.0f;
+ style.ErrorBarSize = 5;
+ style.ErrorBarWeight = 1.5f;
+ style.DigitalBitHeight = 8;
+ style.DigitalBitGap = 4;
+ style.PlotBorderSize = 0;
+ style.MinorAlpha = 1.0f;
+ style.MajorTickLen = ImVec2(0,0);
+ style.MinorTickLen = ImVec2(0,0);
+ style.MajorTickSize = ImVec2(0,0);
+ style.MinorTickSize = ImVec2(0,0);
+ style.MajorGridSize = ImVec2(1.2f,1.2f);
+ style.MinorGridSize = ImVec2(1.2f,1.2f);
+ style.PlotPadding = ImVec2(12,12);
+ style.LabelPadding = ImVec2(5,5);
+ style.LegendPadding = ImVec2(5,5);
+ style.MousePosPadding = ImVec2(5,5);
+ style.PlotMinSize = ImVec2(300,225);
+}
+
+} // namespaece MyImPlot
+
+// WARNING:
+//
+// You can use "implot_internal.h" to build custom plotting fuctions or extend ImPlot.
+// However, note that forward compatibility of this file is not guaranteed and the
+// internal API is subject to change. At some point we hope to bring more of this
+// into the public API and expose the necessary building blocks to fully support
+// custom plotters. For now, proceed at your own risk!
+
+#include "implot_internal.h"
+
+namespace MyImPlot {
+
+template <typename T>
+int BinarySearch(const T* arr, int l, int r, T x) {
+ if (r >= l) {
+ int mid = l + (r - l) / 2;
+ if (arr[mid] == x)
+ return mid;
+ if (arr[mid] > x)
+ return BinarySearch(arr, l, mid - 1, x);
+ return BinarySearch(arr, mid + 1, r, x);
+ }
+ return -1;
+}
+
+void PlotCandlestick(const char* label_id, const double* xs, const double* opens, const double* closes, const double* lows, const double* highs, int count, bool tooltip, float width_percent, ImVec4 bullCol, ImVec4 bearCol) {
+
+ // get ImGui window DrawList
+ ImDrawList* draw_list = ImPlot::GetPlotDrawList();
+ // calc real value width
+ double half_width = count > 1 ? (xs[1] - xs[0]) * width_percent : width_percent;
+
+ // custom tool
+ if (ImPlot::IsPlotHovered() && tooltip) {
+ ImPlotPoint mouse = ImPlot::GetPlotMousePos();
+ mouse.x = ImPlot::RoundTime(ImPlotTime::FromDouble(mouse.x), ImPlotTimeUnit_Day).ToDouble();
+ float tool_l = ImPlot::PlotToPixels(mouse.x - half_width * 1.5, mouse.y).x;
+ float tool_r = ImPlot::PlotToPixels(mouse.x + half_width * 1.5, mouse.y).x;
+ float tool_t = ImPlot::GetPlotPos().y;
+ float tool_b = tool_t + ImPlot::GetPlotSize().y;
+ ImPlot::PushPlotClipRect();
+ draw_list->AddRectFilled(ImVec2(tool_l, tool_t), ImVec2(tool_r, tool_b), IM_COL32(128,128,128,64));
+ ImPlot::PopPlotClipRect();
+ // find mouse location index
+ int idx = BinarySearch(xs, 0, count - 1, mouse.x);
+ // render tool tip (won't be affected by plot clip rect)
+ if (idx != -1) {
+ ImGui::BeginTooltip();
+ char buff[32];
+ ImPlot::FormatDate(ImPlotTime::FromDouble(xs[idx]),buff,32,ImPlotDateFmt_DayMoYr,ImPlot::GetStyle().UseISO8601);
+ ImGui::Text("Day: %s", buff);
+ ImGui::Text("Open: $%.2f", opens[idx]);
+ ImGui::Text("Close: $%.2f", closes[idx]);
+ ImGui::Text("Low: $%.2f", lows[idx]);
+ ImGui::Text("High: $%.2f", highs[idx]);
+ ImGui::EndTooltip();
+ }
+ }
+
+ // begin plot item
+ if (ImPlot::BeginItem(label_id)) {
+ // override legend icon color
+ ImPlot::GetCurrentItem()->Color = IM_COL32(64,64,64,255);
+ // fit data if requested
+ if (ImPlot::FitThisFrame()) {
+ for (int i = 0; i < count; ++i) {
+ ImPlot::FitPoint(ImPlotPoint(xs[i], lows[i]));
+ ImPlot::FitPoint(ImPlotPoint(xs[i], highs[i]));
+ }
+ }
+ // render data
+ for (int i = 0; i < count; ++i) {
+ ImVec2 open_pos = ImPlot::PlotToPixels(xs[i] - half_width, opens[i]);
+ ImVec2 close_pos = ImPlot::PlotToPixels(xs[i] + half_width, closes[i]);
+ ImVec2 low_pos = ImPlot::PlotToPixels(xs[i], lows[i]);
+ ImVec2 high_pos = ImPlot::PlotToPixels(xs[i], highs[i]);
+ ImU32 color = ImGui::GetColorU32(opens[i] > closes[i] ? bearCol : bullCol);
+ draw_list->AddLine(low_pos, high_pos, color);
+ draw_list->AddRectFilled(open_pos, close_pos, color);
+ }
+
+ // end plot item
+ ImPlot::EndItem();
+ }
+}
+
+} // namespace MyImplot
+
+namespace ImPlot {
+
+//-----------------------------------------------------------------------------
+// BENCHMARK
+//-----------------------------------------------------------------------------
+
+struct BenchData {
+ BenchData() {
+ float y = RandomRange(0.0f,1.0f);
+ Data = new float[1000];
+ for (int i = 0; i < 1000; ++i) {
+ Data[i] = y + RandomRange(-0.01f,0.01f);
+ }
+ Col = ImVec4(RandomRange(0.0f,1.0f),RandomRange(0.0f,1.0f),RandomRange(0.0f,1.0f),0.5f);
+ }
+ ~BenchData() { delete[] Data; }
+ float* Data;
+ ImVec4 Col;
+};
+
+enum BenchMode {
+ Line = 0,
+ Shaded = 1,
+ Scatter = 2,
+ Bars = 3
+};
+
+struct BenchRecord {
+ int Mode;
+ bool AA;
+ ImVector<ImPlotPoint> Data;
+};
+
+void ShowBenchmarkTool() {
+ static const int max_items = 500;
+ static BenchData items[max_items];
+ static bool running = false;
+ static int frames = 60;
+ static int L = 0;
+ static int F = 0;
+ static double t1, t2;
+ static int mode = BenchMode::Line;
+ const char* names[] = {"Line","Shaded","Scatter","Bars"};
+
+ static ImVector<BenchRecord> records;
+
+ if (running) {
+ F++;
+ if (F == frames) {
+ t2 = ImGui::GetTime();
+ records.back().Data.push_back(ImPlotPoint(L, frames / (t2 - t1)));
+ L += 5;
+ F = 0;
+ t1 = ImGui::GetTime();
+ }
+ if (L > max_items) {
+ running = false;
+ L = max_items;
+ }
+ }
+
+ ImGui::Text("ImDrawIdx: %d-bit", (int)(sizeof(ImDrawIdx) * 8));
+ ImGui::Text("ImGuiBackendFlags_RendererHasVtxOffset: %s", (ImGui::GetIO().BackendFlags & ImGuiBackendFlags_RendererHasVtxOffset) ? "True" : "False");
+ ImGui::Text("%.2f FPS", ImGui::GetIO().Framerate);
+
+ ImGui::Separator();
+
+ bool was_running = running;
+ if (was_running) {
+ ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
+ ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.25f);
+ }
+ if (ImGui::Button("Benchmark")) {
+ running = true;
+ L = F = 0;
+ records.push_back(BenchRecord());
+ records.back().Data.reserve(max_items+1);
+ records.back().Mode = mode;
+ records.back().AA = ImPlot::GetStyle().AntiAliasedLines;
+ t1 = ImGui::GetTime();
+ }
+ ImGui::SameLine();
+ ImGui::SetNextItemWidth(200);
+ ImGui::Combo("##Mode",&mode,names,4);
+ ImGui::SameLine();
+
+ ImGui::Checkbox("Anti-Aliased Lines", &ImPlot::GetStyle().AntiAliasedLines);
+ if (was_running) { ImGui::PopItemFlag(); ImGui::PopStyleVar(); }
+
+ ImGui::ProgressBar((float)L / (float)(max_items - 1));
+
+ ImPlot::SetNextPlotLimits(0,1000,0,1,ImGuiCond_Always);
+ if (ImPlot::BeginPlot("##Bench",NULL,NULL,ImVec2(-1,0),ImPlotFlags_NoChild | ImPlotFlags_CanvasOnly,ImPlotAxisFlags_NoDecorations,ImPlotAxisFlags_NoDecorations)) {
+ if (running) {
+ if (mode == BenchMode::Line) {
+ for (int i = 0; i < L; ++i) {
+ ImGui::PushID(i);
+ ImPlot::SetNextLineStyle(items[i].Col);
+ ImPlot::PlotLine("##item", items[i].Data, 1000);
+ ImGui::PopID();
+ }
+ }
+ else if (mode == BenchMode::Shaded) {
+ for (int i = 0; i < L; ++i) {
+ ImGui::PushID(i);
+ ImPlot::SetNextFillStyle(items[i].Col,0.5f);
+ ImPlot::PlotShaded("##item", items[i].Data, 1000);
+ ImGui::PopID();
+ }
+ }
+ else if (mode == BenchMode::Scatter) {
+ for (int i = 0; i < L; ++i) {
+ ImGui::PushID(i);
+ ImPlot::SetNextLineStyle(items[i].Col);
+ ImPlot::PlotScatter("##item", items[i].Data, 1000);
+ ImGui::PopID();
+ }
+ }
+ else if (mode == BenchMode::Bars) {
+ for (int i = 0; i < L; ++i) {
+ ImGui::PushID(i);
+ ImPlot::SetNextFillStyle(items[i].Col,0.5f);
+ ImPlot::PlotBars("##item", items[i].Data, 1000);
+ ImGui::PopID();
+ }
+ }
+ }
+ ImPlot::EndPlot();
+ }
+ ImPlot::SetNextPlotLimits(0,500,0,500,ImGuiCond_Always);
+ static char buffer[64];
+ if (ImPlot::BeginPlot("##Stats", "Items (1,000 pts each)", "Framerate (Hz)", ImVec2(-1,0), ImPlotFlags_NoChild)) {
+ for (int run = 0; run < records.size(); ++run) {
+ if (records[run].Data.Size > 1) {
+ sprintf(buffer, "B%d-%s%s", run + 1, names[records[run].Mode], records[run].AA ? "-AA" : "");
+ ImVector<ImPlotPoint>& d = records[run].Data;
+ ImPlot::PlotLine(buffer, &d[0].x, &d[0].y, d.Size, 0, 2*sizeof(double));
+ }
+ }
+ ImPlot::EndPlot();
+ }
+}
+
+}
diff --git a/3rdparty/implot/implot_internal.h b/3rdparty/implot/implot_internal.h
new file mode 100644
index 0000000..3c0d1d5
--- /dev/null
+++ b/3rdparty/implot/implot_internal.h
@@ -0,0 +1,1240 @@
+// MIT License
+
+// Copyright (c) 2021 Evan Pezent
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// ImPlot v0.10 WIP
+
+// You may use this file to debug, understand or extend ImPlot features but we
+// don't provide any guarantee of forward compatibility!
+
+//-----------------------------------------------------------------------------
+// [SECTION] Header Mess
+//-----------------------------------------------------------------------------
+
+#pragma once
+
+#ifndef IMGUI_DEFINE_MATH_OPERATORS
+#define IMGUI_DEFINE_MATH_OPERATORS
+#endif
+
+#include <time.h>
+#include "imgui_internal.h"
+
+#ifndef IMPLOT_VERSION
+#error Must include implot.h before implot_internal.h
+#endif
+
+//-----------------------------------------------------------------------------
+// [SECTION] Constants
+//-----------------------------------------------------------------------------
+
+// Constants can be changed unless stated otherwise. We may move some of these
+// to ImPlotStyleVar_ over time.
+
+// The maximum number of supported y-axes (DO NOT CHANGE THIS)
+#define IMPLOT_Y_AXES 3
+// Zoom rate for scroll (e.g. 0.1f = 10% plot range every scroll click)
+#define IMPLOT_ZOOM_RATE 0.1f
+// Mimimum allowable timestamp value 01/01/1970 @ 12:00am (UTC) (DO NOT DECREASE THIS)
+#define IMPLOT_MIN_TIME 0
+// Maximum allowable timestamp value 01/01/3000 @ 12:00am (UTC) (DO NOT INCREASE THIS)
+#define IMPLOT_MAX_TIME 32503680000
+// Default label format for axis labels
+#define IMPLOT_LABEL_FMT "%g"
+
+//-----------------------------------------------------------------------------
+// [SECTION] Macros
+//-----------------------------------------------------------------------------
+
+// Split ImU32 color into RGB components [0 255]
+#define IM_COL32_SPLIT_RGB(col,r,g,b) \
+ ImU32 r = ((col >> IM_COL32_R_SHIFT) & 0xFF); \
+ ImU32 g = ((col >> IM_COL32_G_SHIFT) & 0xFF); \
+ ImU32 b = ((col >> IM_COL32_B_SHIFT) & 0xFF);
+
+//-----------------------------------------------------------------------------
+// [SECTION] Forward Declarations
+//-----------------------------------------------------------------------------
+
+struct ImPlotTick;
+struct ImPlotAxis;
+struct ImPlotAxisColor;
+struct ImPlotItem;
+struct ImPlotLegendData;
+struct ImPlotPlot;
+struct ImPlotNextPlotData;
+
+//-----------------------------------------------------------------------------
+// [SECTION] Context Pointer
+//-----------------------------------------------------------------------------
+
+extern IMPLOT_API ImPlotContext* GImPlot; // Current implicit context pointer
+
+//-----------------------------------------------------------------------------
+// [SECTION] Generic Helpers
+//-----------------------------------------------------------------------------
+
+// Computes the common (base-10) logarithm
+static inline float ImLog10(float x) { return log10f(x); }
+static inline double ImLog10(double x) { return log10(x); }
+// Returns true if a flag is set
+template <typename TSet, typename TFlag>
+static inline bool ImHasFlag(TSet set, TFlag flag) { return (set & flag) == flag; }
+// Flips a flag in a flagset
+template <typename TSet, typename TFlag>
+static inline void ImFlipFlag(TSet& set, TFlag flag) { ImHasFlag(set, flag) ? set &= ~flag : set |= flag; }
+// Linearly remaps x from [x0 x1] to [y0 y1].
+template <typename T>
+static inline T ImRemap(T x, T x0, T x1, T y0, T y1) { return y0 + (x - x0) * (y1 - y0) / (x1 - x0); }
+// Linear rempas x from [x0 x1] to [0 1]
+template <typename T>
+static inline T ImRemap01(T x, T x0, T x1) { return (x - x0) / (x1 - x0); }
+// Returns always positive modulo (assumes r != 0)
+static inline int ImPosMod(int l, int r) { return (l % r + r) % r; }
+// Returns true if val is NAN or INFINITY
+static inline bool ImNanOrInf(double val) { return val == HUGE_VAL || val == -HUGE_VAL || isnan(val); }
+// Turns NANs to 0s
+static inline double ImConstrainNan(double val) { return isnan(val) ? 0 : val; }
+// Turns infinity to floating point maximums
+static inline double ImConstrainInf(double val) { return val == HUGE_VAL ? DBL_MAX : val == -HUGE_VAL ? - DBL_MAX : val; }
+// Turns numbers less than or equal to 0 to 0.001 (sort of arbitrary, is there a better way?)
+static inline double ImConstrainLog(double val) { return val <= 0 ? 0.001f : val; }
+// Turns numbers less than 0 to zero
+static inline double ImConstrainTime(double val) { return val < IMPLOT_MIN_TIME ? IMPLOT_MIN_TIME : (val > IMPLOT_MAX_TIME ? IMPLOT_MAX_TIME : val); }
+// True if two numbers are approximately equal using units in the last place.
+static inline bool ImAlmostEqual(double v1, double v2, int ulp = 2) { return ImAbs(v1-v2) < DBL_EPSILON * ImAbs(v1+v2) * ulp || ImAbs(v1-v2) < DBL_MIN; }
+// Finds min value in an unsorted array
+template <typename T>
+static inline T ImMinArray(const T* values, int count) { T m = values[0]; for (int i = 1; i < count; ++i) { if (values[i] < m) { m = values[i]; } } return m; }
+// Finds the max value in an unsorted array
+template <typename T>
+static inline T ImMaxArray(const T* values, int count) { T m = values[0]; for (int i = 1; i < count; ++i) { if (values[i] > m) { m = values[i]; } } return m; }
+// Finds the min and max value in an unsorted array
+template <typename T>
+static inline void ImMinMaxArray(const T* values, int count, T* min_out, T* max_out) {
+ T Min = values[0]; T Max = values[0];
+ for (int i = 1; i < count; ++i) {
+ if (values[i] < Min) { Min = values[i]; }
+ if (values[i] > Max) { Max = values[i]; }
+ }
+ *min_out = Min; *max_out = Max;
+}
+// Finds the mean of an array
+template <typename T>
+static inline double ImMean(const T* values, int count) {
+ double den = 1.0 / count;
+ double mu = 0;
+ for (int i = 0; i < count; ++i)
+ mu += values[i] * den;
+ return mu;
+}
+// Finds the sample standard deviation of an array
+template <typename T>
+static inline double ImStdDev(const T* values, int count) {
+ double den = 1.0 / (count - 1.0);
+ double mu = ImMean(values, count);
+ double x = 0;
+ for (int i = 0; i < count; ++i)
+ x += (values[i] - mu) * (values[i] - mu) * den;
+ return sqrt(x);
+}
+// Mix color a and b by factor s in [0 256]
+static inline ImU32 ImMixU32(ImU32 a, ImU32 b, ImU32 s) {
+#ifdef IMPLOT_MIX64
+ const ImU32 af = 256-s;
+ const ImU32 bf = s;
+ const ImU64 al = (a & 0x00ff00ff) | (((ImU64)(a & 0xff00ff00)) << 24);
+ const ImU64 bl = (b & 0x00ff00ff) | (((ImU64)(b & 0xff00ff00)) << 24);
+ const ImU64 mix = (al * af + bl * bf);
+ return ((mix >> 32) & 0xff00ff00) | ((mix & 0xff00ff00) >> 8);
+#else
+ const ImU32 af = 256-s;
+ const ImU32 bf = s;
+ const ImU32 al = (a & 0x00ff00ff);
+ const ImU32 ah = (a & 0xff00ff00) >> 8;
+ const ImU32 bl = (b & 0x00ff00ff);
+ const ImU32 bh = (b & 0xff00ff00) >> 8;
+ const ImU32 ml = (al * af + bl * bf);
+ const ImU32 mh = (ah * af + bh * bf);
+ return (mh & 0xff00ff00) | ((ml & 0xff00ff00) >> 8);
+#endif
+}
+
+// Lerp across an array of 32-bit collors given t in [0.0 1.0]
+static inline ImU32 ImLerpU32(const ImU32* colors, int size, float t) {
+ int i1 = (int)((size - 1 ) * t);
+ int i2 = i1 + 1;
+ if (i2 == size || size == 1)
+ return colors[i1];
+ float den = 1.0f / (size - 1);
+ float t1 = i1 * den;
+ float t2 = i2 * den;
+ float tr = ImRemap01(t, t1, t2);
+ return ImMixU32(colors[i1], colors[i2], (ImU32)(tr*256));
+}
+
+// Set alpha channel of 32-bit color from float in range [0.0 1.0]
+static inline ImU32 ImAlphaU32(ImU32 col, float alpha) {
+ return col & ~((ImU32)((1.0f-alpha)*255)<<IM_COL32_A_SHIFT);
+}
+
+// Character buffer writer helper (FIXME: Can't we replace this with ImGuiTextBuffer?)
+struct ImBufferWriter
+{
+ char* Buffer;
+ int Size;
+ int Pos;
+
+ ImBufferWriter(char* buffer, int size) {
+ Buffer = buffer;
+ Size = size;
+ Pos = 0;
+ }
+
+ void Write(const char* fmt, ...) {
+ va_list args;
+ va_start(args, fmt);
+ WriteV(fmt, args);
+ va_end(args);
+ }
+
+ void WriteV(const char* fmt, va_list args) {
+ const int written = ::vsnprintf(&Buffer[Pos], Size - Pos - 1, fmt, args);
+ if (written > 0)
+ Pos += ImMin(written, Size-Pos-1);
+ }
+};
+
+// Fixed size point array
+template <int N>
+struct ImPlotPointArray {
+ inline ImPlotPoint& operator[](int i) { return Data[i]; }
+ inline const ImPlotPoint& operator[](int i) const { return Data[i]; }
+ inline int Size() { return N; }
+ ImPlotPoint Data[N];
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] ImPlot Enums
+//-----------------------------------------------------------------------------
+
+typedef int ImPlotScale; // -> enum ImPlotScale_
+typedef int ImPlotTimeUnit; // -> enum ImPlotTimeUnit_
+typedef int ImPlotDateFmt; // -> enum ImPlotDateFmt_
+typedef int ImPlotTimeFmt; // -> enum ImPlotTimeFmt_
+
+// XY axes scaling combinations
+enum ImPlotScale_ {
+ ImPlotScale_LinLin, // linear x, linear y
+ ImPlotScale_LogLin, // log x, linear y
+ ImPlotScale_LinLog, // linear x, log y
+ ImPlotScale_LogLog // log x, log y
+};
+
+enum ImPlotTimeUnit_ {
+ ImPlotTimeUnit_Us, // microsecond
+ ImPlotTimeUnit_Ms, // millisecond
+ ImPlotTimeUnit_S, // second
+ ImPlotTimeUnit_Min, // minute
+ ImPlotTimeUnit_Hr, // hour
+ ImPlotTimeUnit_Day, // day
+ ImPlotTimeUnit_Mo, // month
+ ImPlotTimeUnit_Yr, // year
+ ImPlotTimeUnit_COUNT
+};
+
+enum ImPlotDateFmt_ { // default [ ISO 8601 ]
+ ImPlotDateFmt_None = 0,
+ ImPlotDateFmt_DayMo, // 10/3 [ --10-03 ]
+ ImPlotDateFmt_DayMoYr, // 10/3/91 [ 1991-10-03 ]
+ ImPlotDateFmt_MoYr, // Oct 1991 [ 1991-10 ]
+ ImPlotDateFmt_Mo, // Oct [ --10 ]
+ ImPlotDateFmt_Yr // 1991 [ 1991 ]
+};
+
+enum ImPlotTimeFmt_ { // default [ 24 Hour Clock ]
+ ImPlotTimeFmt_None = 0,
+ ImPlotTimeFmt_Us, // .428 552 [ .428 552 ]
+ ImPlotTimeFmt_SUs, // :29.428 552 [ :29.428 552 ]
+ ImPlotTimeFmt_SMs, // :29.428 [ :29.428 ]
+ ImPlotTimeFmt_S, // :29 [ :29 ]
+ ImPlotTimeFmt_HrMinSMs, // 7:21:29.428pm [ 19:21:29.428 ]
+ ImPlotTimeFmt_HrMinS, // 7:21:29pm [ 19:21:29 ]
+ ImPlotTimeFmt_HrMin, // 7:21pm [ 19:21 ]
+ ImPlotTimeFmt_Hr // 7pm [ 19:00 ]
+};
+
+// Input mapping structure, default values listed in the comments.
+struct ImPlotInputMap {
+ ImGuiMouseButton PanButton; // LMB enables panning when held
+ ImGuiKeyModFlags PanMod; // none optional modifier that must be held for panning
+ ImGuiMouseButton FitButton; // LMB fits visible data when double clicked
+ ImGuiMouseButton ContextMenuButton; // RMB opens plot context menu (if enabled) when clicked
+ ImGuiMouseButton BoxSelectButton; // RMB begins box selection when pressed and confirms selection when released
+ ImGuiKeyModFlags BoxSelectMod; // none optional modifier that must be held for box selection
+ ImGuiMouseButton BoxSelectCancelButton; // LMB cancels active box selection when pressed
+ ImGuiMouseButton QueryButton; // MMB begins query selection when pressed and end query selection when released
+ ImGuiKeyModFlags QueryMod; // none optional modifier that must be held for query selection
+ ImGuiKeyModFlags QueryToggleMod; // Ctrl when held, active box selections turn into queries
+ ImGuiKeyModFlags HorizontalMod; // Alt expands active box selection/query horizontally to plot edge when held
+ ImGuiKeyModFlags VerticalMod; // Shift expands active box selection/query vertically to plot edge when held
+ IMPLOT_API ImPlotInputMap();
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] ImPlot Structs
+//-----------------------------------------------------------------------------
+
+// Combined date/time format spec
+struct ImPlotDateTimeFmt {
+ ImPlotDateTimeFmt(ImPlotDateFmt date_fmt, ImPlotTimeFmt time_fmt, bool use_24_hr_clk = false, bool use_iso_8601 = false) {
+ Date = date_fmt;
+ Time = time_fmt;
+ UseISO8601 = use_iso_8601;
+ Use24HourClock = use_24_hr_clk;
+ }
+ ImPlotDateFmt Date;
+ ImPlotTimeFmt Time;
+ bool UseISO8601;
+ bool Use24HourClock;
+};
+
+// Two part timestamp struct.
+struct ImPlotTime {
+ time_t S; // second part
+ int Us; // microsecond part
+ ImPlotTime() { S = 0; Us = 0; }
+ ImPlotTime(time_t s, int us = 0) { S = s + us / 1000000; Us = us % 1000000; }
+ void RollOver() { S = S + Us / 1000000; Us = Us % 1000000; }
+ double ToDouble() const { return (double)S + (double)Us / 1000000.0; }
+ static ImPlotTime FromDouble(double t) { return ImPlotTime((time_t)t, (int)(t * 1000000 - floor(t) * 1000000)); }
+};
+
+static inline ImPlotTime operator+(const ImPlotTime& lhs, const ImPlotTime& rhs)
+{ return ImPlotTime(lhs.S + rhs.S, lhs.Us + rhs.Us); }
+static inline ImPlotTime operator-(const ImPlotTime& lhs, const ImPlotTime& rhs)
+{ return ImPlotTime(lhs.S - rhs.S, lhs.Us - rhs.Us); }
+static inline bool operator==(const ImPlotTime& lhs, const ImPlotTime& rhs)
+{ return lhs.S == rhs.S && lhs.Us == rhs.Us; }
+static inline bool operator<(const ImPlotTime& lhs, const ImPlotTime& rhs)
+{ return lhs.S == rhs.S ? lhs.Us < rhs.Us : lhs.S < rhs.S; }
+static inline bool operator>(const ImPlotTime& lhs, const ImPlotTime& rhs)
+{ return rhs < lhs; }
+static inline bool operator<=(const ImPlotTime& lhs, const ImPlotTime& rhs)
+{ return lhs < rhs || lhs == rhs; }
+static inline bool operator>=(const ImPlotTime& lhs, const ImPlotTime& rhs)
+{ return lhs > rhs || lhs == rhs; }
+
+// Colormap data storage
+struct ImPlotColormapData {
+ ImVector<ImU32> Keys;
+ ImVector<int> KeyCounts;
+ ImVector<int> KeyOffsets;
+ ImVector<ImU32> Tables;
+ ImVector<int> TableSizes;
+ ImVector<int> TableOffsets;
+ ImGuiTextBuffer Text;
+ ImVector<int> TextOffsets;
+ ImVector<bool> Quals;
+ ImGuiStorage Map;
+ int Count;
+
+ ImPlotColormapData() { Count = 0; }
+
+ int Append(const char* name, const ImU32* keys, int count, bool qual) {
+ if (GetIndex(name) != -1)
+ return -1;
+ KeyOffsets.push_back(Keys.size());
+ KeyCounts.push_back(count);
+ Keys.reserve(Keys.size()+count);
+ for (int i = 0; i < count; ++i)
+ Keys.push_back(keys[i]);
+ TextOffsets.push_back(Text.size());
+ Text.append(name, name + strlen(name) + 1);
+ Quals.push_back(qual);
+ ImGuiID id = ImHashStr(name);
+ int idx = Count++;
+ Map.SetInt(id,idx);
+ _AppendTable(idx);
+ return idx;
+ }
+
+ void _AppendTable(ImPlotColormap cmap) {
+ int key_count = GetKeyCount(cmap);
+ const ImU32* keys = GetKeys(cmap);
+ int off = Tables.size();
+ TableOffsets.push_back(off);
+ if (IsQual(cmap)) {
+ Tables.reserve(key_count);
+ for (int i = 0; i < key_count; ++i)
+ Tables.push_back(keys[i]);
+ TableSizes.push_back(key_count);
+ }
+ else {
+ int max_size = 255 * (key_count-1) + 1;
+ Tables.reserve(off + max_size);
+ // ImU32 last = keys[0];
+ // Tables.push_back(last);
+ // int n = 1;
+ for (int i = 0; i < key_count-1; ++i) {
+ for (int s = 0; s < 255; ++s) {
+ ImU32 a = keys[i];
+ ImU32 b = keys[i+1];
+ ImU32 c = ImMixU32(a,b,s);
+ // if (c != last) {
+ Tables.push_back(c);
+ // last = c;
+ // n++;
+ // }
+ }
+ }
+ ImU32 c = keys[key_count-1];
+ // if (c != last) {
+ Tables.push_back(c);
+ // n++;
+ // }
+ // TableSizes.push_back(n);
+ TableSizes.push_back(max_size);
+ }
+ }
+
+ void RebuildTables() {
+ Tables.resize(0);
+ TableSizes.resize(0);
+ TableOffsets.resize(0);
+ for (int i = 0; i < Count; ++i)
+ _AppendTable(i);
+ }
+
+ inline bool IsQual(ImPlotColormap cmap) const { return Quals[cmap]; }
+ inline const char* GetName(ImPlotColormap cmap) const { return cmap < Count ? Text.Buf.Data + TextOffsets[cmap] : NULL; }
+ inline ImPlotColormap GetIndex(const char* name) const { ImGuiID key = ImHashStr(name); return Map.GetInt(key,-1); }
+
+ inline const ImU32* GetKeys(ImPlotColormap cmap) const { return &Keys[KeyOffsets[cmap]]; }
+ inline int GetKeyCount(ImPlotColormap cmap) const { return KeyCounts[cmap]; }
+ inline ImU32 GetKeyColor(ImPlotColormap cmap, int idx) const { return Keys[KeyOffsets[cmap]+idx]; }
+ inline void SetKeyColor(ImPlotColormap cmap, int idx, ImU32 value) { Keys[KeyOffsets[cmap]+idx] = value; RebuildTables(); }
+
+ inline const ImU32* GetTable(ImPlotColormap cmap) const { return &Tables[TableOffsets[cmap]]; }
+ inline int GetTableSize(ImPlotColormap cmap) const { return TableSizes[cmap]; }
+ inline ImU32 GetTableColor(ImPlotColormap cmap, int idx) const { return Tables[TableOffsets[cmap]+idx]; }
+
+ inline ImU32 LerpTable(ImPlotColormap cmap, float t) const {
+ int off = TableOffsets[cmap];
+ int siz = TableSizes[cmap];
+ int idx = Quals[cmap] ? ImClamp((int)(siz*t),0,siz-1) : (int)((siz - 1) * t + 0.5f);
+ return Tables[off + idx];
+ }
+
+};
+
+// ImPlotPoint with positive/negative error values
+struct ImPlotPointError {
+ double X, Y, Neg, Pos;
+ ImPlotPointError(double x, double y, double neg, double pos) {
+ X = x; Y = y; Neg = neg; Pos = pos;
+ }
+};
+
+// Interior plot label/annotation
+struct ImPlotAnnotation {
+ ImVec2 Pos;
+ ImVec2 Offset;
+ ImU32 ColorBg;
+ ImU32 ColorFg;
+ int TextOffset;
+ bool Clamp;
+};
+
+// Collection of plot labels
+struct ImPlotAnnotationCollection {
+
+ ImVector<ImPlotAnnotation> Annotations;
+ ImGuiTextBuffer TextBuffer;
+ int Size;
+
+ ImPlotAnnotationCollection() { Reset(); }
+
+ void AppendV(const ImVec2& pos, const ImVec2& off, ImU32 bg, ImU32 fg, bool clamp, const char* fmt, va_list args) IM_FMTLIST(7) {
+ ImPlotAnnotation an;
+ an.Pos = pos; an.Offset = off;
+ an.ColorBg = bg; an.ColorFg = fg;
+ an.TextOffset = TextBuffer.size();
+ an.Clamp = clamp;
+ Annotations.push_back(an);
+ TextBuffer.appendfv(fmt, args);
+ const char nul[] = "";
+ TextBuffer.append(nul,nul+1);
+ Size++;
+ }
+
+ void Append(const ImVec2& pos, const ImVec2& off, ImU32 bg, ImU32 fg, bool clamp, const char* fmt, ...) IM_FMTARGS(7) {
+ va_list args;
+ va_start(args, fmt);
+ AppendV(pos, off, bg, fg, clamp, fmt, args);
+ va_end(args);
+ }
+
+ const char* GetText(int idx) {
+ return TextBuffer.Buf.Data + Annotations[idx].TextOffset;
+ }
+
+ void Reset() {
+ Annotations.shrink(0);
+ TextBuffer.Buf.shrink(0);
+ Size = 0;
+ }
+};
+
+// Tick mark info
+struct ImPlotTick
+{
+ double PlotPos;
+ float PixelPos;
+ ImVec2 LabelSize;
+ int TextOffset;
+ bool Major;
+ bool ShowLabel;
+ int Level;
+
+ ImPlotTick(double value, bool major, bool show_label) {
+ PlotPos = value;
+ Major = major;
+ ShowLabel = show_label;
+ TextOffset = -1;
+ Level = 0;
+ }
+};
+
+// Collection of ticks
+struct ImPlotTickCollection {
+ ImVector<ImPlotTick> Ticks;
+ ImGuiTextBuffer TextBuffer;
+ float TotalWidthMax;
+ float TotalWidth;
+ float TotalHeight;
+ float MaxWidth;
+ float MaxHeight;
+ int Size;
+
+ ImPlotTickCollection() { Reset(); }
+
+ const ImPlotTick& Append(const ImPlotTick& tick) {
+ if (tick.ShowLabel) {
+ TotalWidth += tick.ShowLabel ? tick.LabelSize.x : 0;
+ TotalHeight += tick.ShowLabel ? tick.LabelSize.y : 0;
+ MaxWidth = tick.LabelSize.x > MaxWidth ? tick.LabelSize.x : MaxWidth;
+ MaxHeight = tick.LabelSize.y > MaxHeight ? tick.LabelSize.y : MaxHeight;
+ }
+ Ticks.push_back(tick);
+ Size++;
+ return Ticks.back();
+ }
+
+ const ImPlotTick& Append(double value, bool major, bool show_label, const char* fmt) {
+ ImPlotTick tick(value, major, show_label);
+ if (show_label && fmt != NULL) {
+ char temp[32];
+ tick.TextOffset = TextBuffer.size();
+ snprintf(temp, 32, fmt, tick.PlotPos);
+ TextBuffer.append(temp, temp + strlen(temp) + 1);
+ tick.LabelSize = ImGui::CalcTextSize(TextBuffer.Buf.Data + tick.TextOffset);
+ }
+ return Append(tick);
+ }
+
+ const char* GetText(int idx) const {
+ return TextBuffer.Buf.Data + Ticks[idx].TextOffset;
+ }
+
+ void Reset() {
+ Ticks.shrink(0);
+ TextBuffer.Buf.shrink(0);
+ TotalWidth = TotalHeight = MaxWidth = MaxHeight = 0;
+ Size = 0;
+ }
+};
+
+// Axis state information that must persist after EndPlot
+struct ImPlotAxis
+{
+ ImPlotAxisFlags Flags;
+ ImPlotAxisFlags PreviousFlags;
+ ImPlotRange Range;
+ float Pixels;
+ ImPlotOrientation Orientation;
+ bool Dragging;
+ bool ExtHovered;
+ bool AllHovered;
+ bool Present;
+ bool HasRange;
+ double* LinkedMin;
+ double* LinkedMax;
+ ImPlotTime PickerTimeMin, PickerTimeMax;
+ int PickerLevel;
+ ImU32 ColorMaj, ColorMin, ColorTxt;
+ ImGuiCond RangeCond;
+ ImRect HoverRect;
+
+ ImPlotAxis() {
+ Flags = PreviousFlags = ImPlotAxisFlags_None;
+ Range.Min = 0;
+ Range.Max = 1;
+ Dragging = false;
+ ExtHovered = false;
+ AllHovered = false;
+ LinkedMin = LinkedMax = NULL;
+ PickerLevel = 0;
+ ColorMaj = ColorMin = ColorTxt = 0;
+ }
+
+ bool SetMin(double _min, bool force=false) {
+ if (!force && IsLockedMin())
+ return false;
+ _min = ImConstrainNan(ImConstrainInf(_min));
+ if (ImHasFlag(Flags, ImPlotAxisFlags_LogScale))
+ _min = ImConstrainLog(_min);
+ if (ImHasFlag(Flags, ImPlotAxisFlags_Time))
+ _min = ImConstrainTime(_min);
+ if (_min >= Range.Max)
+ return false;
+ Range.Min = _min;
+ PickerTimeMin = ImPlotTime::FromDouble(Range.Min);
+ return true;
+ };
+
+ bool SetMax(double _max, bool force=false) {
+ if (!force && IsLockedMax())
+ return false;
+ _max = ImConstrainNan(ImConstrainInf(_max));
+ if (ImHasFlag(Flags, ImPlotAxisFlags_LogScale))
+ _max = ImConstrainLog(_max);
+ if (ImHasFlag(Flags, ImPlotAxisFlags_Time))
+ _max = ImConstrainTime(_max);
+ if (_max <= Range.Min)
+ return false;
+ Range.Max = _max;
+ PickerTimeMax = ImPlotTime::FromDouble(Range.Max);
+ return true;
+ };
+
+ void SetRange(double _min, double _max) {
+ Range.Min = _min;
+ Range.Max = _max;
+ Constrain();
+ PickerTimeMin = ImPlotTime::FromDouble(Range.Min);
+ PickerTimeMax = ImPlotTime::FromDouble(Range.Max);
+ }
+
+ void SetRange(const ImPlotRange& range) {
+ SetRange(range.Min, range.Max);
+ }
+
+ void SetAspect(double unit_per_pix) {
+ double new_size = unit_per_pix * Pixels;
+ double delta = (new_size - Range.Size()) * 0.5f;
+ if (IsLocked())
+ return;
+ else if (IsLockedMin() && !IsLockedMax())
+ SetRange(Range.Min, Range.Max + 2*delta);
+ else if (!IsLockedMin() && IsLockedMax())
+ SetRange(Range.Min - 2*delta, Range.Max);
+ else
+ SetRange(Range.Min - delta, Range.Max + delta);
+ }
+
+ double GetAspect() const { return Range.Size() / Pixels; }
+
+ void Constrain() {
+ Range.Min = ImConstrainNan(ImConstrainInf(Range.Min));
+ Range.Max = ImConstrainNan(ImConstrainInf(Range.Max));
+ if (ImHasFlag(Flags, ImPlotAxisFlags_LogScale)) {
+ Range.Min = ImConstrainLog(Range.Min);
+ Range.Max = ImConstrainLog(Range.Max);
+ }
+ if (ImHasFlag(Flags, ImPlotAxisFlags_Time)) {
+ Range.Min = ImConstrainTime(Range.Min);
+ Range.Max = ImConstrainTime(Range.Max);
+ }
+ if (Range.Max <= Range.Min)
+ Range.Max = Range.Min + DBL_EPSILON;
+ }
+
+ inline bool IsLabeled() const { return !ImHasFlag(Flags, ImPlotAxisFlags_NoTickLabels); }
+ inline bool IsInverted() const { return ImHasFlag(Flags, ImPlotAxisFlags_Invert); }
+
+ inline bool IsAutoFitting() const { return ImHasFlag(Flags, ImPlotAxisFlags_AutoFit); }
+ inline bool IsRangeLocked() const { return HasRange && RangeCond == ImGuiCond_Always; }
+
+ inline bool IsLockedMin() const { return !Present || IsRangeLocked() || ImHasFlag(Flags, ImPlotAxisFlags_LockMin); }
+ inline bool IsLockedMax() const { return !Present || IsRangeLocked() || ImHasFlag(Flags, ImPlotAxisFlags_LockMax); }
+ inline bool IsLocked() const { return IsLockedMin() && IsLockedMax(); }
+
+ inline bool IsInputLockedMin() const { return IsLockedMin() || IsAutoFitting(); }
+ inline bool IsInputLockedMax() const { return IsLockedMax() || IsAutoFitting(); }
+ inline bool IsInputLocked() const { return IsLocked() || IsAutoFitting(); }
+
+ inline bool IsTime() const { return ImHasFlag(Flags, ImPlotAxisFlags_Time); }
+ inline bool IsLog() const { return ImHasFlag(Flags, ImPlotAxisFlags_LogScale); }
+};
+
+// State information for Plot items
+struct ImPlotItem
+{
+ ImGuiID ID;
+ ImU32 Color;
+ int NameOffset;
+ bool Show;
+ bool LegendHovered;
+ bool SeenThisFrame;
+
+ ImPlotItem() {
+ ID = 0;
+ NameOffset = -1;
+ Show = true;
+ SeenThisFrame = false;
+ LegendHovered = false;
+ }
+
+ ~ImPlotItem() { ID = 0; }
+};
+
+// Holds Legend state labels and item references
+struct ImPlotLegendData
+{
+ ImVector<int> Indices;
+ ImGuiTextBuffer Labels;
+ void Reset() { Indices.shrink(0); Labels.Buf.shrink(0); }
+};
+
+// Holds Plot state information that must persist after EndPlot
+struct ImPlotPlot
+{
+ ImGuiID ID;
+ ImPlotFlags Flags;
+ ImPlotFlags PreviousFlags;
+ ImPlotAxis XAxis;
+ ImPlotAxis YAxis[IMPLOT_Y_AXES];
+ ImPlotLegendData LegendData;
+ ImPool<ImPlotItem> Items;
+ ImVec2 SelectStart;
+ ImRect SelectRect;
+ ImVec2 QueryStart;
+ ImRect QueryRect;
+ bool Initialized;
+ bool Selecting;
+ bool Selected;
+ bool ContextLocked;
+ bool Querying;
+ bool Queried;
+ bool DraggingQuery;
+ bool LegendHovered;
+ bool LegendOutside;
+ bool LegendFlipSideNextFrame;
+ bool FrameHovered;
+ bool PlotHovered;
+ int ColormapIdx;
+ int CurrentYAxis;
+ ImPlotLocation MousePosLocation;
+ ImPlotLocation LegendLocation;
+ ImPlotOrientation LegendOrientation;
+ ImRect FrameRect;
+ ImRect CanvasRect;
+ ImRect PlotRect;
+ ImRect AxesRect;
+ ImRect LegendRect;
+
+ ImPlotPlot() {
+ Flags = PreviousFlags = ImPlotFlags_None;
+ XAxis.Orientation = ImPlotOrientation_Horizontal;
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i)
+ YAxis[i].Orientation = ImPlotOrientation_Vertical;
+ SelectStart = QueryStart = ImVec2(0,0);
+ Initialized = Selecting = Selected = ContextLocked = Querying = Queried = DraggingQuery = LegendHovered = LegendOutside = LegendFlipSideNextFrame = false;
+ ColormapIdx = CurrentYAxis = 0;
+ LegendLocation = ImPlotLocation_North | ImPlotLocation_West;
+ LegendOrientation = ImPlotOrientation_Vertical;
+ MousePosLocation = ImPlotLocation_South | ImPlotLocation_East;
+ }
+
+ int GetLegendCount() const { return LegendData.Indices.size(); }
+ ImPlotItem* GetLegendItem(int i);
+ const char* GetLegendLabel(int i);
+
+ inline bool AnyYInputLocked() const { return YAxis[0].IsInputLocked() || (YAxis[1].Present ? YAxis[1].IsInputLocked() : false) || (YAxis[2].Present ? YAxis[2].IsInputLocked() : false); }
+ inline bool AllYInputLocked() const { return YAxis[0].IsInputLocked() && (YAxis[1].Present ? YAxis[1].IsInputLocked() : true ) && (YAxis[2].Present ? YAxis[2].IsInputLocked() : true ); }
+ inline bool IsInputLocked() const { return XAxis.IsInputLocked() && YAxis[0].IsInputLocked() && YAxis[1].IsInputLocked() && YAxis[2].IsInputLocked(); }
+};
+
+// Temporary data storage for upcoming plot
+struct ImPlotNextPlotData
+{
+ ImGuiCond XRangeCond;
+ ImGuiCond YRangeCond[IMPLOT_Y_AXES];
+ ImPlotRange XRange;
+ ImPlotRange YRange[IMPLOT_Y_AXES];
+ bool HasXRange;
+ bool HasYRange[IMPLOT_Y_AXES];
+ bool ShowDefaultTicksX;
+ bool ShowDefaultTicksY[IMPLOT_Y_AXES];
+ char FmtX[16];
+ char FmtY[IMPLOT_Y_AXES][16];
+ bool HasFmtX;
+ bool HasFmtY[IMPLOT_Y_AXES];
+ bool FitX;
+ bool FitY[IMPLOT_Y_AXES];
+ double* LinkedXmin;
+ double* LinkedXmax;
+ double* LinkedYmin[IMPLOT_Y_AXES];
+ double* LinkedYmax[IMPLOT_Y_AXES];
+
+ ImPlotNextPlotData() { Reset(); }
+
+ void Reset() {
+ HasXRange = false;
+ ShowDefaultTicksX = true;
+ HasFmtX = false;
+ FitX = false;
+ LinkedXmin = LinkedXmax = NULL;
+ for (int i = 0; i < IMPLOT_Y_AXES; ++i) {
+ HasYRange[i] = false;
+ ShowDefaultTicksY[i] = true;
+ HasFmtY[i] = false;
+ FitY[i] = false;
+ LinkedYmin[i] = LinkedYmax[i] = NULL;
+ }
+ }
+
+};
+
+// Temporary data storage for upcoming item
+struct ImPlotNextItemData {
+ ImVec4 Colors[5]; // ImPlotCol_Line, ImPlotCol_Fill, ImPlotCol_MarkerOutline, ImPlotCol_MarkerFill, ImPlotCol_ErrorBar
+ float LineWeight;
+ ImPlotMarker Marker;
+ float MarkerSize;
+ float MarkerWeight;
+ float FillAlpha;
+ float ErrorBarSize;
+ float ErrorBarWeight;
+ float DigitalBitHeight;
+ float DigitalBitGap;
+ bool RenderLine;
+ bool RenderFill;
+ bool RenderMarkerLine;
+ bool RenderMarkerFill;
+ bool HasHidden;
+ bool Hidden;
+ ImGuiCond HiddenCond;
+ ImPlotNextItemData() { Reset(); }
+ void Reset() {
+ for (int i = 0; i < 5; ++i)
+ Colors[i] = IMPLOT_AUTO_COL;
+ LineWeight = MarkerSize = MarkerWeight = FillAlpha = ErrorBarSize = ErrorBarWeight = DigitalBitHeight = DigitalBitGap = IMPLOT_AUTO;
+ Marker = IMPLOT_AUTO;
+ HasHidden = Hidden = false;
+ }
+};
+
+// Holds state information that must persist between calls to BeginPlot()/EndPlot()
+struct ImPlotContext {
+ // Plot States
+ ImPool<ImPlotPlot> Plots;
+ ImPlotPlot* CurrentPlot;
+ ImPlotItem* CurrentItem;
+ ImPlotItem* PreviousItem;
+
+ // Tick Marks and Labels
+ ImPlotTickCollection CTicks;
+ ImPlotTickCollection XTicks;
+ ImPlotTickCollection YTicks[IMPLOT_Y_AXES];
+ float YAxisReference[IMPLOT_Y_AXES];
+
+ // Annotation and User Labels
+ ImPlotAnnotationCollection Annotations;
+
+ // Transformations and Data Extents
+ ImPlotScale Scales[IMPLOT_Y_AXES];
+ ImRect PixelRange[IMPLOT_Y_AXES];
+ double Mx;
+ double My[IMPLOT_Y_AXES];
+ double LogDenX;
+ double LogDenY[IMPLOT_Y_AXES];
+ ImPlotRange ExtentsX;
+ ImPlotRange ExtentsY[IMPLOT_Y_AXES];
+
+ // Data Fitting Flags
+ bool FitThisFrame;
+ bool FitX;
+ bool FitY[IMPLOT_Y_AXES];
+
+ // Axis Rendering Flags
+ bool RenderX;
+ bool RenderY[IMPLOT_Y_AXES];
+
+ // Axis Locking Flags
+ bool ChildWindowMade;
+
+ // Style and Colormaps
+ ImPlotStyle Style;
+ ImVector<ImGuiColorMod> ColorModifiers;
+ ImVector<ImGuiStyleMod> StyleModifiers;
+ ImPlotColormapData ColormapData;
+ ImVector<ImPlotColormap> ColormapModifiers;
+
+ // Time
+ tm Tm;
+
+ // Temp data for general use
+ ImVector<double> Temp1, Temp2;
+
+ // Misc
+ int VisibleItemCount;
+ int DigitalPlotItemCnt;
+ int DigitalPlotOffset;
+ ImPlotNextPlotData NextPlotData;
+ ImPlotNextItemData NextItemData;
+ ImPlotInputMap InputMap;
+ ImPlotPoint MousePos[IMPLOT_Y_AXES];
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Internal API
+// No guarantee of forward compatibility here!
+//-----------------------------------------------------------------------------
+
+namespace ImPlot {
+
+//-----------------------------------------------------------------------------
+// [SECTION] Context Utils
+//-----------------------------------------------------------------------------
+
+// Initializes an ImPlotContext
+IMPLOT_API void Initialize(ImPlotContext* ctx);
+// Resets an ImPlot context for the next call to BeginPlot
+IMPLOT_API void Reset(ImPlotContext* ctx);
+
+//-----------------------------------------------------------------------------
+// [SECTION] Input Utils
+//-----------------------------------------------------------------------------
+
+// Allows changing how keyboard/mouse interaction works.
+IMPLOT_API ImPlotInputMap& GetInputMap();
+
+//-----------------------------------------------------------------------------
+// [SECTION] Plot Utils
+//-----------------------------------------------------------------------------
+
+// Gets a plot from the current ImPlotContext
+IMPLOT_API ImPlotPlot* GetPlot(const char* title);
+// Gets the current plot from the current ImPlotContext
+IMPLOT_API ImPlotPlot* GetCurrentPlot();
+// Busts the cache for every plot in the current context
+IMPLOT_API void BustPlotCache();
+
+// Shows a plot's context menu.
+IMPLOT_API void ShowPlotContextMenu(ImPlotPlot& plot);
+
+//-----------------------------------------------------------------------------
+// [SECTION] Item Utils
+//-----------------------------------------------------------------------------
+
+// Begins a new item. Returns false if the item should not be plotted. Pushes PlotClipRect.
+IMPLOT_API bool BeginItem(const char* label_id, ImPlotCol recolor_from = -1);
+// Ends an item (call only if BeginItem returns true). Pops PlotClipRect.
+IMPLOT_API void EndItem();
+
+// Register or get an existing item from the current plot.
+IMPLOT_API ImPlotItem* RegisterOrGetItem(const char* label_id, bool* just_created = NULL);
+// Get a plot item from the current plot.
+IMPLOT_API ImPlotItem* GetItem(const char* label_id);
+// Gets the current item.
+IMPLOT_API ImPlotItem* GetCurrentItem();
+// Busts the cache for every item for every plot in the current context.
+IMPLOT_API void BustItemCache();
+
+//-----------------------------------------------------------------------------
+// [SECTION] Axis Utils
+//-----------------------------------------------------------------------------
+
+// Gets the current y-axis for the current plot
+static inline int GetCurrentYAxis() { return GImPlot->CurrentPlot->CurrentYAxis; }
+// Updates axis ticks, lins, and label colors
+IMPLOT_API void UpdateAxisColors(int axis_flag, ImPlotAxis* axis);
+
+// Updates plot-to-pixel space transformation variables for the current plot.
+IMPLOT_API void UpdateTransformCache();
+// Gets the XY scale for the current plot and y-axis
+static inline ImPlotScale GetCurrentScale() { return GImPlot->Scales[GetCurrentYAxis()]; }
+
+// Returns true if the user has requested data to be fit.
+static inline bool FitThisFrame() { return GImPlot->FitThisFrame; }
+// Extend the the extents of an axis on current plot so that it encompes v
+static inline void FitPointAxis(ImPlotAxis& axis, ImPlotRange& ext, double v) {
+ if (!ImNanOrInf(v) && !(ImHasFlag(axis.Flags, ImPlotAxisFlags_LogScale) && v <= 0)) {
+ ext.Min = v < ext.Min ? v : ext.Min;
+ ext.Max = v > ext.Max ? v : ext.Max;
+ }
+}
+// Extend the the extents of an axis on current plot so that it encompes v
+static inline void FitPointMultiAxis(ImPlotAxis& axis, ImPlotAxis& alt, ImPlotRange& ext, double v, double v_alt) {
+ if (ImHasFlag(axis.Flags, ImPlotAxisFlags_RangeFit) && !alt.Range.Contains(v_alt))
+ return;
+ if (!ImNanOrInf(v) && !(ImHasFlag(axis.Flags, ImPlotAxisFlags_LogScale) && v <= 0)) {
+ ext.Min = v < ext.Min ? v : ext.Min;
+ ext.Max = v > ext.Max ? v : ext.Max;
+ }
+}
+// Extends the current plot's axes so that it encompasses a vertical line at x
+static inline void FitPointX(double x) {
+ FitPointAxis(GImPlot->CurrentPlot->XAxis, GImPlot->ExtentsX, x);
+}
+// Extends the current plot's axes so that it encompasses a horizontal line at y
+static inline void FitPointY(double y) {
+ const ImPlotYAxis y_axis = GImPlot->CurrentPlot->CurrentYAxis;
+ FitPointAxis(GImPlot->CurrentPlot->YAxis[y_axis], GImPlot->ExtentsY[y_axis], y);
+}
+// Extends the current plot's axes so that it encompasses point p
+static inline void FitPoint(const ImPlotPoint& p) {
+ const ImPlotYAxis y_axis = GImPlot->CurrentPlot->CurrentYAxis;
+ FitPointMultiAxis(GImPlot->CurrentPlot->XAxis, GImPlot->CurrentPlot->YAxis[y_axis], GImPlot->ExtentsX, p.x, p.y);
+ FitPointMultiAxis(GImPlot->CurrentPlot->YAxis[y_axis], GImPlot->CurrentPlot->XAxis, GImPlot->ExtentsY[y_axis], p.y, p.x);
+}
+
+// Returns true if two ranges overlap
+static inline bool RangesOverlap(const ImPlotRange& r1, const ImPlotRange& r2)
+{ return r1.Min <= r2.Max && r2.Min <= r1.Max; }
+
+// Updates pointers for linked axes from axis internal range.
+IMPLOT_API void PushLinkedAxis(ImPlotAxis& axis);
+// Updates axis internal range from points for linked axes.
+IMPLOT_API void PullLinkedAxis(ImPlotAxis& axis);
+
+// Shows an axis's context menu.
+IMPLOT_API void ShowAxisContextMenu(ImPlotAxis& axis, ImPlotAxis* equal_axis, bool time_allowed = false);
+
+// Get format spec for axis
+static inline const char* GetFormatX() { return GImPlot->NextPlotData.HasFmtX ? GImPlot->NextPlotData.FmtX : IMPLOT_LABEL_FMT; }
+static inline const char* GetFormatY(ImPlotYAxis y) { return GImPlot->NextPlotData.HasFmtY[y] ? GImPlot->NextPlotData.FmtY[y] : IMPLOT_LABEL_FMT; }
+
+//-----------------------------------------------------------------------------
+// [SECTION] Legend Utils
+//-----------------------------------------------------------------------------
+
+// Gets the position of an inner rect that is located inside of an outer rect according to an ImPlotLocation and padding amount.
+IMPLOT_API ImVec2 GetLocationPos(const ImRect& outer_rect, const ImVec2& inner_size, ImPlotLocation location, const ImVec2& pad = ImVec2(0,0));
+// Calculates the bounding box size of a legend
+IMPLOT_API ImVec2 CalcLegendSize(ImPlotPlot& plot, const ImVec2& pad, const ImVec2& spacing, ImPlotOrientation orientation);
+// Renders legend entries into a bounding box
+IMPLOT_API void ShowLegendEntries(ImPlotPlot& plot, const ImRect& legend_bb, bool interactable, const ImVec2& pad, const ImVec2& spacing, ImPlotOrientation orientation, ImDrawList& DrawList);
+// Shows an alternate legend for the plot identified by #title_id, outside of the plot frame (can be called before or after of Begin/EndPlot but must occur in the same ImGui window!).
+IMPLOT_API void ShowAltLegend(const char* title_id, ImPlotOrientation orientation = ImPlotOrientation_Vertical, const ImVec2 size = ImVec2(0,0), bool interactable = true);
+
+//-----------------------------------------------------------------------------
+// [SECTION] Tick Utils
+//-----------------------------------------------------------------------------
+
+// Label a tick with time formatting.
+IMPLOT_API void LabelTickTime(ImPlotTick& tick, ImGuiTextBuffer& buffer, const ImPlotTime& t, ImPlotDateTimeFmt fmt);
+
+// Populates a list of ImPlotTicks with normal spaced and formatted ticks
+IMPLOT_API void AddTicksDefault(const ImPlotRange& range, float pix, ImPlotOrientation orn, ImPlotTickCollection& ticks, const char* fmt);
+// Populates a list of ImPlotTicks with logarithmic space and formatted ticks
+IMPLOT_API void AddTicksLogarithmic(const ImPlotRange& range, float pix, ImPlotOrientation orn, ImPlotTickCollection& ticks, const char* fmt);
+// Populates a list of ImPlotTicks with time formatted ticks.
+IMPLOT_API void AddTicksTime(const ImPlotRange& range, float plot_width, ImPlotTickCollection& ticks);
+// Populates a list of ImPlotTicks with custom spaced and labeled ticks
+IMPLOT_API void AddTicksCustom(const double* values, const char* const labels[], int n, ImPlotTickCollection& ticks, const char* fmt);
+
+// Create a a string label for a an axis value
+IMPLOT_API int LabelAxisValue(const ImPlotAxis& axis, const ImPlotTickCollection& ticks, double value, char* buff, int size);
+
+//-----------------------------------------------------------------------------
+// [SECTION] Styling Utils
+//-----------------------------------------------------------------------------
+
+// Get styling data for next item (call between Begin/EndItem)
+static inline const ImPlotNextItemData& GetItemData() { return GImPlot->NextItemData; }
+
+// Returns true if a color is set to be automatically determined
+static inline bool IsColorAuto(const ImVec4& col) { return col.w == -1; }
+// Returns true if a style color is set to be automaticaly determined
+static inline bool IsColorAuto(ImPlotCol idx) { return IsColorAuto(GImPlot->Style.Colors[idx]); }
+// Returns the automatically deduced style color
+IMPLOT_API ImVec4 GetAutoColor(ImPlotCol idx);
+
+// Returns the style color whether it is automatic or custom set
+static inline ImVec4 GetStyleColorVec4(ImPlotCol idx) { return IsColorAuto(idx) ? GetAutoColor(idx) : GImPlot->Style.Colors[idx]; }
+static inline ImU32 GetStyleColorU32(ImPlotCol idx) { return ImGui::ColorConvertFloat4ToU32(GetStyleColorVec4(idx)); }
+
+// Draws vertical text. The position is the bottom left of the text rect.
+IMPLOT_API void AddTextVertical(ImDrawList *DrawList, ImVec2 pos, ImU32 col, const char* text_begin, const char* text_end = NULL);
+// Calculates the size of vertical text
+static inline ImVec2 CalcTextSizeVertical(const char *text) {
+ ImVec2 sz = ImGui::CalcTextSize(text);
+ return ImVec2(sz.y, sz.x);
+}
+// Returns white or black text given background color
+static inline ImU32 CalcTextColor(const ImVec4& bg) { return (bg.x * 0.299 + bg.y * 0.587 + bg.z * 0.114) > 0.5 ? IM_COL32_BLACK : IM_COL32_WHITE; }
+static inline ImU32 CalcTextColor(ImU32 bg) { return CalcTextColor(ImGui::ColorConvertU32ToFloat4(bg)); }
+// Lightens or darkens a color for hover
+static inline ImU32 CalcHoverColor(ImU32 col) { return ImMixU32(col, CalcTextColor(col), 32); }
+
+// Clamps a label position so that it fits a rect defined by Min/Max
+static inline ImVec2 ClampLabelPos(ImVec2 pos, const ImVec2& size, const ImVec2& Min, const ImVec2& Max) {
+ if (pos.x < Min.x) pos.x = Min.x;
+ if (pos.y < Min.y) pos.y = Min.y;
+ if ((pos.x + size.x) > Max.x) pos.x = Max.x - size.x;
+ if ((pos.y + size.y) > Max.y) pos.y = Max.y - size.y;
+ return pos;
+}
+
+// Returns a color from the Color map given an index >= 0 (modulo will be performed).
+IMPLOT_API ImU32 GetColormapColorU32(int idx, ImPlotColormap cmap);
+// Returns the next unused colormap color and advances the colormap. Can be used to skip colors if desired.
+IMPLOT_API ImU32 NextColormapColorU32();
+// Linearly interpolates a color from the current colormap given t between 0 and 1.
+IMPLOT_API ImU32 SampleColormapU32(float t, ImPlotColormap cmap);
+
+// Render a colormap bar
+IMPLOT_API void RenderColorBar(const ImU32* colors, int size, ImDrawList& DrawList, const ImRect& bounds, bool vert, bool reversed, bool continuous);
+
+//-----------------------------------------------------------------------------
+// [SECTION] Math and Misc Utils
+//-----------------------------------------------------------------------------
+
+// Rounds x to powers of 2,5 and 10 for generating axis labels (from Graphics Gems 1 Chapter 11.2)
+IMPLOT_API double NiceNum(double x, bool round);
+// Computes order of magnitude of double.
+static inline int OrderOfMagnitude(double val) { return val == 0 ? 0 : (int)(floor(log10(fabs(val)))); }
+// Returns the precision required for a order of magnitude.
+static inline int OrderToPrecision(int order) { return order > 0 ? 0 : 1 - order; }
+// Returns a floating point precision to use given a value
+static inline int Precision(double val) { return OrderToPrecision(OrderOfMagnitude(val)); }
+// Round a value to a given precision
+static inline double RoundTo(double val, int prec) { double p = pow(10,(double)prec); return floor(val*p+0.5)/p; }
+
+// Returns the intersection point of two lines A and B (assumes they are not parallel!)
+static inline ImVec2 Intersection(const ImVec2& a1, const ImVec2& a2, const ImVec2& b1, const ImVec2& b2) {
+ float v1 = (a1.x * a2.y - a1.y * a2.x); float v2 = (b1.x * b2.y - b1.y * b2.x);
+ float v3 = ((a1.x - a2.x) * (b1.y - b2.y) - (a1.y - a2.y) * (b1.x - b2.x));
+ return ImVec2((v1 * (b1.x - b2.x) - v2 * (a1.x - a2.x)) / v3, (v1 * (b1.y - b2.y) - v2 * (a1.y - a2.y)) / v3);
+}
+
+// Fills a buffer with n samples linear interpolated from vmin to vmax
+template <typename T>
+void FillRange(ImVector<T>& buffer, int n, T vmin, T vmax) {
+ buffer.resize(n);
+ T step = (vmax - vmin) / (n - 1);
+ for (int i = 0; i < n; ++i) {
+ buffer[i] = vmin + i * step;
+ }
+}
+
+// Offsets and strides a data buffer
+template <typename T>
+static inline T OffsetAndStride(const T* data, int idx, int count, int offset, int stride) {
+ idx = ImPosMod(offset + idx, count);
+ return *(const T*)(const void*)((const unsigned char*)data + (size_t)idx * stride);
+}
+
+// Calculate histogram bin counts and widths
+template <typename T>
+static inline void CalculateBins(const T* values, int count, ImPlotBin meth, const ImPlotRange& range, int& bins_out, double& width_out) {
+ switch (meth) {
+ case ImPlotBin_Sqrt:
+ bins_out = (int)ceil(sqrt(count));
+ break;
+ case ImPlotBin_Sturges:
+ bins_out = (int)ceil(1.0 + log2(count));
+ break;
+ case ImPlotBin_Rice:
+ bins_out = (int)ceil(2 * cbrt(count));
+ break;
+ case ImPlotBin_Scott:
+ width_out = 3.49 * ImStdDev(values, count) / cbrt(count);
+ bins_out = (int)round(range.Size() / width_out);
+ break;
+ }
+ width_out = range.Size() / bins_out;
+}
+
+//-----------------------------------------------------------------------------
+// Time Utils
+//-----------------------------------------------------------------------------
+
+// Returns true if year is leap year (366 days long)
+static inline bool IsLeapYear(int year) {
+ return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
+}
+// Returns the number of days in a month, accounting for Feb. leap years. #month is zero indexed.
+static inline int GetDaysInMonth(int year, int month) {
+ static const int days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+ return days[month] + (int)(month == 1 && IsLeapYear(year));
+}
+
+// Make a UNIX timestamp from a tm struct expressed in UTC time (i.e. GMT timezone).
+IMPLOT_API ImPlotTime MkGmtTime(struct tm *ptm);
+// Make a tm struct expressed in UTC time (i.e. GMT timezone) from a UNIX timestamp.
+IMPLOT_API tm* GetGmtTime(const ImPlotTime& t, tm* ptm);
+
+// Make a UNIX timestamp from a tm struct expressed in local time.
+IMPLOT_API ImPlotTime MkLocTime(struct tm *ptm);
+// Make a tm struct expressed in local time from a UNIX timestamp.
+IMPLOT_API tm* GetLocTime(const ImPlotTime& t, tm* ptm);
+
+// NB: The following functions only work if there is a current ImPlotContext because the
+// internal tm struct is owned by the context! They are aware of ImPlotStyle.UseLocalTime.
+
+// Make a timestamp from time components.
+// year[1970-3000], month[0-11], day[1-31], hour[0-23], min[0-59], sec[0-59], us[0,999999]
+IMPLOT_API ImPlotTime MakeTime(int year, int month = 0, int day = 1, int hour = 0, int min = 0, int sec = 0, int us = 0);
+// Get year component from timestamp [1970-3000]
+IMPLOT_API int GetYear(const ImPlotTime& t);
+
+// Adds or subtracts time from a timestamp. #count > 0 to add, < 0 to subtract.
+IMPLOT_API ImPlotTime AddTime(const ImPlotTime& t, ImPlotTimeUnit unit, int count);
+// Rounds a timestamp down to nearest unit.
+IMPLOT_API ImPlotTime FloorTime(const ImPlotTime& t, ImPlotTimeUnit unit);
+// Rounds a timestamp up to the nearest unit.
+IMPLOT_API ImPlotTime CeilTime(const ImPlotTime& t, ImPlotTimeUnit unit);
+// Rounds a timestamp up or down to the nearest unit.
+IMPLOT_API ImPlotTime RoundTime(const ImPlotTime& t, ImPlotTimeUnit unit);
+// Combines the date of one timestamp with the time-of-day of another timestamp.
+IMPLOT_API ImPlotTime CombineDateTime(const ImPlotTime& date_part, const ImPlotTime& time_part);
+
+// Formats the time part of timestamp t into a buffer according to #fmt
+IMPLOT_API int FormatTime(const ImPlotTime& t, char* buffer, int size, ImPlotTimeFmt fmt, bool use_24_hr_clk);
+// Formats the date part of timestamp t into a buffer according to #fmt
+IMPLOT_API int FormatDate(const ImPlotTime& t, char* buffer, int size, ImPlotDateFmt fmt, bool use_iso_8601);
+// Formats the time and/or date parts of a timestamp t into a buffer according to #fmt
+IMPLOT_API int FormatDateTime(const ImPlotTime& t, char* buffer, int size, ImPlotDateTimeFmt fmt);
+
+// Shows a date picker widget block (year/month/day).
+// #level = 0 for day, 1 for month, 2 for year. Modified by user interaction.
+// #t will be set when a day is clicked and the function will return true.
+// #t1 and #t2 are optional dates to highlight.
+IMPLOT_API bool ShowDatePicker(const char* id, int* level, ImPlotTime* t, const ImPlotTime* t1 = NULL, const ImPlotTime* t2 = NULL);
+// Shows a time picker widget block (hour/min/sec).
+// #t will be set when a new hour, minute, or sec is selected or am/pm is toggled, and the function will return true.
+IMPLOT_API bool ShowTimePicker(const char* id, ImPlotTime* t);
+
+} // namespace ImPlot
diff --git a/3rdparty/implot/implot_items.cpp b/3rdparty/implot/implot_items.cpp
new file mode 100644
index 0000000..9f94492
--- /dev/null
+++ b/3rdparty/implot/implot_items.cpp
@@ -0,0 +1,2252 @@
+// MIT License
+
+// Copyright (c) 2020 Evan Pezent
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// ImPlot v0.10 WIP
+
+#include "implot.h"
+#include "implot_internal.h"
+
+#ifdef _MSC_VER
+#define sprintf sprintf_s
+#endif
+
+#define SQRT_1_2 0.70710678118f
+#define SQRT_3_2 0.86602540378f
+
+#define IMPLOT_NORMALIZE2F_OVER_ZERO(VX, VY) \
+ { \
+ float d2 = VX * VX + VY * VY; \
+ if (d2 > 0.0f) { \
+ float inv_len = 1.0f / ImSqrt(d2); \
+ VX *= inv_len; \
+ VY *= inv_len; \
+ } \
+ }
+
+// Support for pre-1.82 version. Users on 1.82+ can use 0 (default) flags to mean "all corners" but in order to support older versions we are more explicit.
+#if (IMGUI_VERSION_NUM < 18102) && !defined(ImDrawFlags_RoundCornersAll)
+#define ImDrawFlags_RoundCornersAll ImDrawCornerFlags_All
+#endif
+
+namespace ImPlot {
+
+//-----------------------------------------------------------------------------
+// Item Utils
+//-----------------------------------------------------------------------------
+
+ImPlotItem* RegisterOrGetItem(const char* label_id, bool* just_created) {
+ ImPlotContext& gp = *GImPlot;
+ ImGuiID id = ImGui::GetID(label_id);
+ if (just_created != NULL)
+ *just_created = gp.CurrentPlot->Items.GetByKey(id) == NULL;
+ ImPlotItem* item = gp.CurrentPlot->Items.GetOrAddByKey(id);
+ if (item->SeenThisFrame)
+ return item;
+ item->SeenThisFrame = true;
+ int idx = gp.CurrentPlot->Items.GetIndex(item);
+ item->ID = id;
+ if (ImGui::FindRenderedTextEnd(label_id, NULL) != label_id) {
+ gp.CurrentPlot->LegendData.Indices.push_back(idx);
+ item->NameOffset = gp.CurrentPlot->LegendData.Labels.size();
+ gp.CurrentPlot->LegendData.Labels.append(label_id, label_id + strlen(label_id) + 1);
+ }
+ else {
+ item->Show = true;
+ }
+ if (item->Show)
+ gp.VisibleItemCount++;
+ return item;
+}
+
+ImPlotItem* GetItem(const char* label_id) {
+ ImPlotContext& gp = *GImPlot;
+ ImGuiID id = ImGui::GetID(label_id);
+ return gp.CurrentPlot->Items.GetByKey(id);
+}
+
+ImPlotItem* GetCurrentItem() {
+ ImPlotContext& gp = *GImPlot;
+ return gp.CurrentItem;
+}
+
+void SetNextLineStyle(const ImVec4& col, float weight) {
+ ImPlotContext& gp = *GImPlot;
+ gp.NextItemData.Colors[ImPlotCol_Line] = col;
+ gp.NextItemData.LineWeight = weight;
+}
+
+void SetNextFillStyle(const ImVec4& col, float alpha) {
+ ImPlotContext& gp = *GImPlot;
+ gp.NextItemData.Colors[ImPlotCol_Fill] = col;
+ gp.NextItemData.FillAlpha = alpha;
+}
+
+void SetNextMarkerStyle(ImPlotMarker marker, float size, const ImVec4& fill, float weight, const ImVec4& outline) {
+ ImPlotContext& gp = *GImPlot;
+ gp.NextItemData.Marker = marker;
+ gp.NextItemData.Colors[ImPlotCol_MarkerFill] = fill;
+ gp.NextItemData.MarkerSize = size;
+ gp.NextItemData.Colors[ImPlotCol_MarkerOutline] = outline;
+ gp.NextItemData.MarkerWeight = weight;
+}
+
+void SetNextErrorBarStyle(const ImVec4& col, float size, float weight) {
+ ImPlotContext& gp = *GImPlot;
+ gp.NextItemData.Colors[ImPlotCol_ErrorBar] = col;
+ gp.NextItemData.ErrorBarSize = size;
+ gp.NextItemData.ErrorBarWeight = weight;
+}
+
+ImVec4 GetLastItemColor() {
+ ImPlotContext& gp = *GImPlot;
+ if (gp.PreviousItem)
+ return ImGui::ColorConvertU32ToFloat4(gp.PreviousItem->Color);
+ return ImVec4();
+}
+
+void HideNextItem(bool hidden, ImGuiCond cond) {
+ ImPlotContext& gp = *GImPlot;
+ gp.NextItemData.HasHidden = true;
+ gp.NextItemData.Hidden = hidden;
+ gp.NextItemData.HiddenCond = cond;
+}
+
+void BustItemCache() {
+ ImPlotContext& gp = *GImPlot;
+ for (int p = 0; p < gp.Plots.GetSize(); ++p) {
+ ImPlotPlot& plot = *gp.Plots.GetByIndex(p);
+ plot.ColormapIdx = 0;
+ plot.Items.Clear();
+ plot.LegendData.Reset();
+ }
+}
+
+void BustColorCache(const char* plot_title_id) {
+ ImPlotContext& gp = *GImPlot;
+ if (plot_title_id == NULL) {
+ BustItemCache();
+ }
+ else {
+ ImPlotPlot* plot = gp.Plots.GetByKey(ImGui::GetCurrentWindow()->GetID(plot_title_id));
+ if (plot == NULL)
+ return;
+ plot->ColormapIdx = 0;
+ plot->Items.Clear();
+ plot->LegendData.Reset();
+ }
+}
+
+//-----------------------------------------------------------------------------
+// Begin/EndItem
+//-----------------------------------------------------------------------------
+
+// Begins a new item. Returns false if the item should not be plotted.
+bool BeginItem(const char* label_id, ImPlotCol recolor_from) {
+ ImPlotContext& gp = *GImPlot;
+ IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "PlotX() needs to be called between BeginPlot() and EndPlot()!");
+ bool just_created;
+ ImPlotItem* item = RegisterOrGetItem(label_id, &just_created);
+ // set current item
+ gp.CurrentItem = item;
+ ImPlotNextItemData& s = gp.NextItemData;
+ // set/override item color
+ if (recolor_from != -1) {
+ if (!IsColorAuto(s.Colors[recolor_from]))
+ item->Color = ImGui::ColorConvertFloat4ToU32(s.Colors[recolor_from]);
+ else if (!IsColorAuto(gp.Style.Colors[recolor_from]))
+ item->Color = ImGui::ColorConvertFloat4ToU32(gp.Style.Colors[recolor_from]);
+ else if (just_created)
+ item->Color = NextColormapColorU32();
+ }
+ else if (just_created) {
+ item->Color = NextColormapColorU32();
+ }
+ // hide/show item
+ if (gp.NextItemData.HasHidden) {
+ if (just_created || gp.NextItemData.HiddenCond == ImGuiCond_Always)
+ item->Show = !gp.NextItemData.Hidden;
+ }
+ if (!item->Show) {
+ // reset next item data
+ gp.NextItemData.Reset();
+ gp.PreviousItem = item;
+ gp.CurrentItem = NULL;
+ return false;
+ }
+ else {
+ ImVec4 item_color = ImGui::ColorConvertU32ToFloat4(item->Color);
+ // stage next item colors
+ s.Colors[ImPlotCol_Line] = IsColorAuto(s.Colors[ImPlotCol_Line]) ? ( IsColorAuto(ImPlotCol_Line) ? item_color : gp.Style.Colors[ImPlotCol_Line] ) : s.Colors[ImPlotCol_Line];
+ s.Colors[ImPlotCol_Fill] = IsColorAuto(s.Colors[ImPlotCol_Fill]) ? ( IsColorAuto(ImPlotCol_Fill) ? item_color : gp.Style.Colors[ImPlotCol_Fill] ) : s.Colors[ImPlotCol_Fill];
+ s.Colors[ImPlotCol_MarkerOutline] = IsColorAuto(s.Colors[ImPlotCol_MarkerOutline]) ? ( IsColorAuto(ImPlotCol_MarkerOutline) ? s.Colors[ImPlotCol_Line] : gp.Style.Colors[ImPlotCol_MarkerOutline] ) : s.Colors[ImPlotCol_MarkerOutline];
+ s.Colors[ImPlotCol_MarkerFill] = IsColorAuto(s.Colors[ImPlotCol_MarkerFill]) ? ( IsColorAuto(ImPlotCol_MarkerFill) ? s.Colors[ImPlotCol_Line] : gp.Style.Colors[ImPlotCol_MarkerFill] ) : s.Colors[ImPlotCol_MarkerFill];
+ s.Colors[ImPlotCol_ErrorBar] = IsColorAuto(s.Colors[ImPlotCol_ErrorBar]) ? ( GetStyleColorVec4(ImPlotCol_ErrorBar) ) : s.Colors[ImPlotCol_ErrorBar];
+ // stage next item style vars
+ s.LineWeight = s.LineWeight < 0 ? gp.Style.LineWeight : s.LineWeight;
+ s.Marker = s.Marker < 0 ? gp.Style.Marker : s.Marker;
+ s.MarkerSize = s.MarkerSize < 0 ? gp.Style.MarkerSize : s.MarkerSize;
+ s.MarkerWeight = s.MarkerWeight < 0 ? gp.Style.MarkerWeight : s.MarkerWeight;
+ s.FillAlpha = s.FillAlpha < 0 ? gp.Style.FillAlpha : s.FillAlpha;
+ s.ErrorBarSize = s.ErrorBarSize < 0 ? gp.Style.ErrorBarSize : s.ErrorBarSize;
+ s.ErrorBarWeight = s.ErrorBarWeight < 0 ? gp.Style.ErrorBarWeight : s.ErrorBarWeight;
+ s.DigitalBitHeight = s.DigitalBitHeight < 0 ? gp.Style.DigitalBitHeight : s.DigitalBitHeight;
+ s.DigitalBitGap = s.DigitalBitGap < 0 ? gp.Style.DigitalBitGap : s.DigitalBitGap;
+ // apply alpha modifier(s)
+ s.Colors[ImPlotCol_Fill].w *= s.FillAlpha;
+ // s.Colors[ImPlotCol_MarkerFill].w *= s.FillAlpha; // TODO: this should be separate, if it at all
+ // apply highlight mods
+ if (item->LegendHovered && !ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_NoHighlight)) {
+ s.LineWeight *= 2;
+ s.MarkerWeight *= 2;
+ // TODO: highlight fills?
+ }
+ // set render flags
+ s.RenderLine = s.Colors[ImPlotCol_Line].w > 0 && s.LineWeight > 0;
+ s.RenderFill = s.Colors[ImPlotCol_Fill].w > 0;
+ s.RenderMarkerLine = s.Colors[ImPlotCol_MarkerOutline].w > 0 && s.MarkerWeight > 0;
+ s.RenderMarkerFill = s.Colors[ImPlotCol_MarkerFill].w > 0;
+ // push rendering clip rect
+ PushPlotClipRect();
+ return true;
+ }
+}
+
+// Ends an item (call only if BeginItem returns true)
+void EndItem() {
+ ImPlotContext& gp = *GImPlot;
+ // pop rendering clip rect
+ PopPlotClipRect();
+ // reset next item data
+ gp.NextItemData.Reset();
+ // set current item
+ gp.PreviousItem = gp.CurrentItem;
+ gp.CurrentItem = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// GETTERS
+//-----------------------------------------------------------------------------
+
+// Getters can be thought of as iterators that convert user data (e.g. raw arrays)
+// to ImPlotPoints
+
+// Interprets an array of Y points as ImPlotPoints where the X value is the index
+template <typename T>
+struct GetterYs {
+ GetterYs(const T* ys, int count, double xscale, double x0, int offset, int stride) :
+ Ys(ys),
+ Count(count),
+ XScale(xscale),
+ X0(x0),
+ Offset(count ? ImPosMod(offset, count) : 0),
+ Stride(stride)
+ { }
+ inline ImPlotPoint operator()(int idx) const {
+ return ImPlotPoint(X0 + XScale * idx, (double)OffsetAndStride(Ys, idx, Count, Offset, Stride));
+ }
+ const T* const Ys;
+ const int Count;
+ const double XScale;
+ const double X0;
+ const int Offset;
+ const int Stride;
+};
+
+// Interprets separate arrays for X and Y points as ImPlotPoints
+template <typename T>
+struct GetterXsYs {
+ GetterXsYs(const T* xs, const T* ys, int count, int offset, int stride) :
+ Xs(xs),
+ Ys(ys),
+ Count(count),
+ Offset(count ? ImPosMod(offset, count) : 0),
+ Stride(stride)
+ { }
+ inline ImPlotPoint operator()(int idx) const {
+ return ImPlotPoint((double)OffsetAndStride(Xs, idx, Count, Offset, Stride), (double)OffsetAndStride(Ys, idx, Count, Offset, Stride));
+ }
+ const T* const Xs;
+ const T* const Ys;
+ const int Count;
+ const int Offset;
+ const int Stride;
+};
+
+// Always returns a constant Y reference value where the X value is the index
+struct GetterYRef {
+ GetterYRef(double y_ref, int count, double xscale, double x0) :
+ YRef(y_ref),
+ Count(count),
+ XScale(xscale),
+ X0(x0)
+ { }
+ inline ImPlotPoint operator()(int idx) const {
+ return ImPlotPoint(X0 + XScale*idx, YRef);
+ }
+ const double YRef;
+ const int Count;
+ const double XScale;
+ const double X0;
+};
+
+// Interprets an array of X points as ImPlotPoints where the Y value is a constant reference value
+template <typename T>
+struct GetterXsYRef {
+ GetterXsYRef(const T* xs, double y_ref, int count, int offset, int stride) :
+ Xs(xs),
+ YRef(y_ref),
+ Count(count),
+ Offset(count ? ImPosMod(offset, count) : 0),
+ Stride(stride)
+ { }
+ inline ImPlotPoint operator()(int idx) const {
+ return ImPlotPoint((double)OffsetAndStride(Xs, idx, Count, Offset, Stride), YRef);
+ }
+ const T* const Xs;
+ const double YRef;
+ const int Count;
+ const int Offset;
+ const int Stride;
+};
+
+// Interprets an array of Y points as ImPlotPoints where the X value is a constant reference value
+template <typename T>
+struct GetterXRefYs {
+ GetterXRefYs(double x_ref, const T* ys, int count, int offset, int stride) :
+ XRef(x_ref),
+ Ys(ys),
+ Count(count),
+ Offset(count ? ImPosMod(offset, count) : 0),
+ Stride(stride)
+ { }
+ inline ImPlotPoint operator()(int idx) const {
+ return ImPlotPoint(XRef, (double)OffsetAndStride(Ys, idx, Count, Offset, Stride));
+ }
+ const double XRef;
+ const T* const Ys;
+ const int Count;
+ const int Offset;
+ const int Stride;
+};
+
+/// Interprets a user's function pointer as ImPlotPoints
+struct GetterFuncPtr {
+ GetterFuncPtr(ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset) :
+ Getter(getter),
+ Data(data),
+ Count(count),
+ Offset(count ? ImPosMod(offset, count) : 0)
+ { }
+ inline ImPlotPoint operator()(int idx) const {
+ idx = ImPosMod(Offset + idx, Count);
+ return Getter(Data, idx);
+ }
+ ImPlotPoint (* const Getter)(void* data, int idx);
+ void* const Data;
+ const int Count;
+ const int Offset;
+};
+
+template <typename T>
+struct GetterBarV {
+ const T* Ys; double XShift; int Count; int Offset; int Stride;
+ GetterBarV(const T* ys, double xshift, int count, int offset, int stride) { Ys = ys; XShift = xshift; Count = count; Offset = offset; Stride = stride; }
+ inline ImPlotPoint operator()(int idx) const { return ImPlotPoint((double)idx + (double)XShift, (double)OffsetAndStride(Ys, idx, Count, Offset, Stride)); }
+};
+
+template <typename T>
+struct GetterBarH {
+ const T* Xs; double YShift; int Count; int Offset; int Stride;
+ GetterBarH(const T* xs, double yshift, int count, int offset, int stride) { Xs = xs; YShift = yshift; Count = count; Offset = offset; Stride = stride; }
+ inline ImPlotPoint operator()(int idx) const { return ImPlotPoint((double)OffsetAndStride(Xs, idx, Count, Offset, Stride), (double)idx + (double)YShift); }
+};
+
+template <typename T>
+struct GetterError {
+ GetterError(const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset, int stride) :
+ Xs(xs),
+ Ys(ys),
+ Neg(neg),
+ Pos(pos),
+ Count(count),
+ Offset(count ? ImPosMod(offset, count) : 0),
+ Stride(stride)
+ { }
+ inline ImPlotPointError operator()(int idx) const {
+ return ImPlotPointError((double)OffsetAndStride(Xs, idx, Count, Offset, Stride),
+ (double)OffsetAndStride(Ys, idx, Count, Offset, Stride),
+ (double)OffsetAndStride(Neg, idx, Count, Offset, Stride),
+ (double)OffsetAndStride(Pos, idx, Count, Offset, Stride));
+ }
+ const T* const Xs;
+ const T* const Ys;
+ const T* const Neg;
+ const T* const Pos;
+ const int Count;
+ const int Offset;
+ const int Stride;
+};
+
+//-----------------------------------------------------------------------------
+// TRANSFORMERS
+//-----------------------------------------------------------------------------
+
+// Transforms convert points in plot space (i.e. ImPlotPoint) to pixel space (i.e. ImVec2)
+
+// Transforms points for linear x and linear y space
+struct TransformerLinLin {
+ TransformerLinLin() : YAxis(GetCurrentYAxis()) {}
+ // inline ImVec2 operator()(const ImPlotPoint& plt) const { return (*this)(plt.x, plt.y); }
+ inline ImVec2 operator()(const ImPlotPoint& plt) const {
+ ImPlotContext& gp = *GImPlot;
+ return ImVec2( (float)(gp.PixelRange[YAxis].Min.x + gp.Mx * (plt.x - gp.CurrentPlot->XAxis.Range.Min)),
+ (float)(gp.PixelRange[YAxis].Min.y + gp.My[YAxis] * (plt.y - gp.CurrentPlot->YAxis[YAxis].Range.Min)) );
+ }
+ const int YAxis;
+};
+
+// Transforms points for log x and linear y space
+struct TransformerLogLin {
+ TransformerLogLin() : YAxis(GetCurrentYAxis()) {}
+ inline ImVec2 operator()(const ImPlotPoint& plt) const {
+ ImPlotContext& gp = *GImPlot;
+ double t = ImLog10(plt.x / gp.CurrentPlot->XAxis.Range.Min) / gp.LogDenX;
+ double x = ImLerp(gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max, (float)t);
+ return ImVec2( (float)(gp.PixelRange[YAxis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min)),
+ (float)(gp.PixelRange[YAxis].Min.y + gp.My[YAxis] * (plt.y - gp.CurrentPlot->YAxis[YAxis].Range.Min)) );
+ }
+ const int YAxis;
+};
+
+// Transforms points for linear x and log y space
+struct TransformerLinLog {
+ TransformerLinLog() : YAxis(GetCurrentYAxis()) {}
+ inline ImVec2 operator()(const ImPlotPoint& plt) const {
+ ImPlotContext& gp = *GImPlot;
+ double t = ImLog10(plt.y / gp.CurrentPlot->YAxis[YAxis].Range.Min) / gp.LogDenY[YAxis];
+ double y = ImLerp(gp.CurrentPlot->YAxis[YAxis].Range.Min, gp.CurrentPlot->YAxis[YAxis].Range.Max, (float)t);
+ return ImVec2( (float)(gp.PixelRange[YAxis].Min.x + gp.Mx * (plt.x - gp.CurrentPlot->XAxis.Range.Min)),
+ (float)(gp.PixelRange[YAxis].Min.y + gp.My[YAxis] * (y - gp.CurrentPlot->YAxis[YAxis].Range.Min)) );
+ }
+ const int YAxis;
+};
+
+// Transforms points for log x and log y space
+struct TransformerLogLog {
+ TransformerLogLog() : YAxis(GetCurrentYAxis()) {}
+ inline ImVec2 operator()(const ImPlotPoint& plt) const {
+ ImPlotContext& gp = *GImPlot;
+ double t = ImLog10(plt.x / gp.CurrentPlot->XAxis.Range.Min) / gp.LogDenX;
+ double x = ImLerp(gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max, (float)t);
+ t = ImLog10(plt.y / gp.CurrentPlot->YAxis[YAxis].Range.Min) / gp.LogDenY[YAxis];
+ double y = ImLerp(gp.CurrentPlot->YAxis[YAxis].Range.Min, gp.CurrentPlot->YAxis[YAxis].Range.Max, (float)t);
+ return ImVec2( (float)(gp.PixelRange[YAxis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min)),
+ (float)(gp.PixelRange[YAxis].Min.y + gp.My[YAxis] * (y - gp.CurrentPlot->YAxis[YAxis].Range.Min)) );
+ }
+ const int YAxis;
+};
+
+//-----------------------------------------------------------------------------
+// PRIMITIVE RENDERERS
+//-----------------------------------------------------------------------------
+
+inline void AddLine(const ImVec2& P1, const ImVec2& P2, float weight, ImU32 col, ImDrawList& DrawList, ImVec2 uv) {
+ float dx = P2.x - P1.x;
+ float dy = P2.y - P1.y;
+ IMPLOT_NORMALIZE2F_OVER_ZERO(dx, dy);
+ dx *= (weight * 0.5f);
+ dy *= (weight * 0.5f);
+ DrawList._VtxWritePtr[0].pos.x = P1.x + dy;
+ DrawList._VtxWritePtr[0].pos.y = P1.y - dx;
+ DrawList._VtxWritePtr[0].uv = uv;
+ DrawList._VtxWritePtr[0].col = col;
+ DrawList._VtxWritePtr[1].pos.x = P2.x + dy;
+ DrawList._VtxWritePtr[1].pos.y = P2.y - dx;
+ DrawList._VtxWritePtr[1].uv = uv;
+ DrawList._VtxWritePtr[1].col = col;
+ DrawList._VtxWritePtr[2].pos.x = P2.x - dy;
+ DrawList._VtxWritePtr[2].pos.y = P2.y + dx;
+ DrawList._VtxWritePtr[2].uv = uv;
+ DrawList._VtxWritePtr[2].col = col;
+ DrawList._VtxWritePtr[3].pos.x = P1.x - dy;
+ DrawList._VtxWritePtr[3].pos.y = P1.y + dx;
+ DrawList._VtxWritePtr[3].uv = uv;
+ DrawList._VtxWritePtr[3].col = col;
+ DrawList._VtxWritePtr += 4;
+ DrawList._IdxWritePtr[0] = (ImDrawIdx)(DrawList._VtxCurrentIdx);
+ DrawList._IdxWritePtr[1] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 1);
+ DrawList._IdxWritePtr[2] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 2);
+ DrawList._IdxWritePtr[3] = (ImDrawIdx)(DrawList._VtxCurrentIdx);
+ DrawList._IdxWritePtr[4] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 2);
+ DrawList._IdxWritePtr[5] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 3);
+ DrawList._IdxWritePtr += 6;
+ DrawList._VtxCurrentIdx += 4;
+}
+
+inline void AddRectFilled(const ImVec2& Pmin, const ImVec2& Pmax, ImU32 col, ImDrawList& DrawList, ImVec2 uv) {
+ DrawList._VtxWritePtr[0].pos = Pmin;
+ DrawList._VtxWritePtr[0].uv = uv;
+ DrawList._VtxWritePtr[0].col = col;
+ DrawList._VtxWritePtr[1].pos = Pmax;
+ DrawList._VtxWritePtr[1].uv = uv;
+ DrawList._VtxWritePtr[1].col = col;
+ DrawList._VtxWritePtr[2].pos.x = Pmin.x;
+ DrawList._VtxWritePtr[2].pos.y = Pmax.y;
+ DrawList._VtxWritePtr[2].uv = uv;
+ DrawList._VtxWritePtr[2].col = col;
+ DrawList._VtxWritePtr[3].pos.x = Pmax.x;
+ DrawList._VtxWritePtr[3].pos.y = Pmin.y;
+ DrawList._VtxWritePtr[3].uv = uv;
+ DrawList._VtxWritePtr[3].col = col;
+ DrawList._VtxWritePtr += 4;
+ DrawList._IdxWritePtr[0] = (ImDrawIdx)(DrawList._VtxCurrentIdx);
+ DrawList._IdxWritePtr[1] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 1);
+ DrawList._IdxWritePtr[2] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 2);
+ DrawList._IdxWritePtr[3] = (ImDrawIdx)(DrawList._VtxCurrentIdx);
+ DrawList._IdxWritePtr[4] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 1);
+ DrawList._IdxWritePtr[5] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 3);
+ DrawList._IdxWritePtr += 6;
+ DrawList._VtxCurrentIdx += 4;
+}
+
+template <typename TGetter, typename TTransformer>
+struct LineStripRenderer {
+ inline LineStripRenderer(const TGetter& getter, const TTransformer& transformer, ImU32 col, float weight) :
+ Getter(getter),
+ Transformer(transformer),
+ Prims(Getter.Count - 1),
+ Col(col),
+ Weight(weight)
+ {
+ P1 = Transformer(Getter(0));
+ }
+ inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
+ ImVec2 P2 = Transformer(Getter(prim + 1));
+ if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
+ P1 = P2;
+ return false;
+ }
+ AddLine(P1,P2,Weight,Col,DrawList,uv);
+ P1 = P2;
+ return true;
+ }
+ const TGetter& Getter;
+ const TTransformer& Transformer;
+ const int Prims;
+ const ImU32 Col;
+ const float Weight;
+ mutable ImVec2 P1;
+ static const int IdxConsumed = 6;
+ static const int VtxConsumed = 4;
+};
+
+template <typename TGetter, typename TTransformer>
+struct StairsRenderer {
+ inline StairsRenderer(const TGetter& getter, const TTransformer& transformer, ImU32 col, float weight) :
+ Getter(getter),
+ Transformer(transformer),
+ Prims(Getter.Count - 1),
+ Col(col),
+ HalfWeight(weight * 0.5f)
+ {
+ P1 = Transformer(Getter(0));
+ }
+ inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
+ ImVec2 P2 = Transformer(Getter(prim + 1));
+ if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
+ P1 = P2;
+ return false;
+ }
+ AddRectFilled(ImVec2(P1.x, P1.y + HalfWeight), ImVec2(P2.x, P1.y - HalfWeight), Col, DrawList, uv);
+ AddRectFilled(ImVec2(P2.x - HalfWeight, P2.y), ImVec2(P2.x + HalfWeight, P1.y), Col, DrawList, uv);
+
+ // AddLine(P1, P12, Weight, Col, DrawList, uv);
+ // AddLine(P12, P2, Weight, Col, DrawList, uv);
+ P1 = P2;
+ return true;
+ }
+ const TGetter& Getter;
+ const TTransformer& Transformer;
+ const int Prims;
+ const ImU32 Col;
+ const float HalfWeight;
+ mutable ImVec2 P1;
+ static const int IdxConsumed = 12;
+ static const int VtxConsumed = 8;
+};
+
+template <typename TGetter1, typename TGetter2, typename TTransformer>
+struct LineSegmentsRenderer {
+ inline LineSegmentsRenderer(const TGetter1& getter1, const TGetter2& getter2, const TTransformer& transformer, ImU32 col, float weight) :
+ Getter1(getter1),
+ Getter2(getter2),
+ Transformer(transformer),
+ Prims(ImMin(Getter1.Count, Getter2.Count)),
+ Col(col),
+ Weight(weight)
+ {}
+ inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
+ ImVec2 P1 = Transformer(Getter1(prim));
+ ImVec2 P2 = Transformer(Getter2(prim));
+ if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2))))
+ return false;
+ AddLine(P1,P2,Weight,Col,DrawList,uv);
+ return true;
+ }
+ const TGetter1& Getter1;
+ const TGetter2& Getter2;
+ const TTransformer& Transformer;
+ const int Prims;
+ const ImU32 Col;
+ const float Weight;
+ static const int IdxConsumed = 6;
+ static const int VtxConsumed = 4;
+};
+
+template <typename TGetter1, typename TGetter2, typename TTransformer>
+struct ShadedRenderer {
+ ShadedRenderer(const TGetter1& getter1, const TGetter2& getter2, const TTransformer& transformer, ImU32 col) :
+ Getter1(getter1),
+ Getter2(getter2),
+ Transformer(transformer),
+ Prims(ImMin(Getter1.Count, Getter2.Count) - 1),
+ Col(col)
+ {
+ P11 = Transformer(Getter1(0));
+ P12 = Transformer(Getter2(0));
+ }
+
+ inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
+ ImVec2 P21 = Transformer(Getter1(prim+1));
+ ImVec2 P22 = Transformer(Getter2(prim+1));
+ ImRect rect(ImMin(ImMin(ImMin(P11,P12),P21),P22), ImMax(ImMax(ImMax(P11,P12),P21),P22));
+ if (!cull_rect.Overlaps(rect)) {
+ P11 = P21;
+ P12 = P22;
+ return false;
+ }
+ const int intersect = (P11.y > P12.y && P22.y > P21.y) || (P12.y > P11.y && P21.y > P22.y);
+ ImVec2 intersection = Intersection(P11,P21,P12,P22);
+ DrawList._VtxWritePtr[0].pos = P11;
+ DrawList._VtxWritePtr[0].uv = uv;
+ DrawList._VtxWritePtr[0].col = Col;
+ DrawList._VtxWritePtr[1].pos = P21;
+ DrawList._VtxWritePtr[1].uv = uv;
+ DrawList._VtxWritePtr[1].col = Col;
+ DrawList._VtxWritePtr[2].pos = intersection;
+ DrawList._VtxWritePtr[2].uv = uv;
+ DrawList._VtxWritePtr[2].col = Col;
+ DrawList._VtxWritePtr[3].pos = P12;
+ DrawList._VtxWritePtr[3].uv = uv;
+ DrawList._VtxWritePtr[3].col = Col;
+ DrawList._VtxWritePtr[4].pos = P22;
+ DrawList._VtxWritePtr[4].uv = uv;
+ DrawList._VtxWritePtr[4].col = Col;
+ DrawList._VtxWritePtr += 5;
+ DrawList._IdxWritePtr[0] = (ImDrawIdx)(DrawList._VtxCurrentIdx);
+ DrawList._IdxWritePtr[1] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 1 + intersect);
+ DrawList._IdxWritePtr[2] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 3);
+ DrawList._IdxWritePtr[3] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 1);
+ DrawList._IdxWritePtr[4] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 3 - intersect);
+ DrawList._IdxWritePtr[5] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 4);
+ DrawList._IdxWritePtr += 6;
+ DrawList._VtxCurrentIdx += 5;
+ P11 = P21;
+ P12 = P22;
+ return true;
+ }
+ const TGetter1& Getter1;
+ const TGetter2& Getter2;
+ const TTransformer& Transformer;
+ const int Prims;
+ const ImU32 Col;
+ mutable ImVec2 P11;
+ mutable ImVec2 P12;
+ static const int IdxConsumed = 6;
+ static const int VtxConsumed = 5;
+};
+
+// Stupid way of calculating maximum index size of ImDrawIdx without integer overflow issues
+template <typename T>
+struct MaxIdx { static const unsigned int Value; };
+template <> const unsigned int MaxIdx<unsigned short>::Value = 65535;
+template <> const unsigned int MaxIdx<unsigned int>::Value = 4294967295;
+
+/// Renders primitive shapes in bulk as efficiently as possible.
+template <typename Renderer>
+inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
+ unsigned int prims = renderer.Prims;
+ unsigned int prims_culled = 0;
+ unsigned int idx = 0;
+ const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
+ while (prims) {
+ // find how many can be reserved up to end of current draw command's limit
+ unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
+ // make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
+ if (cnt >= ImMin(64u, prims)) {
+ if (prims_culled >= cnt)
+ prims_culled -= cnt; // reuse previous reservation
+ else {
+ DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
+ prims_culled = 0;
+ }
+ }
+ else
+ {
+ if (prims_culled > 0) {
+ DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
+ prims_culled = 0;
+ }
+ cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
+ DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
+ }
+ prims -= cnt;
+ for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
+ if (!renderer(DrawList, cull_rect, uv, idx))
+ prims_culled++;
+ }
+ }
+ if (prims_culled > 0)
+ DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
+}
+
+template <typename Getter, typename Transformer>
+inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
+ ImPlotContext& gp = *GImPlot;
+ if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
+ ImVec2 p1 = transformer(getter(0));
+ for (int i = 1; i < getter.Count; ++i) {
+ ImVec2 p2 = transformer(getter(i));
+ if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
+ DrawList.AddLine(p1, p2, col, line_weight);
+ p1 = p2;
+ }
+ }
+ else {
+ RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
+ }
+}
+
+template <typename Getter1, typename Getter2, typename Transformer>
+inline void RenderLineSegments(const Getter1& getter1, const Getter2& getter2, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
+ ImPlotContext& gp = *GImPlot;
+ if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
+ int I = ImMin(getter1.Count, getter2.Count);
+ for (int i = 0; i < I; ++i) {
+ ImVec2 p1 = transformer(getter1(i));
+ ImVec2 p2 = transformer(getter2(i));
+ if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
+ DrawList.AddLine(p1, p2, col, line_weight);
+ }
+ }
+ else {
+ RenderPrimitives(LineSegmentsRenderer<Getter1,Getter2,Transformer>(getter1, getter2, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
+ }
+}
+
+template <typename Getter, typename Transformer>
+inline void RenderStairs(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
+ ImPlotContext& gp = *GImPlot;
+ if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
+ ImVec2 p1 = transformer(getter(0));
+ for (int i = 1; i < getter.Count; ++i) {
+ ImVec2 p2 = transformer(getter(i));
+ if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2)))) {
+ ImVec2 p12(p2.x, p1.y);
+ DrawList.AddLine(p1, p12, col, line_weight);
+ DrawList.AddLine(p12, p2, col, line_weight);
+ }
+ p1 = p2;
+ }
+ }
+ else {
+ RenderPrimitives(StairsRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
+ }
+}
+
+//-----------------------------------------------------------------------------
+// MARKER RENDERERS
+//-----------------------------------------------------------------------------
+
+inline void TransformMarker(ImVec2* points, int n, const ImVec2& c, float s) {
+ for (int i = 0; i < n; ++i) {
+ points[i].x = c.x + points[i].x * s;
+ points[i].y = c.y + points[i].y * s;
+ }
+}
+
+inline void RenderMarkerGeneral(ImDrawList& DrawList, ImVec2* points, int n, const ImVec2& c, float s, bool outline, ImU32 col_outline, bool fill, ImU32 col_fill, float weight) {
+ TransformMarker(points, n, c, s);
+ if (fill)
+ DrawList.AddConvexPolyFilled(points, n, col_fill);
+ if (outline && !(fill && col_outline == col_fill)) {
+ for (int i = 0; i < n; ++i)
+ DrawList.AddLine(points[i], points[(i+1)%n], col_outline, weight);
+ }
+}
+
+inline void RenderMarkerCircle(ImDrawList& DrawList, const ImVec2& c, float s, bool outline, ImU32 col_outline, bool fill, ImU32 col_fill, float weight) {
+ ImVec2 marker[10] = {ImVec2(1.0f, 0.0f),
+ ImVec2(0.809017f, 0.58778524f),
+ ImVec2(0.30901697f, 0.95105654f),
+ ImVec2(-0.30901703f, 0.9510565f),
+ ImVec2(-0.80901706f, 0.5877852f),
+ ImVec2(-1.0f, 0.0f),
+ ImVec2(-0.80901694f, -0.58778536f),
+ ImVec2(-0.3090171f, -0.9510565f),
+ ImVec2(0.30901712f, -0.9510565f),
+ ImVec2(0.80901694f, -0.5877853f)};
+ RenderMarkerGeneral(DrawList, marker, 10, c, s, outline, col_outline, fill, col_fill, weight);
+}
+
+inline void RenderMarkerDiamond(ImDrawList& DrawList, const ImVec2& c, float s, bool outline, ImU32 col_outline, bool fill, ImU32 col_fill, float weight) {
+ ImVec2 marker[4] = {ImVec2(1, 0), ImVec2(0, -1), ImVec2(-1, 0), ImVec2(0, 1)};
+ RenderMarkerGeneral(DrawList, marker, 4, c, s, outline, col_outline, fill, col_fill, weight);
+}
+
+inline void RenderMarkerSquare(ImDrawList& DrawList, const ImVec2& c, float s, bool outline, ImU32 col_outline, bool fill, ImU32 col_fill, float weight) {
+ ImVec2 marker[4] = {ImVec2(SQRT_1_2,SQRT_1_2),ImVec2(SQRT_1_2,-SQRT_1_2),ImVec2(-SQRT_1_2,-SQRT_1_2),ImVec2(-SQRT_1_2,SQRT_1_2)};
+ RenderMarkerGeneral(DrawList, marker, 4, c, s, outline, col_outline, fill, col_fill, weight);
+}
+
+inline void RenderMarkerUp(ImDrawList& DrawList, const ImVec2& c, float s, bool outline, ImU32 col_outline, bool fill, ImU32 col_fill, float weight) {
+ ImVec2 marker[3] = {ImVec2(SQRT_3_2,0.5f),ImVec2(0,-1),ImVec2(-SQRT_3_2,0.5f)};
+ RenderMarkerGeneral(DrawList, marker, 3, c, s, outline, col_outline, fill, col_fill, weight);
+}
+
+inline void RenderMarkerDown(ImDrawList& DrawList, const ImVec2& c, float s, bool outline, ImU32 col_outline, bool fill, ImU32 col_fill, float weight) {
+ ImVec2 marker[3] = {ImVec2(SQRT_3_2,-0.5f),ImVec2(0,1),ImVec2(-SQRT_3_2,-0.5f)};
+ RenderMarkerGeneral(DrawList, marker, 3, c, s, outline, col_outline, fill, col_fill, weight);
+}
+
+inline void RenderMarkerLeft(ImDrawList& DrawList, const ImVec2& c, float s, bool outline, ImU32 col_outline, bool fill, ImU32 col_fill, float weight) {
+ ImVec2 marker[3] = {ImVec2(-1,0), ImVec2(0.5, SQRT_3_2), ImVec2(0.5, -SQRT_3_2)};
+ RenderMarkerGeneral(DrawList, marker, 3, c, s, outline, col_outline, fill, col_fill, weight);
+}
+
+inline void RenderMarkerRight(ImDrawList& DrawList, const ImVec2& c, float s, bool outline, ImU32 col_outline, bool fill, ImU32 col_fill, float weight) {
+ ImVec2 marker[3] = {ImVec2(1,0), ImVec2(-0.5, SQRT_3_2), ImVec2(-0.5, -SQRT_3_2)};
+ RenderMarkerGeneral(DrawList, marker, 3, c, s, outline, col_outline, fill, col_fill, weight);
+}
+
+inline void RenderMarkerAsterisk(ImDrawList& DrawList, const ImVec2& c, float s, bool /*outline*/, ImU32 col_outline, bool /*fill*/, ImU32 /*col_fill*/, float weight) {
+ ImVec2 marker[6] = {ImVec2(SQRT_3_2, 0.5f), ImVec2(0, -1), ImVec2(-SQRT_3_2, 0.5f), ImVec2(SQRT_3_2, -0.5f), ImVec2(0, 1), ImVec2(-SQRT_3_2, -0.5f)};
+ TransformMarker(marker, 6, c, s);
+ DrawList.AddLine(marker[0], marker[5], col_outline, weight);
+ DrawList.AddLine(marker[1], marker[4], col_outline, weight);
+ DrawList.AddLine(marker[2], marker[3], col_outline, weight);
+}
+
+inline void RenderMarkerPlus(ImDrawList& DrawList, const ImVec2& c, float s, bool /*outline*/, ImU32 col_outline, bool /*fill*/, ImU32 /*col_fill*/, float weight) {
+ ImVec2 marker[4] = {ImVec2(1, 0), ImVec2(0, -1), ImVec2(-1, 0), ImVec2(0, 1)};
+ TransformMarker(marker, 4, c, s);
+ DrawList.AddLine(marker[0], marker[2], col_outline, weight);
+ DrawList.AddLine(marker[1], marker[3], col_outline, weight);
+}
+
+inline void RenderMarkerCross(ImDrawList& DrawList, const ImVec2& c, float s, bool /*outline*/, ImU32 col_outline, bool /*fill*/, ImU32 /*col_fill*/, float weight) {
+ ImVec2 marker[4] = {ImVec2(SQRT_1_2,SQRT_1_2),ImVec2(SQRT_1_2,-SQRT_1_2),ImVec2(-SQRT_1_2,-SQRT_1_2),ImVec2(-SQRT_1_2,SQRT_1_2)};
+ TransformMarker(marker, 4, c, s);
+ DrawList.AddLine(marker[0], marker[2], col_outline, weight);
+ DrawList.AddLine(marker[1], marker[3], col_outline, weight);
+}
+
+template <typename Transformer, typename Getter>
+inline void RenderMarkers(Getter getter, Transformer transformer, ImDrawList& DrawList, ImPlotMarker marker, float size, bool rend_mk_line, ImU32 col_mk_line, float weight, bool rend_mk_fill, ImU32 col_mk_fill) {
+ static void (*marker_table[ImPlotMarker_COUNT])(ImDrawList&, const ImVec2&, float s, bool, ImU32, bool, ImU32, float) = {
+ RenderMarkerCircle,
+ RenderMarkerSquare,
+ RenderMarkerDiamond ,
+ RenderMarkerUp ,
+ RenderMarkerDown ,
+ RenderMarkerLeft,
+ RenderMarkerRight,
+ RenderMarkerCross,
+ RenderMarkerPlus,
+ RenderMarkerAsterisk
+ };
+ ImPlotContext& gp = *GImPlot;
+ for (int i = 0; i < getter.Count; ++i) {
+ ImVec2 c = transformer(getter(i));
+ if (gp.CurrentPlot->PlotRect.Contains(c))
+ marker_table[marker](DrawList, c, size, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, weight);
+ }
+}
+
+//-----------------------------------------------------------------------------
+// PLOT LINE
+//-----------------------------------------------------------------------------
+
+template <typename Getter>
+inline void PlotLineEx(const char* label_id, const Getter& getter) {
+ if (BeginItem(label_id, ImPlotCol_Line)) {
+ if (FitThisFrame()) {
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPoint p = getter(i);
+ FitPoint(p);
+ }
+ }
+ const ImPlotNextItemData& s = GetItemData();
+ ImDrawList& DrawList = *GetPlotDrawList();
+ if (getter.Count > 1 && s.RenderLine) {
+ const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderLineStrip(getter, TransformerLinLin(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LogLin: RenderLineStrip(getter, TransformerLogLin(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LinLog: RenderLineStrip(getter, TransformerLinLog(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LogLog: RenderLineStrip(getter, TransformerLogLog(), DrawList, s.LineWeight, col_line); break;
+ }
+ }
+ // render markers
+ if (s.Marker != ImPlotMarker_None) {
+ PopPlotClipRect();
+ PushPlotClipRect(s.MarkerSize);
+ const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
+ const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderMarkers(getter, TransformerLinLin(), DrawList, s.Marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LogLin: RenderMarkers(getter, TransformerLogLin(), DrawList, s.Marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LinLog: RenderMarkers(getter, TransformerLinLog(), DrawList, s.Marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LogLog: RenderMarkers(getter, TransformerLogLog(), DrawList, s.Marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ }
+ }
+ EndItem();
+ }
+}
+
+template <typename T>
+void PlotLine(const char* label_id, const T* values, int count, double xscale, double x0, int offset, int stride) {
+ GetterYs<T> getter(values,count,xscale,x0,offset,stride);
+ PlotLineEx(label_id, getter);
+}
+
+template IMPLOT_API void PlotLine<ImS8> (const char* label_id, const ImS8* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotLine<ImU8> (const char* label_id, const ImU8* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotLine<ImS16>(const char* label_id, const ImS16* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotLine<ImU16>(const char* label_id, const ImU16* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotLine<ImS32>(const char* label_id, const ImS32* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotLine<ImU32>(const char* label_id, const ImU32* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotLine<ImS64>(const char* label_id, const ImS64* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotLine<ImU64>(const char* label_id, const ImU64* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotLine<float>(const char* label_id, const float* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotLine<double>(const char* label_id, const double* values, int count, double xscale, double x0, int offset, int stride);
+
+template <typename T>
+void PlotLine(const char* label_id, const T* xs, const T* ys, int count, int offset, int stride) {
+ GetterXsYs<T> getter(xs,ys,count,offset,stride);
+ return PlotLineEx(label_id, getter);
+}
+
+template IMPLOT_API void PlotLine<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotLine<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotLine<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotLine<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotLine<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotLine<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotLine<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotLine<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotLine<float>(const char* label_id, const float* xs, const float* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotLine<double>(const char* label_id, const double* xs, const double* ys, int count, int offset, int stride);
+
+// custom
+void PlotLineG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, int offset) {
+ GetterFuncPtr getter(getter_func,data, count, offset);
+ return PlotLineEx(label_id, getter);
+}
+
+//-----------------------------------------------------------------------------
+// PLOT SCATTER
+//-----------------------------------------------------------------------------
+
+template <typename Getter>
+inline void PlotScatterEx(const char* label_id, const Getter& getter) {
+ if (BeginItem(label_id, ImPlotCol_MarkerOutline)) {
+ if (FitThisFrame()) {
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPoint p = getter(i);
+ FitPoint(p);
+ }
+ }
+ const ImPlotNextItemData& s = GetItemData();
+ ImDrawList& DrawList = *GetPlotDrawList();
+ // render markers
+ ImPlotMarker marker = s.Marker == ImPlotMarker_None ? ImPlotMarker_Circle : s.Marker;
+ if (marker != ImPlotMarker_None) {
+ PopPlotClipRect();
+ PushPlotClipRect(s.MarkerSize);
+ const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
+ const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderMarkers(getter, TransformerLinLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LogLin: RenderMarkers(getter, TransformerLogLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LinLog: RenderMarkers(getter, TransformerLinLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LogLog: RenderMarkers(getter, TransformerLogLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ }
+ }
+ EndItem();
+ }
+}
+
+template <typename T>
+void PlotScatter(const char* label_id, const T* values, int count, double xscale, double x0, int offset, int stride) {
+ GetterYs<T> getter(values,count,xscale,x0,offset,stride);
+ PlotScatterEx(label_id, getter);
+}
+
+template IMPLOT_API void PlotScatter<ImS8>(const char* label_id, const ImS8* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImU8>(const char* label_id, const ImU8* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImS16>(const char* label_id, const ImS16* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImU16>(const char* label_id, const ImU16* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImS32>(const char* label_id, const ImS32* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImU32>(const char* label_id, const ImU32* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImS64>(const char* label_id, const ImS64* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImU64>(const char* label_id, const ImU64* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotScatter<float>(const char* label_id, const float* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotScatter<double>(const char* label_id, const double* values, int count, double xscale, double x0, int offset, int stride);
+
+template <typename T>
+void PlotScatter(const char* label_id, const T* xs, const T* ys, int count, int offset, int stride) {
+ GetterXsYs<T> getter(xs,ys,count,offset,stride);
+ return PlotScatterEx(label_id, getter);
+}
+
+template IMPLOT_API void PlotScatter<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotScatter<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotScatter<float>(const char* label_id, const float* xs, const float* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotScatter<double>(const char* label_id, const double* xs, const double* ys, int count, int offset, int stride);
+
+// custom
+void PlotScatterG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, int offset) {
+ GetterFuncPtr getter(getter_func,data, count, offset);
+ return PlotScatterEx(label_id, getter);
+}
+
+//-----------------------------------------------------------------------------
+// PLOT STAIRS
+//-----------------------------------------------------------------------------
+
+template <typename Getter>
+inline void PlotStairsEx(const char* label_id, const Getter& getter) {
+ if (BeginItem(label_id, ImPlotCol_Line)) {
+ if (FitThisFrame()) {
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPoint p = getter(i);
+ FitPoint(p);
+ }
+ }
+ const ImPlotNextItemData& s = GetItemData();
+ ImDrawList& DrawList = *GetPlotDrawList();
+ if (getter.Count > 1 && s.RenderLine) {
+ const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderStairs(getter, TransformerLinLin(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LogLin: RenderStairs(getter, TransformerLogLin(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LinLog: RenderStairs(getter, TransformerLinLog(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LogLog: RenderStairs(getter, TransformerLogLog(), DrawList, s.LineWeight, col_line); break;
+ }
+ }
+ // render markers
+ if (s.Marker != ImPlotMarker_None) {
+ PopPlotClipRect();
+ PushPlotClipRect(s.MarkerSize);
+ const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
+ const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderMarkers(getter, TransformerLinLin(), DrawList, s.Marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LogLin: RenderMarkers(getter, TransformerLogLin(), DrawList, s.Marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LinLog: RenderMarkers(getter, TransformerLinLog(), DrawList, s.Marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LogLog: RenderMarkers(getter, TransformerLogLog(), DrawList, s.Marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ }
+ }
+ EndItem();
+ }
+}
+
+template <typename T>
+void PlotStairs(const char* label_id, const T* values, int count, double xscale, double x0, int offset, int stride) {
+ GetterYs<T> getter(values,count,xscale,x0,offset,stride);
+ PlotStairsEx(label_id, getter);
+}
+
+template IMPLOT_API void PlotStairs<ImS8> (const char* label_id, const ImS8* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImU8> (const char* label_id, const ImU8* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImS16>(const char* label_id, const ImS16* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImU16>(const char* label_id, const ImU16* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImS32>(const char* label_id, const ImS32* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImU32>(const char* label_id, const ImU32* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImS64>(const char* label_id, const ImS64* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImU64>(const char* label_id, const ImU64* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStairs<float>(const char* label_id, const float* values, int count, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStairs<double>(const char* label_id, const double* values, int count, double xscale, double x0, int offset, int stride);
+
+template <typename T>
+void PlotStairs(const char* label_id, const T* xs, const T* ys, int count, int offset, int stride) {
+ GetterXsYs<T> getter(xs,ys,count,offset,stride);
+ return PlotStairsEx(label_id, getter);
+}
+
+template IMPLOT_API void PlotStairs<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotStairs<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotStairs<float>(const char* label_id, const float* xs, const float* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotStairs<double>(const char* label_id, const double* xs, const double* ys, int count, int offset, int stride);
+
+// custom
+void PlotStairsG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, int offset) {
+ GetterFuncPtr getter(getter_func,data, count, offset);
+ return PlotStairsEx(label_id, getter);
+}
+
+//-----------------------------------------------------------------------------
+// PLOT SHADED
+//-----------------------------------------------------------------------------
+
+template <typename Getter1, typename Getter2>
+inline void PlotShadedEx(const char* label_id, const Getter1& getter1, const Getter2& getter2, bool fit2) {
+ if (BeginItem(label_id, ImPlotCol_Fill)) {
+ if (FitThisFrame()) {
+ for (int i = 0; i < getter1.Count; ++i)
+ FitPoint(getter1(i));
+ if (fit2) {
+ for (int i = 0; i < getter2.Count; ++i)
+ FitPoint(getter2(i));
+ }
+ }
+ const ImPlotNextItemData& s = GetItemData();
+ ImDrawList & DrawList = *GetPlotDrawList();
+ if (s.RenderFill) {
+ ImU32 col = ImGui::GetColorU32(s.Colors[ImPlotCol_Fill]);
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderPrimitives(ShadedRenderer<Getter1,Getter2,TransformerLinLin>(getter1,getter2,TransformerLinLin(), col), DrawList, GImPlot->CurrentPlot->PlotRect); break;
+ case ImPlotScale_LogLin: RenderPrimitives(ShadedRenderer<Getter1,Getter2,TransformerLogLin>(getter1,getter2,TransformerLogLin(), col), DrawList, GImPlot->CurrentPlot->PlotRect); break;
+ case ImPlotScale_LinLog: RenderPrimitives(ShadedRenderer<Getter1,Getter2,TransformerLinLog>(getter1,getter2,TransformerLinLog(), col), DrawList, GImPlot->CurrentPlot->PlotRect); break;
+ case ImPlotScale_LogLog: RenderPrimitives(ShadedRenderer<Getter1,Getter2,TransformerLogLog>(getter1,getter2,TransformerLogLog(), col), DrawList, GImPlot->CurrentPlot->PlotRect); break;
+ }
+ }
+ EndItem();
+ }
+}
+
+template <typename T>
+void PlotShaded(const char* label_id, const T* values, int count, double y_ref, double xscale, double x0, int offset, int stride) {
+ bool fit2 = true;
+ if (y_ref == -HUGE_VAL) {
+ fit2 = false;
+ y_ref = GetPlotLimits().Y.Min;
+ }
+ if (y_ref == HUGE_VAL) {
+ fit2 = false;
+ y_ref = GetPlotLimits().Y.Max;
+ }
+ GetterYs<T> getter1(values,count,xscale,x0,offset,stride);
+ GetterYRef getter2(y_ref,count,xscale,x0);
+ PlotShadedEx(label_id, getter1, getter2, fit2);
+}
+
+template IMPLOT_API void PlotShaded<ImS8>(const char* label_id, const ImS8* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU8>(const char* label_id, const ImU8* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImS16>(const char* label_id, const ImS16* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU16>(const char* label_id, const ImU16* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImS32>(const char* label_id, const ImS32* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU32>(const char* label_id, const ImU32* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImS64>(const char* label_id, const ImS64* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU64>(const char* label_id, const ImU64* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotShaded<float>(const char* label_id, const float* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotShaded<double>(const char* label_id, const double* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+
+template <typename T>
+void PlotShaded(const char* label_id, const T* xs, const T* ys, int count, double y_ref, int offset, int stride) {
+ bool fit2 = true;
+ if (y_ref == -HUGE_VAL) {
+ fit2 = false;
+ y_ref = GetPlotLimits().Y.Min;
+ }
+ if (y_ref == HUGE_VAL) {
+ fit2 = false;
+ y_ref = GetPlotLimits().Y.Max;
+ }
+ GetterXsYs<T> getter1(xs, ys, count, offset, stride);
+ GetterXsYRef<T> getter2(xs, y_ref, count, offset, stride);
+ PlotShadedEx(label_id, getter1, getter2, fit2);
+}
+
+template IMPLOT_API void PlotShaded<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotShaded<float>(const char* label_id, const float* xs, const float* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotShaded<double>(const char* label_id, const double* xs, const double* ys, int count, double y_ref, int offset, int stride);
+
+template <typename T>
+void PlotShaded(const char* label_id, const T* xs, const T* ys1, const T* ys2, int count, int offset, int stride) {
+ GetterXsYs<T> getter1(xs, ys1, count, offset, stride);
+ GetterXsYs<T> getter2(xs, ys2, count, offset, stride);
+ PlotShadedEx(label_id, getter1, getter2, true);
+}
+
+template IMPLOT_API void PlotShaded<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys1, const ImS8* ys2, int count, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys1, const ImU8* ys2, int count, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys1, const ImS16* ys2, int count, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys1, const ImU16* ys2, int count, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys1, const ImS32* ys2, int count, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys1, const ImU32* ys2, int count, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys1, const ImS64* ys2, int count, int offset, int stride);
+template IMPLOT_API void PlotShaded<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys1, const ImU64* ys2, int count, int offset, int stride);
+template IMPLOT_API void PlotShaded<float>(const char* label_id, const float* xs, const float* ys1, const float* ys2, int count, int offset, int stride);
+template IMPLOT_API void PlotShaded<double>(const char* label_id, const double* xs, const double* ys1, const double* ys2, int count, int offset, int stride);
+
+// custom
+void PlotShadedG(const char* label_id, ImPlotPoint (*g1)(void* data, int idx), void* data1, ImPlotPoint (*g2)(void* data, int idx), void* data2, int count, int offset) {
+ GetterFuncPtr getter1(g1, data1, count, offset);
+ GetterFuncPtr getter2(g2, data2, count, offset);
+ PlotShadedEx(label_id, getter1, getter2, true);
+}
+
+//-----------------------------------------------------------------------------
+// PLOT BAR
+//-----------------------------------------------------------------------------
+
+// TODO: Migrate to RenderPrimitives
+
+template <typename Getter>
+void PlotBarsEx(const char* label_id, const Getter& getter, double width) {
+ if (BeginItem(label_id, ImPlotCol_Fill)) {
+ const double half_width = width / 2;
+ if (FitThisFrame()) {
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPoint p = getter(i);
+ FitPoint(ImPlotPoint(p.x - half_width, p.y));
+ FitPoint(ImPlotPoint(p.x + half_width, 0));
+ }
+ }
+ const ImPlotNextItemData& s = GetItemData();
+ ImDrawList& DrawList = *GetPlotDrawList();
+ ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
+ ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_Fill]);
+ bool rend_line = s.RenderLine;
+ if (s.RenderFill && col_line == col_fill)
+ rend_line = false;
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPoint p = getter(i);
+ if (p.y == 0)
+ continue;
+ ImVec2 a = PlotToPixels(p.x - half_width, p.y);
+ ImVec2 b = PlotToPixels(p.x + half_width, 0);
+ if (s.RenderFill)
+ DrawList.AddRectFilled(a, b, col_fill);
+ if (rend_line)
+ DrawList.AddRect(a, b, col_line, 0, ImDrawFlags_RoundCornersAll, s.LineWeight);
+ }
+ EndItem();
+ }
+}
+
+template <typename T>
+void PlotBars(const char* label_id, const T* values, int count, double width, double shift, int offset, int stride) {
+ GetterBarV<T> getter(values,shift,count,offset,stride);
+ PlotBarsEx(label_id, getter, width);
+}
+
+template IMPLOT_API void PlotBars<ImS8>(const char* label_id, const ImS8* values, int count, double width, double shift, int offset, int stride);
+template IMPLOT_API void PlotBars<ImU8>(const char* label_id, const ImU8* values, int count, double width, double shift, int offset, int stride);
+template IMPLOT_API void PlotBars<ImS16>(const char* label_id, const ImS16* values, int count, double width, double shift, int offset, int stride);
+template IMPLOT_API void PlotBars<ImU16>(const char* label_id, const ImU16* values, int count, double width, double shift, int offset, int stride);
+template IMPLOT_API void PlotBars<ImS32>(const char* label_id, const ImS32* values, int count, double width, double shift, int offset, int stride);
+template IMPLOT_API void PlotBars<ImU32>(const char* label_id, const ImU32* values, int count, double width, double shift, int offset, int stride);
+template IMPLOT_API void PlotBars<ImS64>(const char* label_id, const ImS64* values, int count, double width, double shift, int offset, int stride);
+template IMPLOT_API void PlotBars<ImU64>(const char* label_id, const ImU64* values, int count, double width, double shift, int offset, int stride);
+template IMPLOT_API void PlotBars<float>(const char* label_id, const float* values, int count, double width, double shift, int offset, int stride);
+template IMPLOT_API void PlotBars<double>(const char* label_id, const double* values, int count, double width, double shift, int offset, int stride);
+
+template <typename T>
+void PlotBars(const char* label_id, const T* xs, const T* ys, int count, double width, int offset, int stride) {
+ GetterXsYs<T> getter(xs,ys,count,offset,stride);
+ PlotBarsEx(label_id, getter, width);
+}
+
+template IMPLOT_API void PlotBars<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, int count, double width, int offset, int stride);
+template IMPLOT_API void PlotBars<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, int count, double width, int offset, int stride);
+template IMPLOT_API void PlotBars<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, int count, double width, int offset, int stride);
+template IMPLOT_API void PlotBars<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, int count, double width, int offset, int stride);
+template IMPLOT_API void PlotBars<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, int count, double width, int offset, int stride);
+template IMPLOT_API void PlotBars<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, int count, double width, int offset, int stride);
+template IMPLOT_API void PlotBars<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, int count, double width, int offset, int stride);
+template IMPLOT_API void PlotBars<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, int count, double width, int offset, int stride);
+template IMPLOT_API void PlotBars<float>(const char* label_id, const float* xs, const float* ys, int count, double width, int offset, int stride);
+template IMPLOT_API void PlotBars<double>(const char* label_id, const double* xs, const double* ys, int count, double width, int offset, int stride);
+
+// custom
+void PlotBarsG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, double width, int offset) {
+ GetterFuncPtr getter(getter_func, data, count, offset);
+ PlotBarsEx(label_id, getter, width);
+}
+
+//-----------------------------------------------------------------------------
+// PLOT BAR H
+//-----------------------------------------------------------------------------
+
+// TODO: Migrate to RenderPrimitives
+
+template <typename Getter, typename THeight>
+void PlotBarsHEx(const char* label_id, const Getter& getter, THeight height) {
+ if (BeginItem(label_id, ImPlotCol_Fill)) {
+ const THeight half_height = height / 2;
+ if (FitThisFrame()) {
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPoint p = getter(i);
+ FitPoint(ImPlotPoint(0, p.y - half_height));
+ FitPoint(ImPlotPoint(p.x, p.y + half_height));
+ }
+ }
+ const ImPlotNextItemData& s = GetItemData();
+ ImDrawList& DrawList = *GetPlotDrawList();
+ ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
+ ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_Fill]);
+ bool rend_line = s.RenderLine;
+ if (s.RenderFill && col_line == col_fill)
+ rend_line = false;
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPoint p = getter(i);
+ if (p.x == 0)
+ continue;
+ ImVec2 a = PlotToPixels(0, p.y - half_height);
+ ImVec2 b = PlotToPixels(p.x, p.y + half_height);
+ if (s.RenderFill)
+ DrawList.AddRectFilled(a, b, col_fill);
+ if (rend_line)
+ DrawList.AddRect(a, b, col_line, 0, ImDrawFlags_RoundCornersAll, s.LineWeight);
+ }
+ EndItem();
+ }
+}
+
+template <typename T>
+void PlotBarsH(const char* label_id, const T* values, int count, double height, double shift, int offset, int stride) {
+ GetterBarH<T> getter(values,shift,count,offset,stride);
+ PlotBarsHEx(label_id, getter, height);
+}
+
+template IMPLOT_API void PlotBarsH<ImS8>(const char* label_id, const ImS8* values, int count, double height, double shift, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImU8>(const char* label_id, const ImU8* values, int count, double height, double shift, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImS16>(const char* label_id, const ImS16* values, int count, double height, double shift, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImU16>(const char* label_id, const ImU16* values, int count, double height, double shift, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImS32>(const char* label_id, const ImS32* values, int count, double height, double shift, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImU32>(const char* label_id, const ImU32* values, int count, double height, double shift, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImS64>(const char* label_id, const ImS64* values, int count, double height, double shift, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImU64>(const char* label_id, const ImU64* values, int count, double height, double shift, int offset, int stride);
+template IMPLOT_API void PlotBarsH<float>(const char* label_id, const float* values, int count, double height, double shift, int offset, int stride);
+template IMPLOT_API void PlotBarsH<double>(const char* label_id, const double* values, int count, double height, double shift, int offset, int stride);
+
+template <typename T>
+void PlotBarsH(const char* label_id, const T* xs, const T* ys, int count, double height, int offset, int stride) {
+ GetterXsYs<T> getter(xs,ys,count,offset,stride);
+ PlotBarsHEx(label_id, getter, height);
+}
+
+template IMPLOT_API void PlotBarsH<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, int count, double height, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, int count, double height, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, int count, double height, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, int count, double height, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, int count, double height, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, int count, double height, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, int count, double height, int offset, int stride);
+template IMPLOT_API void PlotBarsH<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, int count, double height, int offset, int stride);
+template IMPLOT_API void PlotBarsH<float>(const char* label_id, const float* xs, const float* ys, int count, double height, int offset, int stride);
+template IMPLOT_API void PlotBarsH<double>(const char* label_id, const double* xs, const double* ys, int count, double height, int offset, int stride);
+
+// custom
+void PlotBarsHG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, double height, int offset) {
+ GetterFuncPtr getter(getter_func, data, count, offset);
+ PlotBarsHEx(label_id, getter, height);
+}
+
+//-----------------------------------------------------------------------------
+// PLOT ERROR BARS
+//-----------------------------------------------------------------------------
+
+template <typename Getter>
+void PlotErrorBarsEx(const char* label_id, const Getter& getter) {
+ if (BeginItem(label_id)) {
+ if (FitThisFrame()) {
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPointError e = getter(i);
+ FitPoint(ImPlotPoint(e.X , e.Y - e.Neg));
+ FitPoint(ImPlotPoint(e.X , e.Y + e.Pos ));
+ }
+ }
+ const ImPlotNextItemData& s = GetItemData();
+ ImDrawList& DrawList = *GetPlotDrawList();
+ const ImU32 col = ImGui::GetColorU32(s.Colors[ImPlotCol_ErrorBar]);
+ const bool rend_whisker = s.ErrorBarSize > 0;
+ const float half_whisker = s.ErrorBarSize * 0.5f;
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPointError e = getter(i);
+ ImVec2 p1 = PlotToPixels(e.X, e.Y - e.Neg);
+ ImVec2 p2 = PlotToPixels(e.X, e.Y + e.Pos);
+ DrawList.AddLine(p1,p2,col, s.ErrorBarWeight);
+ if (rend_whisker) {
+ DrawList.AddLine(p1 - ImVec2(half_whisker, 0), p1 + ImVec2(half_whisker, 0), col, s.ErrorBarWeight);
+ DrawList.AddLine(p2 - ImVec2(half_whisker, 0), p2 + ImVec2(half_whisker, 0), col, s.ErrorBarWeight);
+ }
+ }
+ EndItem();
+ }
+}
+
+template <typename T>
+void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset, int stride) {
+ GetterError<T> getter(xs, ys, err, err, count, offset, stride);
+ PlotErrorBarsEx(label_id, getter);
+}
+
+template IMPLOT_API void PlotErrorBars<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, const ImS8* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, const ImU8* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, const ImS16* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, const ImU16* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, const ImS32* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, const ImU32* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, const ImS64* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, const ImU64* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<float>(const char* label_id, const float* xs, const float* ys, const float* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<double>(const char* label_id, const double* xs, const double* ys, const double* err, int count, int offset, int stride);
+
+template <typename T>
+void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset, int stride) {
+ GetterError<T> getter(xs, ys, neg, pos, count, offset, stride);
+ PlotErrorBarsEx(label_id, getter);
+}
+
+template IMPLOT_API void PlotErrorBars<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, const ImS8* neg, const ImS8* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, const ImU8* neg, const ImU8* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, const ImS16* neg, const ImS16* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, const ImU16* neg, const ImU16* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, const ImS32* neg, const ImS32* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, const ImU32* neg, const ImU32* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, const ImS64* neg, const ImS64* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, const ImU64* neg, const ImU64* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<float>(const char* label_id, const float* xs, const float* ys, const float* neg, const float* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBars<double>(const char* label_id, const double* xs, const double* ys, const double* neg, const double* pos, int count, int offset, int stride);
+
+//-----------------------------------------------------------------------------
+// PLOT ERROR BARS H
+//-----------------------------------------------------------------------------
+
+template <typename Getter>
+void PlotErrorBarsHEx(const char* label_id, const Getter& getter) {
+ if (BeginItem(label_id)) {
+ if (FitThisFrame()) {
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPointError e = getter(i);
+ FitPoint(ImPlotPoint(e.X - e.Neg, e.Y));
+ FitPoint(ImPlotPoint(e.X + e.Pos, e.Y));
+ }
+ }
+ const ImPlotNextItemData& s = GetItemData();
+ ImDrawList& DrawList = *GetPlotDrawList();
+ const ImU32 col = ImGui::GetColorU32(s.Colors[ImPlotCol_ErrorBar]);
+ const bool rend_whisker = s.ErrorBarSize > 0;
+ const float half_whisker = s.ErrorBarSize * 0.5f;
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPointError e = getter(i);
+ ImVec2 p1 = PlotToPixels(e.X - e.Neg, e.Y);
+ ImVec2 p2 = PlotToPixels(e.X + e.Pos, e.Y);
+ DrawList.AddLine(p1, p2, col, s.ErrorBarWeight);
+ if (rend_whisker) {
+ DrawList.AddLine(p1 - ImVec2(0, half_whisker), p1 + ImVec2(0, half_whisker), col, s.ErrorBarWeight);
+ DrawList.AddLine(p2 - ImVec2(0, half_whisker), p2 + ImVec2(0, half_whisker), col, s.ErrorBarWeight);
+ }
+ }
+ EndItem();
+ }
+}
+
+template <typename T>
+void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset, int stride) {
+ GetterError<T> getter(xs, ys, err, err, count, offset, stride);
+ PlotErrorBarsHEx(label_id, getter);
+}
+
+template IMPLOT_API void PlotErrorBarsH<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, const ImS8* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, const ImU8* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, const ImS16* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, const ImU16* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, const ImS32* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, const ImU32* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, const ImS64* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, const ImU64* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<float>(const char* label_id, const float* xs, const float* ys, const float* err, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<double>(const char* label_id, const double* xs, const double* ys, const double* err, int count, int offset, int stride);
+
+template <typename T>
+void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset, int stride) {
+ GetterError<T> getter(xs, ys, neg, pos, count, offset, stride);
+ PlotErrorBarsHEx(label_id, getter);
+}
+
+template IMPLOT_API void PlotErrorBarsH<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, const ImS8* neg, const ImS8* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, const ImU8* neg, const ImU8* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, const ImS16* neg, const ImS16* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, const ImU16* neg, const ImU16* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, const ImS32* neg, const ImS32* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, const ImU32* neg, const ImU32* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, const ImS64* neg, const ImS64* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, const ImU64* neg, const ImU64* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<float>(const char* label_id, const float* xs, const float* ys, const float* neg, const float* pos, int count, int offset, int stride);
+template IMPLOT_API void PlotErrorBarsH<double>(const char* label_id, const double* xs, const double* ys, const double* neg, const double* pos, int count, int offset, int stride);
+
+//-----------------------------------------------------------------------------
+// PLOT STEMS
+//-----------------------------------------------------------------------------
+
+template <typename GetterM, typename GetterB>
+inline void PlotStemsEx(const char* label_id, const GetterM& get_mark, const GetterB& get_base) {
+ if (BeginItem(label_id, ImPlotCol_Line)) {
+ if (FitThisFrame()) {
+ for (int i = 0; i < get_base.Count; ++i) {
+ FitPoint(get_mark(i));
+ FitPoint(get_base(i));
+ }
+ }
+ const ImPlotNextItemData& s = GetItemData();
+ ImDrawList& DrawList = *GetPlotDrawList();
+ // render stems
+ if (s.RenderLine) {
+ const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderLineSegments(get_mark, get_base, TransformerLinLin(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LogLin: RenderLineSegments(get_mark, get_base, TransformerLogLin(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LinLog: RenderLineSegments(get_mark, get_base, TransformerLinLog(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LogLog: RenderLineSegments(get_mark, get_base, TransformerLogLog(), DrawList, s.LineWeight, col_line); break;
+ }
+ }
+ // render markers
+ ImPlotMarker marker = s.Marker == ImPlotMarker_None ? ImPlotMarker_Circle : s.Marker;
+ if (marker != ImPlotMarker_None) {
+ PopPlotClipRect();
+ PushPlotClipRect(s.MarkerSize);
+ const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
+ const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderMarkers(get_mark, TransformerLinLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LogLin: RenderMarkers(get_mark, TransformerLogLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LinLog: RenderMarkers(get_mark, TransformerLinLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ case ImPlotScale_LogLog: RenderMarkers(get_mark, TransformerLogLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
+ }
+ }
+ EndItem();
+ }
+}
+
+template <typename T>
+void PlotStems(const char* label_id, const T* values, int count, double y_ref, double xscale, double x0, int offset, int stride) {
+ GetterYs<T> get_mark(values,count,xscale,x0,offset,stride);
+ GetterYRef get_base(y_ref,count,xscale,x0);
+ PlotStemsEx(label_id, get_mark, get_base);
+}
+
+template IMPLOT_API void PlotStems<ImS8>(const char* label_id, const ImS8* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStems<ImU8>(const char* label_id, const ImU8* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStems<ImS16>(const char* label_id, const ImS16* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStems<ImU16>(const char* label_id, const ImU16* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStems<ImS32>(const char* label_id, const ImS32* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStems<ImU32>(const char* label_id, const ImU32* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStems<ImS64>(const char* label_id, const ImS64* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStems<ImU64>(const char* label_id, const ImU64* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStems<float>(const char* label_id, const float* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+template IMPLOT_API void PlotStems<double>(const char* label_id, const double* values, int count, double y_ref, double xscale, double x0, int offset, int stride);
+
+template <typename T>
+void PlotStems(const char* label_id, const T* xs, const T* ys, int count, double y_ref, int offset, int stride) {
+ GetterXsYs<T> get_mark(xs,ys,count,offset,stride);
+ GetterXsYRef<T> get_base(xs,y_ref,count,offset,stride);
+ PlotStemsEx(label_id, get_mark, get_base);
+}
+
+template IMPLOT_API void PlotStems<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotStems<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotStems<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotStems<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotStems<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotStems<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotStems<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotStems<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotStems<float>(const char* label_id, const float* xs, const float* ys, int count, double y_ref, int offset, int stride);
+template IMPLOT_API void PlotStems<double>(const char* label_id, const double* xs, const double* ys, int count, double y_ref, int offset, int stride);
+
+//-----------------------------------------------------------------------------
+// INFINITE LINES
+//-----------------------------------------------------------------------------
+
+template <typename T>
+void PlotVLines(const char* label_id, const T* xs, int count, int offset, int stride) {
+ if (BeginItem(label_id, ImPlotCol_Line)) {
+ const ImPlotLimits lims = GetPlotLimits();
+ GetterXsYRef<T> get_min(xs,lims.Y.Min,count,offset,stride);
+ GetterXsYRef<T> get_max(xs,lims.Y.Max,count,offset,stride);
+ if (FitThisFrame()) {
+ for (int i = 0; i < get_min.Count; ++i)
+ FitPointX(get_min(i).x);
+ }
+ const ImPlotNextItemData& s = GetItemData();
+ ImDrawList& DrawList = *GetPlotDrawList();
+ // render stems
+ if (s.RenderLine) {
+ const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderLineSegments(get_min, get_max, TransformerLinLin(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LogLin: RenderLineSegments(get_min, get_max, TransformerLogLin(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LinLog: RenderLineSegments(get_min, get_max, TransformerLinLog(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LogLog: RenderLineSegments(get_min, get_max, TransformerLogLog(), DrawList, s.LineWeight, col_line); break;
+ }
+ }
+ EndItem();
+ }
+}
+
+template IMPLOT_API void PlotVLines<ImS8>(const char* label_id, const ImS8* xs, int count, int offset, int stride);
+template IMPLOT_API void PlotVLines<ImU8>(const char* label_id, const ImU8* xs, int count, int offset, int stride);
+template IMPLOT_API void PlotVLines<ImS16>(const char* label_id, const ImS16* xs, int count, int offset, int stride);
+template IMPLOT_API void PlotVLines<ImU16>(const char* label_id, const ImU16* xs, int count, int offset, int stride);
+template IMPLOT_API void PlotVLines<ImS32>(const char* label_id, const ImS32* xs, int count, int offset, int stride);
+template IMPLOT_API void PlotVLines<ImU32>(const char* label_id, const ImU32* xs, int count, int offset, int stride);
+template IMPLOT_API void PlotVLines<ImS64>(const char* label_id, const ImS64* xs, int count, int offset, int stride);
+template IMPLOT_API void PlotVLines<ImU64>(const char* label_id, const ImU64* xs, int count, int offset, int stride);
+template IMPLOT_API void PlotVLines<float>(const char* label_id, const float* xs, int count, int offset, int stride);
+template IMPLOT_API void PlotVLines<double>(const char* label_id, const double* xs, int count, int offset, int stride);
+
+
+template <typename T>
+void PlotHLines(const char* label_id, const T* ys, int count, int offset, int stride) {
+ if (BeginItem(label_id, ImPlotCol_Line)) {
+ const ImPlotLimits lims = GetPlotLimits();
+ GetterXRefYs<T> get_min(lims.X.Min,ys,count,offset,stride);
+ GetterXRefYs<T> get_max(lims.X.Max,ys,count,offset,stride);
+ if (FitThisFrame()) {
+ for (int i = 0; i < get_min.Count; ++i)
+ FitPointY(get_min(i).y);
+ }
+ const ImPlotNextItemData& s = GetItemData();
+ ImDrawList& DrawList = *GetPlotDrawList();
+ // render stems
+ if (s.RenderLine) {
+ const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderLineSegments(get_min, get_max, TransformerLinLin(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LogLin: RenderLineSegments(get_min, get_max, TransformerLogLin(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LinLog: RenderLineSegments(get_min, get_max, TransformerLinLog(), DrawList, s.LineWeight, col_line); break;
+ case ImPlotScale_LogLog: RenderLineSegments(get_min, get_max, TransformerLogLog(), DrawList, s.LineWeight, col_line); break;
+ }
+ }
+ EndItem();
+ }
+}
+
+template IMPLOT_API void PlotHLines<ImS8>(const char* label_id, const ImS8* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotHLines<ImU8>(const char* label_id, const ImU8* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotHLines<ImS16>(const char* label_id, const ImS16* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotHLines<ImU16>(const char* label_id, const ImU16* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotHLines<ImS32>(const char* label_id, const ImS32* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotHLines<ImU32>(const char* label_id, const ImU32* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotHLines<ImS64>(const char* label_id, const ImS64* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotHLines<ImU64>(const char* label_id, const ImU64* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotHLines<float>(const char* label_id, const float* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotHLines<double>(const char* label_id, const double* ys, int count, int offset, int stride);
+
+//-----------------------------------------------------------------------------
+// PLOT PIE CHART
+//-----------------------------------------------------------------------------
+
+inline void RenderPieSlice(ImDrawList& DrawList, const ImPlotPoint& center, double radius, double a0, double a1, ImU32 col) {
+ static const float resolution = 50 / (2 * IM_PI);
+ static ImVec2 buffer[50];
+ buffer[0] = PlotToPixels(center);
+ int n = ImMax(3, (int)((a1 - a0) * resolution));
+ double da = (a1 - a0) / (n - 1);
+ for (int i = 0; i < n; ++i) {
+ double a = a0 + i * da;
+ buffer[i + 1] = PlotToPixels(center.x + radius * cos(a), center.y + radius * sin(a));
+ }
+ DrawList.AddConvexPolyFilled(buffer, n + 1, col);
+}
+
+template <typename T>
+void PlotPieChart(const char* const label_ids[], const T* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0) {
+ IM_ASSERT_USER_ERROR(GImPlot->CurrentPlot != NULL, "PlotPieChart() needs to be called between BeginPlot() and EndPlot()!");
+ ImDrawList & DrawList = *GetPlotDrawList();
+ double sum = 0;
+ for (int i = 0; i < count; ++i)
+ sum += (double)values[i];
+ normalize = normalize || sum > 1.0;
+ ImPlotPoint center(x,y);
+ PushPlotClipRect();
+ double a0 = angle0 * 2 * IM_PI / 360.0;
+ double a1 = angle0 * 2 * IM_PI / 360.0;
+ for (int i = 0; i < count; ++i) {
+ double percent = normalize ? (double)values[i] / sum : (double)values[i];
+ a1 = a0 + 2 * IM_PI * percent;
+ if (BeginItem(label_ids[i])) {
+ ImU32 col = GetCurrentItem()->Color;
+ if (percent < 0.5) {
+ RenderPieSlice(DrawList, center, radius, a0, a1, col);
+ }
+ else {
+ RenderPieSlice(DrawList, center, radius, a0, a0 + (a1 - a0) * 0.5, col);
+ RenderPieSlice(DrawList, center, radius, a0 + (a1 - a0) * 0.5, a1, col);
+ }
+ EndItem();
+ }
+ a0 = a1;
+ }
+ if (fmt != NULL) {
+ a0 = angle0 * 2 * IM_PI / 360.0;
+ a1 = angle0 * 2 * IM_PI / 360.0;
+ char buffer[32];
+ for (int i = 0; i < count; ++i) {
+ ImPlotItem* item = GetItem(label_ids[i]);
+ double percent = normalize ? (double)values[i] / sum : (double)values[i];
+ a1 = a0 + 2 * IM_PI * percent;
+ if (item->Show) {
+ sprintf(buffer, fmt, (double)values[i]);
+ ImVec2 size = ImGui::CalcTextSize(buffer);
+ double angle = a0 + (a1 - a0) * 0.5;
+ ImVec2 pos = PlotToPixels(center.x + 0.5 * radius * cos(angle), center.y + 0.5 * radius * sin(angle));
+ ImU32 col = CalcTextColor(ImGui::ColorConvertU32ToFloat4(item->Color));
+ DrawList.AddText(pos - size * 0.5f, col, buffer);
+ }
+ a0 = a1;
+ }
+ }
+ PopPlotClipRect();
+}
+
+template IMPLOT_API void PlotPieChart<ImS8>(const char* const label_ids[], const ImS8* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0);
+template IMPLOT_API void PlotPieChart<ImU8>(const char* const label_ids[], const ImU8* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0);
+template IMPLOT_API void PlotPieChart<ImS16>(const char* const label_ids[], const ImS16* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0);
+template IMPLOT_API void PlotPieChart<ImU16>(const char* const label_ids[], const ImU16* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0);
+template IMPLOT_API void PlotPieChart<ImS32>(const char* const label_ids[], const ImS32* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0);
+template IMPLOT_API void PlotPieChart<ImU32>(const char* const label_ids[], const ImU32* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0);
+template IMPLOT_API void PlotPieChart<ImS64>(const char* const label_ids[], const ImS64* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0);
+template IMPLOT_API void PlotPieChart<ImU64>(const char* const label_ids[], const ImU64* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0);
+template IMPLOT_API void PlotPieChart<float>(const char* const label_ids[], const float* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0);
+template IMPLOT_API void PlotPieChart<double>(const char* const label_ids[], const double* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0);
+
+//-----------------------------------------------------------------------------
+// PLOT HEATMAP
+//-----------------------------------------------------------------------------
+
+struct RectInfo {
+ ImPlotPoint Min, Max;
+ ImU32 Color;
+};
+
+template <typename TGetter, typename TTransformer>
+struct RectRenderer {
+ inline RectRenderer(const TGetter& getter, const TTransformer& transformer) :
+ Getter(getter),
+ Transformer(transformer),
+ Prims(Getter.Count)
+ {}
+ inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
+ RectInfo rect = Getter(prim);
+ ImVec2 P1 = Transformer(rect.Min);
+ ImVec2 P2 = Transformer(rect.Max);
+
+ if ((rect.Color & IM_COL32_A_MASK) == 0 || !cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2))))
+ return false;
+
+ DrawList._VtxWritePtr[0].pos = P1;
+ DrawList._VtxWritePtr[0].uv = uv;
+ DrawList._VtxWritePtr[0].col = rect.Color;
+ DrawList._VtxWritePtr[1].pos.x = P1.x;
+ DrawList._VtxWritePtr[1].pos.y = P2.y;
+ DrawList._VtxWritePtr[1].uv = uv;
+ DrawList._VtxWritePtr[1].col = rect.Color;
+ DrawList._VtxWritePtr[2].pos = P2;
+ DrawList._VtxWritePtr[2].uv = uv;
+ DrawList._VtxWritePtr[2].col = rect.Color;
+ DrawList._VtxWritePtr[3].pos.x = P2.x;
+ DrawList._VtxWritePtr[3].pos.y = P1.y;
+ DrawList._VtxWritePtr[3].uv = uv;
+ DrawList._VtxWritePtr[3].col = rect.Color;
+ DrawList._VtxWritePtr += 4;
+ DrawList._IdxWritePtr[0] = (ImDrawIdx)(DrawList._VtxCurrentIdx);
+ DrawList._IdxWritePtr[1] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 1);
+ DrawList._IdxWritePtr[2] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 3);
+ DrawList._IdxWritePtr[3] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 1);
+ DrawList._IdxWritePtr[4] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 2);
+ DrawList._IdxWritePtr[5] = (ImDrawIdx)(DrawList._VtxCurrentIdx + 3);
+ DrawList._IdxWritePtr += 6;
+ DrawList._VtxCurrentIdx += 4;
+ return true;
+ }
+ const TGetter& Getter;
+ const TTransformer& Transformer;
+ const int Prims;
+ static const int IdxConsumed = 6;
+ static const int VtxConsumed = 4;
+};
+
+template <typename T>
+struct GetterHeatmap {
+ GetterHeatmap(const T* values, int rows, int cols, double scale_min, double scale_max, double width, double height, double xref, double yref, double ydir) :
+ Values(values),
+ Count(rows*cols),
+ Rows(rows),
+ Cols(cols),
+ ScaleMin(scale_min),
+ ScaleMax(scale_max),
+ Width(width),
+ Height(height),
+ XRef(xref),
+ YRef(yref),
+ YDir(ydir),
+ HalfSize(Width*0.5, Height*0.5)
+ { }
+
+ inline RectInfo operator()(int idx) const {
+ double val = (double)Values[idx];
+ const int r = idx / Cols;
+ const int c = idx % Cols;
+ const ImPlotPoint p(XRef + HalfSize.x + c*Width, YRef + YDir * (HalfSize.y + r*Height));
+ RectInfo rect;
+ rect.Min.x = p.x - HalfSize.x;
+ rect.Min.y = p.y - HalfSize.y;
+ rect.Max.x = p.x + HalfSize.x;
+ rect.Max.y = p.y + HalfSize.y;
+ const float t = ImClamp((float)ImRemap01(val, ScaleMin, ScaleMax),0.0f,1.0f);
+ rect.Color = GImPlot->ColormapData.LerpTable(GImPlot->Style.Colormap, t);
+ return rect;
+ }
+ const T* const Values;
+ const int Count, Rows, Cols;
+ const double ScaleMin, ScaleMax, Width, Height, XRef, YRef, YDir;
+ const ImPlotPoint HalfSize;
+};
+
+template <typename T, typename Transformer>
+void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max, bool reverse_y) {
+ ImPlotContext& gp = *GImPlot;
+ if (scale_min == 0 && scale_max == 0) {
+ T temp_min, temp_max;
+ ImMinMaxArray(values,rows*cols,&temp_min,&temp_max);
+ scale_min = (double)temp_min;
+ scale_max = (double)temp_max;
+ }
+ if (scale_min == scale_max) {
+ ImVec2 a = transformer(bounds_min);
+ ImVec2 b = transformer(bounds_max);
+ ImU32 col = GetColormapColorU32(0,gp.Style.Colormap);
+ DrawList.AddRectFilled(a, b, col);
+ return;
+ }
+ const double yref = reverse_y ? bounds_max.y : bounds_min.y;
+ const double ydir = reverse_y ? -1 : 1;
+ GetterHeatmap<T> getter(values, rows, cols, scale_min, scale_max, (bounds_max.x - bounds_min.x) / cols, (bounds_max.y - bounds_min.y) / rows, bounds_min.x, yref, ydir);
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderPrimitives(RectRenderer<GetterHeatmap<T>, TransformerLinLin>(getter, TransformerLinLin()), DrawList, gp.CurrentPlot->PlotRect); break;
+ case ImPlotScale_LogLin: RenderPrimitives(RectRenderer<GetterHeatmap<T>, TransformerLogLin>(getter, TransformerLogLin()), DrawList, gp.CurrentPlot->PlotRect); break;;
+ case ImPlotScale_LinLog: RenderPrimitives(RectRenderer<GetterHeatmap<T>, TransformerLinLog>(getter, TransformerLinLog()), DrawList, gp.CurrentPlot->PlotRect); break;;
+ case ImPlotScale_LogLog: RenderPrimitives(RectRenderer<GetterHeatmap<T>, TransformerLogLog>(getter, TransformerLogLog()), DrawList, gp.CurrentPlot->PlotRect); break;;
+ }
+ if (fmt != NULL) {
+ const double w = (bounds_max.x - bounds_min.x) / cols;
+ const double h = (bounds_max.y - bounds_min.y) / rows;
+ const ImPlotPoint half_size(w*0.5,h*0.5);
+ int i = 0;
+ for (int r = 0; r < rows; ++r) {
+ for (int c = 0; c < cols; ++c) {
+ ImPlotPoint p;
+ p.x = bounds_min.x + 0.5*w + c*w;
+ p.y = yref + ydir * (0.5*h + r*h);
+ ImVec2 px = transformer(p);
+ char buff[32];
+ sprintf(buff, fmt, values[i]);
+ ImVec2 size = ImGui::CalcTextSize(buff);
+ double t = ImClamp(ImRemap01((double)values[i], scale_min, scale_max),0.0,1.0);
+ ImVec4 color = SampleColormap((float)t);
+ ImU32 col = CalcTextColor(color);
+ DrawList.AddText(px - size * 0.5f, col, buff);
+ i++;
+ }
+ }
+ }
+}
+
+template <typename T>
+void PlotHeatmap(const char* label_id, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
+ if (BeginItem(label_id)) {
+ if (FitThisFrame()) {
+ FitPoint(bounds_min);
+ FitPoint(bounds_max);
+ }
+ ImDrawList& DrawList = *GetPlotDrawList();
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderHeatmap(TransformerLinLin(), DrawList, values, rows, cols, scale_min, scale_max, fmt, bounds_min, bounds_max, true); break;
+ case ImPlotScale_LogLin: RenderHeatmap(TransformerLogLin(), DrawList, values, rows, cols, scale_min, scale_max, fmt, bounds_min, bounds_max, true); break;
+ case ImPlotScale_LinLog: RenderHeatmap(TransformerLinLog(), DrawList, values, rows, cols, scale_min, scale_max, fmt, bounds_min, bounds_max, true); break;
+ case ImPlotScale_LogLog: RenderHeatmap(TransformerLogLog(), DrawList, values, rows, cols, scale_min, scale_max, fmt, bounds_min, bounds_max, true); break;
+ }
+ EndItem();
+ }
+}
+
+template IMPLOT_API void PlotHeatmap<ImS8>(const char* label_id, const ImS8* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max);
+template IMPLOT_API void PlotHeatmap<ImU8>(const char* label_id, const ImU8* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max);
+template IMPLOT_API void PlotHeatmap<ImS16>(const char* label_id, const ImS16* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max);
+template IMPLOT_API void PlotHeatmap<ImU16>(const char* label_id, const ImU16* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max);
+template IMPLOT_API void PlotHeatmap<ImS32>(const char* label_id, const ImS32* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max);
+template IMPLOT_API void PlotHeatmap<ImU32>(const char* label_id, const ImU32* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max);
+template IMPLOT_API void PlotHeatmap<ImS64>(const char* label_id, const ImS64* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max);
+template IMPLOT_API void PlotHeatmap<ImU64>(const char* label_id, const ImU64* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max);
+template IMPLOT_API void PlotHeatmap<float>(const char* label_id, const float* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max);
+template IMPLOT_API void PlotHeatmap<double>(const char* label_id, const double* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max);
+
+//-----------------------------------------------------------------------------
+// PLOT HISTOGRAM
+//-----------------------------------------------------------------------------
+
+template <typename T>
+double PlotHistogram(const char* label_id, const T* values, int count, int bins, bool cumulative, bool density, ImPlotRange range, bool outliers, double bar_scale) {
+
+ if (count <= 0 || bins == 0)
+ return 0;
+
+ if (range.Min == 0 && range.Max == 0) {
+ T Min, Max;
+ ImMinMaxArray(values, count, &Min, &Max);
+ range.Min = (double)Min;
+ range.Max = (double)Max;
+ }
+
+ double width;
+ if (bins < 0)
+ CalculateBins(values, count, bins, range, bins, width);
+ else
+ width = range.Size() / bins;
+
+ ImVector<double>& bin_centers = GImPlot->Temp1;
+ ImVector<double>& bin_counts = GImPlot->Temp2;
+ bin_centers.resize(bins);
+ bin_counts.resize(bins);
+ int below = 0;
+
+ for (int b = 0; b < bins; ++b) {
+ bin_centers[b] = range.Min + b * width + width * 0.5;
+ bin_counts[b] = 0;
+ }
+ int counted = 0;
+ double max_count = 0;
+ for (int i = 0; i < count; ++i) {
+ double val = (double)values[i];
+ if (range.Contains(val)) {
+ const int b = ImClamp((int)((val - range.Min) / width), 0, bins - 1);
+ bin_counts[b] += 1.0;
+ if (bin_counts[b] > max_count)
+ max_count = bin_counts[b];
+ counted++;
+ }
+ else if (val < range.Min) {
+ below++;
+ }
+ }
+ if (cumulative && density) {
+ if (outliers)
+ bin_counts[0] += below;
+ for (int b = 1; b < bins; ++b)
+ bin_counts[b] += bin_counts[b-1];
+ double scale = 1.0 / (outliers ? count : counted);
+ for (int b = 0; b < bins; ++b)
+ bin_counts[b] *= scale;
+ max_count = bin_counts[bins-1];
+ }
+ else if (cumulative) {
+ if (outliers)
+ bin_counts[0] += below;
+ for (int b = 1; b < bins; ++b)
+ bin_counts[b] += bin_counts[b-1];
+ max_count = bin_counts[bins-1];
+ }
+ else if (density) {
+ double scale = 1.0 / ((outliers ? count : counted) * width);
+ for (int b = 0; b < bins; ++b)
+ bin_counts[b] *= scale;
+ max_count *= scale;
+ }
+ PlotBars(label_id, &bin_centers.Data[0], &bin_counts.Data[0], bins, bar_scale*width);
+ return max_count;
+}
+
+template IMPLOT_API double PlotHistogram<ImS8>(const char* label_id, const ImS8* values, int count, int bins, bool cumulative, bool density, ImPlotRange range, bool outliers, double bar_scale);
+template IMPLOT_API double PlotHistogram<ImU8>(const char* label_id, const ImU8* values, int count, int bins, bool cumulative, bool density, ImPlotRange range, bool outliers, double bar_scale);
+template IMPLOT_API double PlotHistogram<ImS16>(const char* label_id, const ImS16* values, int count, int bins, bool cumulative, bool density, ImPlotRange range, bool outliers, double bar_scale);
+template IMPLOT_API double PlotHistogram<ImU16>(const char* label_id, const ImU16* values, int count, int bins, bool cumulative, bool density, ImPlotRange range, bool outliers, double bar_scale);
+template IMPLOT_API double PlotHistogram<ImS32>(const char* label_id, const ImS32* values, int count, int bins, bool cumulative, bool density, ImPlotRange range, bool outliers, double bar_scale);
+template IMPLOT_API double PlotHistogram<ImU32>(const char* label_id, const ImU32* values, int count, int bins, bool cumulative, bool density, ImPlotRange range, bool outliers, double bar_scale);
+template IMPLOT_API double PlotHistogram<ImS64>(const char* label_id, const ImS64* values, int count, int bins, bool cumulative, bool density, ImPlotRange range, bool outliers, double bar_scale);
+template IMPLOT_API double PlotHistogram<ImU64>(const char* label_id, const ImU64* values, int count, int bins, bool cumulative, bool density, ImPlotRange range, bool outliers, double bar_scale);
+template IMPLOT_API double PlotHistogram<float>(const char* label_id, const float* values, int count, int bins, bool cumulative, bool density, ImPlotRange range, bool outliers, double bar_scale);
+template IMPLOT_API double PlotHistogram<double>(const char* label_id, const double* values, int count, int bins, bool cumulative, bool density, ImPlotRange range, bool outliers, double bar_scale);
+
+//-----------------------------------------------------------------------------
+// PLOT HISTOGRAM 2D
+//-----------------------------------------------------------------------------
+
+template <typename T>
+double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers) {
+
+ if (count <= 0 || x_bins == 0 || y_bins == 0)
+ return 0;
+
+ if (range.X.Min == 0 && range.X.Max == 0) {
+ T Min, Max;
+ ImMinMaxArray(xs, count, &Min, &Max);
+ range.X.Min = (double)Min;
+ range.X.Max = (double)Max;
+ }
+ if (range.Y.Min == 0 && range.Y.Max == 0) {
+ T Min, Max;
+ ImMinMaxArray(ys, count, &Min, &Max);
+ range.Y.Min = (double)Min;
+ range.Y.Max = (double)Max;
+ }
+
+ double width, height;
+ if (x_bins < 0)
+ CalculateBins(xs, count, x_bins, range.X, x_bins, width);
+ else
+ width = range.X.Size() / x_bins;
+ if (y_bins < 0)
+ CalculateBins(ys, count, y_bins, range.Y, y_bins, height);
+ else
+ height = range.Y.Size() / y_bins;
+
+ const int bins = x_bins * y_bins;
+
+ ImVector<double>& bin_counts = GImPlot->Temp1;
+ bin_counts.resize(bins);
+
+ for (int b = 0; b < bins; ++b)
+ bin_counts[b] = 0;
+
+ int counted = 0;
+ double max_count = 0;
+ for (int i = 0; i < count; ++i) {
+ if (range.Contains((double)xs[i], (double)ys[i])) {
+ const int xb = ImClamp( (int)((double)(xs[i] - range.X.Min) / width) , 0, x_bins - 1);
+ const int yb = ImClamp( (int)((double)(ys[i] - range.Y.Min) / height) , 0, y_bins - 1);
+ const int b = yb * x_bins + xb;
+ bin_counts[b] += 1.0;
+ if (bin_counts[b] > max_count)
+ max_count = bin_counts[b];
+ counted++;
+ }
+ }
+ if (density) {
+ double scale = 1.0 / ((outliers ? count : counted) * width * height);
+ for (int b = 0; b < bins; ++b)
+ bin_counts[b] *= scale;
+ max_count *= scale;
+ }
+
+ if (BeginItem(label_id)) {
+ if (FitThisFrame()) {
+ FitPoint(range.Min());
+ FitPoint(range.Max());
+ }
+ ImDrawList& DrawList = *GetPlotDrawList();
+ switch (GetCurrentScale()) {
+ case ImPlotScale_LinLin: RenderHeatmap(TransformerLinLin(), DrawList, &bin_counts.Data[0], y_bins, x_bins, 0, max_count, NULL, range.Min(), range.Max(), false); break;
+ case ImPlotScale_LogLin: RenderHeatmap(TransformerLogLin(), DrawList, &bin_counts.Data[0], y_bins, x_bins, 0, max_count, NULL, range.Min(), range.Max(), false); break;
+ case ImPlotScale_LinLog: RenderHeatmap(TransformerLinLog(), DrawList, &bin_counts.Data[0], y_bins, x_bins, 0, max_count, NULL, range.Min(), range.Max(), false); break;
+ case ImPlotScale_LogLog: RenderHeatmap(TransformerLogLog(), DrawList, &bin_counts.Data[0], y_bins, x_bins, 0, max_count, NULL, range.Min(), range.Max(), false); break;
+ }
+ EndItem();
+ }
+ return max_count;
+}
+
+template IMPLOT_API double PlotHistogram2D<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
+template IMPLOT_API double PlotHistogram2D<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
+template IMPLOT_API double PlotHistogram2D<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
+template IMPLOT_API double PlotHistogram2D<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
+template IMPLOT_API double PlotHistogram2D<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
+template IMPLOT_API double PlotHistogram2D<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
+template IMPLOT_API double PlotHistogram2D<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
+template IMPLOT_API double PlotHistogram2D<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
+template IMPLOT_API double PlotHistogram2D<float>(const char* label_id, const float* xs, const float* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
+template IMPLOT_API double PlotHistogram2D<double>(const char* label_id, const double* xs, const double* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
+
+//-----------------------------------------------------------------------------
+// PLOT DIGITAL
+//-----------------------------------------------------------------------------
+
+// TODO: Make this behave like all the other plot types (.e. not fixed in y axis)
+
+template <typename Getter>
+inline void PlotDigitalEx(const char* label_id, Getter getter) {
+ if (BeginItem(label_id, ImPlotCol_Fill)) {
+ ImPlotContext& gp = *GImPlot;
+ ImDrawList& DrawList = *GetPlotDrawList();
+ const ImPlotNextItemData& s = GetItemData();
+ if (getter.Count > 1 && s.RenderFill) {
+ const int y_axis = GetCurrentYAxis();
+ int pixYMax = 0;
+ ImPlotPoint itemData1 = getter(0);
+ for (int i = 0; i < getter.Count; ++i) {
+ ImPlotPoint itemData2 = getter(i);
+ if (ImNanOrInf(itemData1.y)) {
+ itemData1 = itemData2;
+ continue;
+ }
+ if (ImNanOrInf(itemData2.y)) itemData2.y = ImConstrainNan(ImConstrainInf(itemData2.y));
+ int pixY_0 = (int)(s.LineWeight);
+ itemData1.y = ImMax(0.0, itemData1.y);
+ float pixY_1_float = s.DigitalBitHeight * (float)itemData1.y;
+ int pixY_1 = (int)(pixY_1_float); //allow only positive values
+ int pixY_chPosOffset = (int)(ImMax(s.DigitalBitHeight, pixY_1_float) + s.DigitalBitGap);
+ pixYMax = ImMax(pixYMax, pixY_chPosOffset);
+ ImVec2 pMin = PlotToPixels(itemData1);
+ ImVec2 pMax = PlotToPixels(itemData2);
+ int pixY_Offset = 20; //20 pixel from bottom due to mouse cursor label
+ pMin.y = (gp.PixelRange[y_axis].Min.y) + ((-gp.DigitalPlotOffset) - pixY_Offset);
+ pMax.y = (gp.PixelRange[y_axis].Min.y) + ((-gp.DigitalPlotOffset) - pixY_0 - pixY_1 - pixY_Offset);
+ //plot only one rectangle for same digital state
+ while (((i+2) < getter.Count) && (itemData1.y == itemData2.y)) {
+ const int in = (i + 1);
+ itemData2 = getter(in);
+ if (ImNanOrInf(itemData2.y)) break;
+ pMax.x = PlotToPixels(itemData2).x;
+ i++;
+ }
+ //do not extend plot outside plot range
+ if (pMin.x < gp.PixelRange[y_axis].Min.x) pMin.x = gp.PixelRange[y_axis].Min.x;
+ if (pMax.x < gp.PixelRange[y_axis].Min.x) pMax.x = gp.PixelRange[y_axis].Min.x;
+ if (pMin.x > gp.PixelRange[y_axis].Max.x) pMin.x = gp.PixelRange[y_axis].Max.x;
+ if (pMax.x > gp.PixelRange[y_axis].Max.x) pMax.x = gp.PixelRange[y_axis].Max.x;
+ //plot a rectangle that extends up to x2 with y1 height
+ if ((pMax.x > pMin.x) && (gp.CurrentPlot->PlotRect.Contains(pMin) || gp.CurrentPlot->PlotRect.Contains(pMax))) {
+ // ImVec4 colAlpha = item->Color;
+ // colAlpha.w = item->Highlight ? 1.0f : 0.9f;
+ DrawList.AddRectFilled(pMin, pMax, ImGui::GetColorU32(s.Colors[ImPlotCol_Fill]));
+ }
+ itemData1 = itemData2;
+ }
+ gp.DigitalPlotItemCnt++;
+ gp.DigitalPlotOffset += pixYMax;
+ }
+ EndItem();
+ }
+}
+
+
+template <typename T>
+void PlotDigital(const char* label_id, const T* xs, const T* ys, int count, int offset, int stride) {
+ GetterXsYs<T> getter(xs,ys,count,offset,stride);
+ return PlotDigitalEx(label_id, getter);
+}
+
+template IMPLOT_API void PlotDigital<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotDigital<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotDigital<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotDigital<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotDigital<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotDigital<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotDigital<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotDigital<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotDigital<float>(const char* label_id, const float* xs, const float* ys, int count, int offset, int stride);
+template IMPLOT_API void PlotDigital<double>(const char* label_id, const double* xs, const double* ys, int count, int offset, int stride);
+
+// custom
+void PlotDigitalG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, int offset) {
+ GetterFuncPtr getter(getter_func,data,count,offset);
+ return PlotDigitalEx(label_id, getter);
+}
+
+//-----------------------------------------------------------------------------
+// PLOT IMAGE
+//-----------------------------------------------------------------------------
+
+void PlotImage(const char* label_id, ImTextureID user_texture_id, const ImPlotPoint& bmin, const ImPlotPoint& bmax, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& tint_col) {
+ if (BeginItem(label_id)) {
+ if (FitThisFrame()) {
+ FitPoint(bmin);
+ FitPoint(bmax);
+ }
+ ImU32 tint_col32 = ImGui::ColorConvertFloat4ToU32(tint_col);
+ GetCurrentItem()->Color = tint_col32;
+ ImDrawList& DrawList = *GetPlotDrawList();
+ ImVec2 p1 = PlotToPixels(bmin.x, bmax.y);
+ ImVec2 p2 = PlotToPixels(bmax.x, bmin.y);
+ PushPlotClipRect();
+ DrawList.AddImage(user_texture_id, p1, p2, uv0, uv1, tint_col32);
+ PopPlotClipRect();
+ EndItem();
+ }
+}
+
+//-----------------------------------------------------------------------------
+// PLOT TEXT
+//-----------------------------------------------------------------------------
+
+// double
+void PlotText(const char* text, double x, double y, bool vertical, const ImVec2& pixel_offset) {
+ IM_ASSERT_USER_ERROR(GImPlot->CurrentPlot != NULL, "PlotText() needs to be called between BeginPlot() and EndPlot()!");
+ ImDrawList & DrawList = *GetPlotDrawList();
+ PushPlotClipRect();
+ ImU32 colTxt = GetStyleColorU32(ImPlotCol_InlayText);
+ if (vertical) {
+ ImVec2 ctr = CalcTextSizeVertical(text) * 0.5f;
+ ImVec2 pos = PlotToPixels(ImPlotPoint(x,y)) + ImVec2(-ctr.x, ctr.y) + pixel_offset;
+ AddTextVertical(&DrawList, pos, colTxt, text);
+ }
+ else {
+ ImVec2 pos = PlotToPixels(ImPlotPoint(x,y)) - ImGui::CalcTextSize(text) * 0.5f + pixel_offset;
+ DrawList.AddText(pos, colTxt, text);
+ }
+ PopPlotClipRect();
+}
+
+//-----------------------------------------------------------------------------
+// PLOT DUMMY
+//-----------------------------------------------------------------------------
+
+void PlotDummy(const char* label_id) {
+ if (BeginItem(label_id, ImPlotCol_Line))
+ EndItem();
+}
+
+} // namespace ImPlot \ No newline at end of file
generated by cgit v1.2.3-70-g09d2 (git 2.50.1) at 2025-08-21 16:37:37 +0000