2451 lines
109 KiB
C++
2451 lines
109 KiB
C++
// MIT License
|
|
|
|
// Copyright (c) 2022 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.14
|
|
|
|
// We define this so that the demo does not accidentally use deprecated API
|
|
#ifndef IMPLOT_DISABLE_OBSOLETE_FUNCTIONS
|
|
#define IMPLOT_DISABLE_OBSOLETE_FUNCTIONS
|
|
#endif
|
|
|
|
#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
|
|
|
|
#define CHECKBOX_FLAG(flags, flag) ImGui::CheckboxFlags(#flag, (unsigned int*)&flags, flag)
|
|
|
|
// 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(int idx, void* wave_data);
|
|
ImPlotPoint SawWave(int idx, void* wave_data);
|
|
ImPlotPoint Spiral(int idx, void* wave_data);
|
|
|
|
// 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 {
|
|
|
|
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;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// [SECTION] Demo Functions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_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("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();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ButtonSelector(const char* label, ImGuiMouseButton* b) {
|
|
ImGui::PushID(label);
|
|
if (ImGui::RadioButton("LMB",*b == ImGuiMouseButton_Left))
|
|
*b = ImGuiMouseButton_Left;
|
|
ImGui::SameLine();
|
|
if (ImGui::RadioButton("RMB",*b == ImGuiMouseButton_Right))
|
|
*b = ImGuiMouseButton_Right;
|
|
ImGui::SameLine();
|
|
if (ImGui::RadioButton("MMB",*b == ImGuiMouseButton_Middle))
|
|
*b = ImGuiMouseButton_Middle;
|
|
ImGui::PopID();
|
|
}
|
|
|
|
void ModSelector(const char* label, ImGuiModFlags* k) {
|
|
ImGui::PushID(label);
|
|
ImGui::CheckboxFlags("Ctrl", (unsigned int*)k, ImGuiModFlags_Ctrl); ImGui::SameLine();
|
|
ImGui::CheckboxFlags("Shift", (unsigned int*)k, ImGuiModFlags_Shift); ImGui::SameLine();
|
|
ImGui::CheckboxFlags("Alt", (unsigned int*)k, ImGuiModFlags_Alt); ImGui::SameLine();
|
|
ImGui::CheckboxFlags("Super", (unsigned int*)k, ImGuiModFlags_Super);
|
|
ImGui::PopID();
|
|
}
|
|
|
|
void InputMapping(const char* label, ImGuiMouseButton* b, ImGuiModFlags* k) {
|
|
ImGui::LabelText("##","%s",label);
|
|
if (b != NULL) {
|
|
ImGui::SameLine(100);
|
|
ButtonSelector(label,b);
|
|
}
|
|
if (k != NULL) {
|
|
ImGui::SameLine(300);
|
|
ModSelector(label,k);
|
|
}
|
|
}
|
|
|
|
void ShowInputMapping() {
|
|
ImPlotInputMap& map = ImPlot::GetInputMap();
|
|
InputMapping("Pan",&map.Pan,&map.PanMod);
|
|
InputMapping("Fit",&map.Fit,NULL);
|
|
InputMapping("Select",&map.Select,&map.SelectMod);
|
|
InputMapping("SelectHorzMod",NULL,&map.SelectHorzMod);
|
|
InputMapping("SelectVertMod",NULL,&map.SelectVertMod);
|
|
InputMapping("SelectCancel",&map.SelectCancel,NULL);
|
|
InputMapping("Menu",&map.Menu,NULL);
|
|
InputMapping("OverrideMod",NULL,&map.OverrideMod);
|
|
InputMapping("ZoomMod",NULL,&map.ZoomMod);
|
|
ImGui::SliderFloat("ZoomRate",&map.ZoomRate,-1,1);
|
|
}
|
|
|
|
void Demo_Config() {
|
|
ImGui::ShowFontSelector("Font");
|
|
ImGui::ShowStyleSelector("ImGui Style");
|
|
ImPlot::ShowStyleSelector("ImPlot Style");
|
|
ImPlot::ShowColormapSelector("ImPlot Colormap");
|
|
ImPlot::ShowInputMapSelector("Input Map");
|
|
ImGui::Separator();
|
|
ImGui::Checkbox("Use Local Time", &ImPlot::GetStyle().UseLocalTime);
|
|
ImGui::Checkbox("Use ISO 8601", &ImPlot::GetStyle().UseISO8601);
|
|
ImGui::Checkbox("Use 24 Hour Clock", &ImPlot::GetStyle().Use24HourClock);
|
|
ImGui::Separator();
|
|
if (ImPlot::BeginPlot("Preview")) {
|
|
static double now = (double)time(0);
|
|
ImPlot::SetupAxisScale(ImAxis_X1, ImPlotScale_Time);
|
|
ImPlot::SetupAxisLimits(ImAxis_X1, now, now + 24*3600);
|
|
for (int i = 0; i < 10; ++i) {
|
|
double x[2] = {now, now + 24*3600};
|
|
double y[2] = {0,i/9.0};
|
|
ImGui::PushID(i);
|
|
ImPlot::PlotLine("##Line",x,y,2);
|
|
ImGui::PopID();
|
|
}
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_LinePlots() {
|
|
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)ImGui::GetTime() / 10));
|
|
}
|
|
static double xs2[20], ys2[20];
|
|
for (int i = 0; i < 20; ++i) {
|
|
xs2[i] = i * 1/19.0f;
|
|
ys2[i] = xs2[i] * xs2[i];
|
|
}
|
|
if (ImPlot::BeginPlot("Line Plots")) {
|
|
ImPlot::SetupAxes("x","y");
|
|
ImPlot::PlotLine("f(x)", xs1, ys1, 1001);
|
|
ImPlot::SetNextMarkerStyle(ImPlotMarker_Circle);
|
|
ImPlot::PlotLine("g(x)", xs2, ys2, 20,ImPlotLineFlags_Segments);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_FilledLinePlots() {
|
|
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;
|
|
static ImPlotShadedFlags flags = 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);
|
|
}
|
|
}
|
|
|
|
if (ImPlot::BeginPlot("Stock Prices")) {
|
|
ImPlot::SetupAxes("Days","Price");
|
|
ImPlot::SetupAxesLimits(0,100,0,500);
|
|
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, flags);
|
|
ImPlot::PlotShaded("Stock 2", xs1, ys2, 101, shade_mode == 0 ? -INFINITY : shade_mode == 1 ? INFINITY : fill_ref, flags);
|
|
ImPlot::PlotShaded("Stock 3", xs1, ys3, 101, shade_mode == 0 ? -INFINITY : shade_mode == 1 ? INFINITY : fill_ref, flags);
|
|
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();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_ShadedPlots() {
|
|
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")) {
|
|
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();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_ScatterPlots() {
|
|
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")) {
|
|
ImPlot::PlotScatter("Data 1", xs1, ys1, 100);
|
|
ImPlot::PushStyleVar(ImPlotStyleVar_FillAlpha, 0.25f);
|
|
ImPlot::SetNextMarkerStyle(ImPlotMarker_Square, 6, ImPlot::GetColormapColor(1), IMPLOT_AUTO, ImPlot::GetColormapColor(1));
|
|
ImPlot::PlotScatter("Data 2", xs2, ys2, 50);
|
|
ImPlot::PopStyleVar();
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_StairstepPlots() {
|
|
static float ys1[21], ys2[21];
|
|
for (int i = 0; i < 21; ++i) {
|
|
ys1[i] = 0.75f + 0.2f * sinf(10 * i * 0.05f);
|
|
ys2[i] = 0.25f + 0.2f * sinf(10 * i * 0.05f);
|
|
}
|
|
static ImPlotStairsFlags flags = 0;
|
|
CHECKBOX_FLAG(flags, ImPlotStairsFlags_Shaded);
|
|
if (ImPlot::BeginPlot("Stairstep Plot")) {
|
|
ImPlot::SetupAxes("x","f(x)");
|
|
ImPlot::SetupAxesLimits(0,1,0,1);
|
|
|
|
ImPlot::PushStyleColor(ImPlotCol_Line, ImVec4(0.5f,0.5f,0.5f,1.0f));
|
|
ImPlot::PlotLine("##1",ys1,21,0.05f);
|
|
ImPlot::PlotLine("##2",ys2,21,0.05f);
|
|
ImPlot::PopStyleColor();
|
|
|
|
ImPlot::SetNextMarkerStyle(ImPlotMarker_Circle);
|
|
ImPlot::SetNextFillStyle(IMPLOT_AUTO_COL, 0.25f);
|
|
ImPlot::PlotStairs("Post Step (default)", ys1, 21, 0.05f, 0, flags);
|
|
ImPlot::SetNextMarkerStyle(ImPlotMarker_Circle);
|
|
ImPlot::SetNextFillStyle(IMPLOT_AUTO_COL, 0.25f);
|
|
ImPlot::PlotStairs("Pre Step", ys2, 21, 0.05f, 0, flags|ImPlotStairsFlags_PreStep);
|
|
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_BarPlots() {
|
|
static ImS8 data[10] = {1,2,3,4,5,6,7,8,9,10};
|
|
if (ImPlot::BeginPlot("Bar Plot")) {
|
|
ImPlot::PlotBars("Vertical",data,10,0.7,1);
|
|
ImPlot::PlotBars("Horizontal",data,10,0.4,1,ImPlotBarsFlags_Horizontal);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_BarGroups() {
|
|
static ImS8 data[30] = {83, 67, 23, 89, 83, 78, 91, 82, 85, 90, // midterm
|
|
80, 62, 56, 99, 55, 78, 88, 78, 90, 100, // final
|
|
80, 69, 52, 92, 72, 78, 75, 76, 89, 95}; // course
|
|
|
|
static const char* ilabels[] = {"Midterm Exam","Final Exam","Course Grade"};
|
|
static const char* glabels[] = {"S1","S2","S3","S4","S5","S6","S7","S8","S9","S10"};
|
|
static const double positions[] = {0,1,2,3,4,5,6,7,8,9};
|
|
|
|
static int items = 3;
|
|
static int groups = 10;
|
|
static float size = 0.67f;
|
|
|
|
static ImPlotBarGroupsFlags flags = 0;
|
|
static bool horz = false;
|
|
|
|
ImGui::CheckboxFlags("Stacked", (unsigned int*)&flags, ImPlotBarGroupsFlags_Stacked);
|
|
ImGui::SameLine();
|
|
ImGui::Checkbox("Horizontal",&horz);
|
|
|
|
ImGui::SliderInt("Items",&items,1,3);
|
|
ImGui::SliderFloat("Size",&size,0,1);
|
|
|
|
if (ImPlot::BeginPlot("Bar Group")) {
|
|
ImPlot::SetupLegend(ImPlotLocation_East, ImPlotLegendFlags_Outside);
|
|
if (horz) {
|
|
ImPlot::SetupAxes("Score","Student",ImPlotAxisFlags_AutoFit,ImPlotAxisFlags_AutoFit);
|
|
ImPlot::SetupAxisTicks(ImAxis_Y1,positions, groups, glabels);
|
|
ImPlot::PlotBarGroups(ilabels,data,items,groups,size,0,flags|ImPlotBarGroupsFlags_Horizontal);
|
|
}
|
|
else {
|
|
ImPlot::SetupAxes("Student","Score",ImPlotAxisFlags_AutoFit,ImPlotAxisFlags_AutoFit);
|
|
ImPlot::SetupAxisTicks(ImAxis_X1,positions, groups, glabels);
|
|
ImPlot::PlotBarGroups(ilabels,data,items,groups,size,0,flags);
|
|
}
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_BarStacks() {
|
|
|
|
static ImPlotColormap Liars = -1;
|
|
if (Liars == -1) {
|
|
static const ImU32 Liars_Data[6] = { 4282515870, 4282609140, 4287357182, 4294630301, 4294945280, 4294921472 };
|
|
Liars = ImPlot::AddColormap("Liars", Liars_Data, 6);
|
|
}
|
|
|
|
static bool diverging = true;
|
|
ImGui::Checkbox("Diverging",&diverging);
|
|
|
|
static const char* politicians[] = {"Trump","Bachman","Cruz","Gingrich","Palin","Santorum","Walker","Perry","Ryan","McCain","Rubio","Romney","Rand Paul","Christie","Biden","Kasich","Sanders","J Bush","H Clinton","Obama"};
|
|
static int data_reg[] = {18,26,7,14,10,8,6,11,4,4,3,8,6,8,6,5,0,3,1,2, // Pants on Fire
|
|
43,36,30,21,30,27,25,17,11,22,15,16,16,17,12,12,14,6,13,12, // False
|
|
16,13,28,22,15,21,15,18,30,17,24,18,13,10,14,15,17,22,14,12, // Mostly False
|
|
17,10,13,25,12,22,19,26,23,17,22,27,20,26,29,17,18,22,21,27, // Half True
|
|
5,7,16,10,10,12,23,13,17,20,22,16,23,19,20,26,36,29,27,26, // Mostly True
|
|
1,8,6,8,23,10,12,15,15,20,14,15,22,20,19,25,15,18,24,21}; // True
|
|
static const char* labels_reg[] = {"Pants on Fire","False","Mostly False","Half True","Mostly True","True"};
|
|
|
|
|
|
static int data_div[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // Pants on Fire (dummy, to order legend logically)
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // False (dummy, to order legend logically)
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // Mostly False (dummy, to order legend logically)
|
|
-16,-13,-28,-22,-15,-21,-15,-18,-30,-17,-24,-18,-13,-10,-14,-15,-17,-22,-14,-12, // Mostly False
|
|
-43,-36,-30,-21,-30,-27,-25,-17,-11,-22,-15,-16,-16,-17,-12,-12,-14,-6,-13,-12, // False
|
|
-18,-26,-7,-14,-10,-8,-6,-11,-4,-4,-3,-8,-6,-8,-6,-5,0,-3,-1,-2, // Pants on Fire
|
|
17,10,13,25,12,22,19,26,23,17,22,27,20,26,29,17,18,22,21,27, // Half True
|
|
5,7,16,10,10,12,23,13,17,20,22,16,23,19,20,26,36,29,27,26, // Mostly True
|
|
1,8,6,8,23,10,12,15,15,20,14,15,22,20,19,25,15,18,24,21}; // True
|
|
static const char* labels_div[] = {"Pants on Fire","False","Mostly False","Mostly False","False","Pants on Fire","Half True","Mostly True","True"};
|
|
|
|
ImPlot::PushColormap(Liars);
|
|
if (ImPlot::BeginPlot("PolitiFact: Who Lies More?",ImVec2(-1,400),ImPlotFlags_NoMouseText)) {
|
|
ImPlot::SetupLegend(ImPlotLocation_South, ImPlotLegendFlags_Outside|ImPlotLegendFlags_Horizontal);
|
|
ImPlot::SetupAxes(NULL,NULL,ImPlotAxisFlags_AutoFit|ImPlotAxisFlags_NoDecorations,ImPlotAxisFlags_AutoFit|ImPlotAxisFlags_Invert);
|
|
ImPlot::SetupAxisTicks(ImAxis_Y1,0,19,20,politicians,false);
|
|
if (diverging)
|
|
ImPlot::PlotBarGroups(labels_div,data_div,9,20,0.75,0,ImPlotBarGroupsFlags_Stacked|ImPlotBarGroupsFlags_Horizontal);
|
|
else
|
|
ImPlot::PlotBarGroups(labels_reg,data_reg,6,20,0.75,0,ImPlotBarGroupsFlags_Stacked|ImPlotBarGroupsFlags_Horizontal);
|
|
ImPlot::EndPlot();
|
|
}
|
|
ImPlot::PopColormap();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_ErrorBars() {
|
|
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};
|
|
|
|
|
|
if (ImPlot::BeginPlot("##ErrorBars")) {
|
|
ImPlot::SetupAxesLimits(0, 6, 0, 10);
|
|
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_Square);
|
|
ImPlot::PlotLine("Line", xs, lin1, 5);
|
|
ImPlot::PushStyleColor(ImPlotCol_ErrorBar, ImPlot::GetColormapColor(2));
|
|
ImPlot::PlotErrorBars("Scatter", xs, lin2, err2, 5);
|
|
ImPlot::PlotErrorBars("Scatter", xs, lin2, err3, err4, 5, ImPlotErrorBarsFlags_Horizontal);
|
|
ImPlot::PopStyleColor();
|
|
ImPlot::PlotScatter("Scatter", xs, lin2, 5);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_StemPlots() {
|
|
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]);
|
|
}
|
|
if (ImPlot::BeginPlot("Stem Plots")) {
|
|
ImPlot::SetupAxisLimits(ImAxis_X1,0,1.0);
|
|
ImPlot::SetupAxisLimits(ImAxis_Y1,0,1.6);
|
|
ImPlot::PlotStems("Stems 1",xs,ys1,51);
|
|
ImPlot::SetNextMarkerStyle(ImPlotMarker_Circle);
|
|
ImPlot::PlotStems("Stems 2", xs, ys2,51);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_InfiniteLines() {
|
|
static double vals[] = {0.25, 0.5, 0.75};
|
|
if (ImPlot::BeginPlot("##Infinite")) {
|
|
ImPlot::SetupAxes(NULL,NULL,ImPlotAxisFlags_NoInitialFit,ImPlotAxisFlags_NoInitialFit);
|
|
ImPlot::PlotInfLines("Vertical",vals,3);
|
|
ImPlot::PlotInfLines("Horizontal",vals,3,ImPlotInfLinesFlags_Horizontal);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_PieCharts() {
|
|
static const char* labels1[] = {"Frogs","Hogs","Dogs","Logs"};
|
|
static float data1[] = {0.15f, 0.30f, 0.2f, 0.05f};
|
|
static ImPlotPieChartFlags flags = 0;
|
|
ImGui::SetNextItemWidth(250);
|
|
ImGui::DragFloat4("Values", data1, 0.01f, 0, 1);
|
|
if ((data1[0] + data1[1] + data1[2] + data1[3]) < 1) {
|
|
ImGui::SameLine();
|
|
CHECKBOX_FLAG(flags,ImPlotPieChartFlags_Normalize);
|
|
}
|
|
|
|
if (ImPlot::BeginPlot("##Pie1", ImVec2(250,250), ImPlotFlags_Equal | ImPlotFlags_NoMouseText)) {
|
|
ImPlot::SetupAxes(NULL, NULL, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations);
|
|
ImPlot::SetupAxesLimits(0, 1, 0, 1);
|
|
ImPlot::PlotPieChart(labels1, data1, 4, 0.5, 0.5, 0.4, "%.2f", 90, flags);
|
|
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);
|
|
if (ImPlot::BeginPlot("##Pie2", ImVec2(250,250), ImPlotFlags_Equal | ImPlotFlags_NoMouseText)) {
|
|
ImPlot::SetupAxes(NULL, NULL, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations);
|
|
ImPlot::SetupAxesLimits(0, 1, 0, 1);
|
|
ImPlot::PlotPieChart(labels2, data2, 5, 0.5, 0.5, 0.4, "%.0f", 180, flags);
|
|
ImPlot::EndPlot();
|
|
}
|
|
ImPlot::PopColormap();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_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 ImPlotHeatmapFlags hm_flags = 0;
|
|
|
|
ImGui::CheckboxFlags("Column Major", (unsigned int*)&hm_flags, ImPlotHeatmapFlags_ColMajor);
|
|
|
|
static ImPlotAxisFlags axes_flags = ImPlotAxisFlags_Lock | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoTickMarks;
|
|
|
|
ImPlot::PushColormap(map);
|
|
|
|
if (ImPlot::BeginPlot("##Heatmap1",ImVec2(225,225),ImPlotFlags_NoLegend|ImPlotFlags_NoMouseText)) {
|
|
ImPlot::SetupAxes(NULL, NULL, axes_flags, axes_flags);
|
|
ImPlot::SetupAxisTicks(ImAxis_X1,0 + 1.0/14.0, 1 - 1.0/14.0, 7, xlabels);
|
|
ImPlot::SetupAxisTicks(ImAxis_Y1,1 - 1.0/14.0, 0 + 1.0/14.0, 7, ylabels);
|
|
ImPlot::PlotHeatmap("heat",values1[0],7,7,scale_min,scale_max,"%g",ImPlotPoint(0,0),ImPlotPoint(1,1),hm_flags);
|
|
ImPlot::EndPlot();
|
|
}
|
|
ImGui::SameLine();
|
|
ImPlot::ColormapScale("##HeatScale",scale_min, scale_max, ImVec2(60,225));
|
|
|
|
ImGui::SameLine();
|
|
|
|
const int size = 80;
|
|
static double values2[size*size];
|
|
srand((unsigned int)(ImGui::GetTime()*1000000));
|
|
for (int i = 0; i < size*size; ++i)
|
|
values2[i] = RandomRange(0.0,1.0);
|
|
|
|
if (ImPlot::BeginPlot("##Heatmap2",ImVec2(225,225))) {
|
|
ImPlot::SetupAxes(NULL, NULL, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations);
|
|
ImPlot::SetupAxesLimits(-1,1,-1,1);
|
|
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();
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_Histogram() {
|
|
static ImPlotHistogramFlags hist_flags = ImPlotHistogramFlags_Density;
|
|
static int bins = 50;
|
|
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);
|
|
}
|
|
ImGui::CheckboxFlags("Horizontal", (unsigned int*)&hist_flags, ImPlotHistogramFlags_Horizontal);
|
|
ImGui::SameLine();
|
|
ImGui::CheckboxFlags("Density", (unsigned int*)&hist_flags, ImPlotHistogramFlags_Density);
|
|
ImGui::SameLine();
|
|
ImGui::CheckboxFlags("Cumulative", (unsigned int*)&hist_flags, ImPlotHistogramFlags_Cumulative);
|
|
|
|
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::CheckboxFlags("Exclude Outliers", (unsigned int*)&hist_flags, ImPlotHistogramFlags_NoOutliers);
|
|
}
|
|
static NormalDistribution<10000> dist(mu, sigma);
|
|
static double x[100];
|
|
static double y[100];
|
|
if (hist_flags & ImPlotHistogramFlags_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 (hist_flags & ImPlotHistogramFlags_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::SetupAxes(NULL,NULL,ImPlotAxisFlags_AutoFit,ImPlotAxisFlags_AutoFit);
|
|
ImPlot::SetNextFillStyle(IMPLOT_AUTO_COL,0.5f);
|
|
ImPlot::PlotHistogram("Empirical", dist.Data, 10000, bins, 1.0, range ? ImPlotRange(rmin,rmax) : ImPlotRange(), hist_flags);
|
|
if ((hist_flags & ImPlotHistogramFlags_Density) && !(hist_flags & ImPlotHistogramFlags_NoOutliers)) {
|
|
if (hist_flags & ImPlotHistogramFlags_Horizontal)
|
|
ImPlot::PlotLine("Theoretical",y,x,100);
|
|
else
|
|
ImPlot::PlotLine("Theoretical",x,y,100);
|
|
}
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_Histogram2D() {
|
|
static int count = 50000;
|
|
static int xybins[2] = {100,100};
|
|
|
|
static ImPlotHistogramFlags hist_flags = 0;
|
|
|
|
ImGui::SliderInt("Count",&count,100,100000);
|
|
ImGui::SliderInt2("Bins",xybins,1,500);
|
|
ImGui::SameLine();
|
|
ImGui::CheckboxFlags("Density", (unsigned int*)&hist_flags, ImPlotHistogramFlags_Density);
|
|
|
|
static NormalDistribution<100000> dist1(1, 2);
|
|
static NormalDistribution<100000> dist2(1, 1);
|
|
double max_count = 0;
|
|
ImPlotAxisFlags flags = ImPlotAxisFlags_AutoFit|ImPlotAxisFlags_Foreground;
|
|
ImPlot::PushColormap("Hot");
|
|
if (ImPlot::BeginPlot("##Hist2D",ImVec2(ImGui::GetContentRegionAvail().x-100-ImGui::GetStyle().ItemSpacing.x,0))) {
|
|
ImPlot::SetupAxes(NULL, NULL, flags, flags);
|
|
ImPlot::SetupAxesLimits(-6,6,-6,6);
|
|
max_count = ImPlot::PlotHistogram2D("Hist2D",dist1.Data,dist2.Data,count,xybins[0],xybins[1],ImPlotRect(-6,6,-6,6), hist_flags);
|
|
ImPlot::EndPlot();
|
|
}
|
|
ImGui::SameLine();
|
|
ImPlot::ColormapScale(hist_flags & ImPlotHistogramFlags_Density ? "Density" : "Count",0,max_count,ImVec2(100,0));
|
|
ImPlot::PopColormap();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_DigitalPlots() {
|
|
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));
|
|
}
|
|
if (ImPlot::BeginPlot("##Digital")) {
|
|
ImPlot::SetupAxisLimits(ImAxis_X1, t - 10.0, t, paused ? ImGuiCond_Once : ImGuiCond_Always);
|
|
ImPlot::SetupAxisLimits(ImAxis_Y1, -1, 1);
|
|
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(), 0, 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(), 0, dataAnalog[i].Offset, 2 * sizeof(float));
|
|
}
|
|
}
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_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();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_RealtimePlots() {
|
|
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;
|
|
|
|
if (ImPlot::BeginPlot("##Scrolling", ImVec2(-1,150))) {
|
|
ImPlot::SetupAxes(NULL, NULL, flags, flags);
|
|
ImPlot::SetupAxisLimits(ImAxis_X1,t - history, t, ImGuiCond_Always);
|
|
ImPlot::SetupAxisLimits(ImAxis_Y1,0,1);
|
|
ImPlot::SetNextFillStyle(IMPLOT_AUTO_COL,0.5f);
|
|
ImPlot::PlotShaded("Mouse X", &sdata1.Data[0].x, &sdata1.Data[0].y, sdata1.Data.size(), -INFINITY, 0, sdata1.Offset, 2 * sizeof(float));
|
|
ImPlot::PlotLine("Mouse Y", &sdata2.Data[0].x, &sdata2.Data[0].y, sdata2.Data.size(), 0, sdata2.Offset, 2*sizeof(float));
|
|
ImPlot::EndPlot();
|
|
}
|
|
if (ImPlot::BeginPlot("##Rolling", ImVec2(-1,150))) {
|
|
ImPlot::SetupAxes(NULL, NULL, flags, flags);
|
|
ImPlot::SetupAxisLimits(ImAxis_X1,0,history, ImGuiCond_Always);
|
|
ImPlot::SetupAxisLimits(ImAxis_Y1,0,1);
|
|
ImPlot::PlotLine("Mouse X", &rdata1.Data[0].x, &rdata1.Data[0].y, rdata1.Data.size(), 0, 0, 2 * sizeof(float));
|
|
ImPlot::PlotLine("Mouse Y", &rdata2.Data[0].x, &rdata2.Data[0].y, rdata2.Data.size(), 0, 0, 2 * sizeof(float));
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_MarkersAndText() {
|
|
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");
|
|
|
|
if (ImPlot::BeginPlot("##MarkerStyles", ImVec2(-1,0), ImPlotFlags_CanvasOnly)) {
|
|
|
|
ImPlot::SetupAxes(NULL, NULL, ImPlotAxisFlags_NoDecorations, ImPlotAxisFlags_NoDecorations);
|
|
ImPlot::SetupAxesLimits(0, 10, 0, 12);
|
|
|
|
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, ImVec2(0,0), ImPlotTextFlags_Vertical);
|
|
ImPlot::PopStyleColor();
|
|
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_NaNValues() {
|
|
|
|
static bool include_nan = true;
|
|
static ImPlotLineFlags flags = 0;
|
|
|
|
float data1[5] = {0.0f,0.25f,0.5f,0.75f,1.0f};
|
|
float data2[5] = {0.0f,0.25f,0.5f,0.75f,1.0f};
|
|
|
|
if (include_nan)
|
|
data1[2] = NAN;
|
|
|
|
ImGui::Checkbox("Include NaN",&include_nan);
|
|
ImGui::SameLine();
|
|
ImGui::CheckboxFlags("Skip NaN", (unsigned int*)&flags, ImPlotLineFlags_SkipNaN);
|
|
|
|
if (ImPlot::BeginPlot("##NaNValues")) {
|
|
ImPlot::SetNextMarkerStyle(ImPlotMarker_Square);
|
|
ImPlot::PlotLine("line", data1, data2, 5, flags);
|
|
ImPlot::PlotBars("bars", data1, 5);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_LogScale() {
|
|
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]);
|
|
}
|
|
if (ImPlot::BeginPlot("Log Plot", ImVec2(-1,0))) {
|
|
ImPlot::SetupAxisScale(ImAxis_X1, ImPlotScale_Log10);
|
|
ImPlot::SetupAxesLimits(0.1, 100, 0, 10);
|
|
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();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_SymmetricLogScale() {
|
|
static double xs[1001], ys1[1001], ys2[1001];
|
|
for (int i = 0; i < 1001; ++i) {
|
|
xs[i] = i*0.1f-50;
|
|
ys1[i] = sin(xs[i]);
|
|
ys2[i] = i*0.002 - 1;
|
|
}
|
|
if (ImPlot::BeginPlot("SymLog Plot", ImVec2(-1,0))) {
|
|
ImPlot::SetupAxisScale(ImAxis_X1, ImPlotScale_SymLog);
|
|
ImPlot::PlotLine("f(x) = a*x+b",xs,ys2,1001);
|
|
ImPlot::PlotLine("f(x) = sin(x)",xs,ys1,1001);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_TimeScale() {
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
if (ImPlot::BeginPlot("##Time", ImVec2(-1,0))) {
|
|
ImPlot::SetupAxisScale(ImAxis_X1, ImPlotScale_Time);
|
|
ImPlot::SetupAxesLimits(t_min,t_max,0,1);
|
|
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, 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::Annotation(t_now,y_now,ImPlot::GetLastItemColor(),ImVec2(10,10),false,"Now");
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static inline double TransformForward_Sqrt(double v, void*) {
|
|
return sqrt(v);
|
|
}
|
|
|
|
static inline double TransformInverse_Sqrt(double v, void*) {
|
|
return v*v;
|
|
}
|
|
|
|
void Demo_CustomScale() {
|
|
static float v[100];
|
|
for (int i = 0; i < 100; ++i) {
|
|
v[i] = i*0.01f;
|
|
}
|
|
if (ImPlot::BeginPlot("Sqrt")) {
|
|
ImPlot::SetupAxis(ImAxis_X1, "Linear");
|
|
ImPlot::SetupAxis(ImAxis_Y1, "Sqrt");
|
|
ImPlot::SetupAxisScale(ImAxis_Y1, TransformForward_Sqrt, TransformInverse_Sqrt);
|
|
ImPlot::SetupAxisLimitsConstraints(ImAxis_Y1, 0, INFINITY);
|
|
ImPlot::PlotLine("##data",v,v,100);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_MultipleAxes() {
|
|
static float xs[1001], xs2[1001], ys1[1001], ys2[1001], ys3[1001];
|
|
for (int i = 0; i < 1001; ++i) {
|
|
xs[i] = (i*0.1f);
|
|
xs2[i] = xs[i] + 10.0f;
|
|
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;
|
|
}
|
|
|
|
static bool x2_axis = true;
|
|
static bool y2_axis = true;
|
|
static bool y3_axis = true;
|
|
|
|
ImGui::Checkbox("X-Axis 2", &x2_axis);
|
|
ImGui::SameLine();
|
|
ImGui::Checkbox("Y-Axis 2", &y2_axis);
|
|
ImGui::SameLine();
|
|
ImGui::Checkbox("Y-Axis 3", &y3_axis);
|
|
|
|
ImGui::BulletText("You can drag axes to the opposite side of the plot.");
|
|
ImGui::BulletText("Hover over legend items to see which axis they are plotted on.");
|
|
|
|
if (ImPlot::BeginPlot("Multi-Axis Plot", ImVec2(-1,0))) {
|
|
ImPlot::SetupAxes("X-Axis 1", "Y-Axis 1");
|
|
ImPlot::SetupAxesLimits(0, 100, 0, 10);
|
|
if (x2_axis) {
|
|
ImPlot::SetupAxis(ImAxis_X2, "X-Axis 2",ImPlotAxisFlags_AuxDefault);
|
|
ImPlot::SetupAxisLimits(ImAxis_X2, 0, 100);
|
|
}
|
|
if (y2_axis) {
|
|
ImPlot::SetupAxis(ImAxis_Y2, "Y-Axis 2",ImPlotAxisFlags_AuxDefault);
|
|
ImPlot::SetupAxisLimits(ImAxis_Y2, 0, 1);
|
|
}
|
|
if (y3_axis) {
|
|
ImPlot::SetupAxis(ImAxis_Y3, "Y-Axis 3",ImPlotAxisFlags_AuxDefault);
|
|
ImPlot::SetupAxisLimits(ImAxis_Y3, 0, 300);
|
|
}
|
|
|
|
ImPlot::PlotLine("f(x) = x", xs, xs, 1001);
|
|
if (x2_axis) {
|
|
ImPlot::SetAxes(ImAxis_X2, ImAxis_Y1);
|
|
ImPlot::PlotLine("f(x) = sin(x)*3+1", xs2, ys1, 1001);
|
|
}
|
|
if (y2_axis) {
|
|
ImPlot::SetAxes(ImAxis_X1, ImAxis_Y2);
|
|
ImPlot::PlotLine("f(x) = cos(x)*.2+.5", xs, ys2, 1001);
|
|
}
|
|
if (y3_axis) {
|
|
ImPlot::SetAxes(ImAxis_X2, ImAxis_Y3);
|
|
ImPlot::PlotLine("f(x) = sin(x+.5)*100+200 ", xs2, ys3, 1001);
|
|
}
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_LinkedAxes() {
|
|
static ImPlotRect lims(0,1,0,1);
|
|
static bool linkx = true, linky = true;
|
|
int data[2] = {0,1};
|
|
ImGui::Checkbox("Link X", &linkx);
|
|
ImGui::SameLine();
|
|
ImGui::Checkbox("Link Y", &linky);
|
|
|
|
ImGui::DragScalarN("Limits",ImGuiDataType_Double,&lims.X.Min,4,0.01f);
|
|
|
|
if (BeginAlignedPlots("AlignedGroup")) {
|
|
if (ImPlot::BeginPlot("Plot A")) {
|
|
ImPlot::SetupAxisLinks(ImAxis_X1, linkx ? &lims.X.Min : NULL, linkx ? &lims.X.Max : NULL);
|
|
ImPlot::SetupAxisLinks(ImAxis_Y1, linky ? &lims.Y.Min : NULL, linky ? &lims.Y.Max : NULL);
|
|
ImPlot::PlotLine("Line",data,2);
|
|
ImPlot::EndPlot();
|
|
}
|
|
if (ImPlot::BeginPlot("Plot B")) {
|
|
ImPlot::SetupAxisLinks(ImAxis_X1, linkx ? &lims.X.Min : NULL, linkx ? &lims.X.Max : NULL);
|
|
ImPlot::SetupAxisLinks(ImAxis_Y1, linky ? &lims.Y.Min : NULL, linky ? &lims.Y.Max : NULL);
|
|
ImPlot::PlotLine("Line",data,2);
|
|
ImPlot::EndPlot();
|
|
}
|
|
ImPlot::EndAlignedPlots();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_AxisConstraints() {
|
|
static float constraints[4] = {-10,10,1,20};
|
|
static ImPlotAxisFlags flags;
|
|
ImGui::DragFloat2("Limits Constraints", &constraints[0], 0.01f);
|
|
ImGui::DragFloat2("Zoom Constraints", &constraints[2], 0.01f);
|
|
CHECKBOX_FLAG(flags, ImPlotAxisFlags_PanStretch);
|
|
if (ImPlot::BeginPlot("##AxisConstraints",ImVec2(-1,0))) {
|
|
ImPlot::SetupAxes("X","Y",flags,flags);
|
|
ImPlot::SetupAxesLimits(-1,1,-1,1);
|
|
ImPlot::SetupAxisLimitsConstraints(ImAxis_X1,constraints[0], constraints[1]);
|
|
ImPlot::SetupAxisZoomConstraints(ImAxis_X1,constraints[2], constraints[3]);
|
|
ImPlot::SetupAxisLimitsConstraints(ImAxis_Y1,constraints[0], constraints[1]);
|
|
ImPlot::SetupAxisZoomConstraints(ImAxis_Y1,constraints[2], constraints[3]);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_EqualAxes() {
|
|
ImGui::BulletText("Equal constraint applies to axis pairs (e.g ImAxis_X1/Y1, ImAxis_X2/Y2)");
|
|
static double xs1[360], ys1[360];
|
|
for (int i = 0; i < 360; ++i) {
|
|
double angle = i * 2 * PI / 359.0;
|
|
xs1[i] = cos(angle); ys1[i] = sin(angle);
|
|
}
|
|
float xs2[] = {-1,0,1,0,-1};
|
|
float ys2[] = {0,1,0,-1,0};
|
|
if (ImPlot::BeginPlot("##EqualAxes",ImVec2(-1,0),ImPlotFlags_Equal)) {
|
|
ImPlot::SetupAxis(ImAxis_X2, NULL, ImPlotAxisFlags_AuxDefault);
|
|
ImPlot::SetupAxis(ImAxis_Y2, NULL, ImPlotAxisFlags_AuxDefault);
|
|
ImPlot::PlotLine("Circle",xs1,ys1,360);
|
|
ImPlot::SetAxes(ImAxis_X2, ImAxis_Y2);
|
|
ImPlot::PlotLine("Diamond",xs2,ys2,5);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_AutoFittingData() {
|
|
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")) {
|
|
ImPlot::SetupAxes("X","Y",xflags,yflags);
|
|
ImPlot::PlotLine("Line",data,101);
|
|
ImPlot::PlotStems("Stems",data,101);
|
|
ImPlot::EndPlot();
|
|
};
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ImPlotPoint SinewaveGetter(int i, void* data) {
|
|
float f = *(float*)data;
|
|
return ImPlotPoint(i,sinf(f*i));
|
|
}
|
|
|
|
void Demo_SubplotsSizing() {
|
|
|
|
static ImPlotSubplotFlags flags = ImPlotSubplotFlags_None;
|
|
ImGui::CheckboxFlags("ImPlotSubplotFlags_NoResize", (unsigned int*)&flags, ImPlotSubplotFlags_NoResize);
|
|
ImGui::CheckboxFlags("ImPlotSubplotFlags_NoTitle", (unsigned int*)&flags, ImPlotSubplotFlags_NoTitle);
|
|
|
|
static int rows = 3;
|
|
static int cols = 3;
|
|
ImGui::SliderInt("Rows",&rows,1,5);
|
|
ImGui::SliderInt("Cols",&cols,1,5);
|
|
static float rratios[] = {5,1,1,1,1,1};
|
|
static float cratios[] = {5,1,1,1,1,1};
|
|
ImGui::DragScalarN("Row Ratios",ImGuiDataType_Float,rratios,rows,0.01f,0);
|
|
ImGui::DragScalarN("Col Ratios",ImGuiDataType_Float,cratios,cols,0.01f,0);
|
|
if (ImPlot::BeginSubplots("My Subplots", rows, cols, ImVec2(-1,400), flags, rratios, cratios)) {
|
|
for (int i = 0; i < rows*cols; ++i) {
|
|
if (ImPlot::BeginPlot("",ImVec2(),ImPlotFlags_NoLegend)) {
|
|
ImPlot::SetupAxes(NULL,NULL,ImPlotAxisFlags_NoDecorations,ImPlotAxisFlags_NoDecorations);
|
|
float fi = 0.01f * (i+1);
|
|
ImPlot::SetNextLineStyle(SampleColormap((float)i/(float)(rows*cols-1),ImPlotColormap_Jet));
|
|
ImPlot::PlotLineG("data",SinewaveGetter,&fi,1000);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
ImPlot::EndSubplots();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_SubplotItemSharing() {
|
|
static ImPlotSubplotFlags flags = ImPlotSubplotFlags_ShareItems;
|
|
ImGui::CheckboxFlags("ImPlotSubplotFlags_ShareItems", (unsigned int*)&flags, ImPlotSubplotFlags_ShareItems);
|
|
ImGui::CheckboxFlags("ImPlotSubplotFlags_ColMajor", (unsigned int*)&flags, ImPlotSubplotFlags_ColMajor);
|
|
ImGui::BulletText("Drag and drop items from the legend onto plots (except for 'common')");
|
|
static int rows = 2;
|
|
static int cols = 3;
|
|
static int id[] = {0,1,2,3,4,5};
|
|
static int curj = -1;
|
|
if (ImPlot::BeginSubplots("##ItemSharing", rows, cols, ImVec2(-1,400), flags)) {
|
|
for (int i = 0; i < rows*cols; ++i) {
|
|
if (ImPlot::BeginPlot("")) {
|
|
float fc = 0.01f;
|
|
ImPlot::PlotLineG("common",SinewaveGetter,&fc,1000);
|
|
for (int j = 0; j < 6; ++j) {
|
|
if (id[j] == i) {
|
|
char label[8];
|
|
float fj = 0.01f * (j+2);
|
|
sprintf(label, "data%d", j);
|
|
ImPlot::PlotLineG(label,SinewaveGetter,&fj,1000);
|
|
if (ImPlot::BeginDragDropSourceItem(label)) {
|
|
curj = j;
|
|
ImGui::SetDragDropPayload("MY_DND",NULL,0);
|
|
ImPlot::ItemIcon(GetLastItemColor()); ImGui::SameLine();
|
|
ImGui::TextUnformatted(label);
|
|
ImPlot::EndDragDropSource();
|
|
}
|
|
}
|
|
}
|
|
if (ImPlot::BeginDragDropTargetPlot()) {
|
|
if (ImGui::AcceptDragDropPayload("MY_DND"))
|
|
id[curj] = i;
|
|
ImPlot::EndDragDropTarget();
|
|
}
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
ImPlot::EndSubplots();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_SubplotAxisLinking() {
|
|
static ImPlotSubplotFlags flags = ImPlotSubplotFlags_LinkRows | ImPlotSubplotFlags_LinkCols;
|
|
ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkRows", (unsigned int*)&flags, ImPlotSubplotFlags_LinkRows);
|
|
ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkCols", (unsigned int*)&flags, ImPlotSubplotFlags_LinkCols);
|
|
ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkAllX", (unsigned int*)&flags, ImPlotSubplotFlags_LinkAllX);
|
|
ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkAllY", (unsigned int*)&flags, ImPlotSubplotFlags_LinkAllY);
|
|
|
|
static int rows = 2;
|
|
static int cols = 2;
|
|
if (ImPlot::BeginSubplots("##AxisLinking", rows, cols, ImVec2(-1,400), flags)) {
|
|
for (int i = 0; i < rows*cols; ++i) {
|
|
if (ImPlot::BeginPlot("")) {
|
|
ImPlot::SetupAxesLimits(0,1000,-1,1);
|
|
float fc = 0.01f;
|
|
ImPlot::PlotLineG("common",SinewaveGetter,&fc,1000);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
ImPlot::EndSubplots();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_LegendOptions() {
|
|
static ImPlotLocation loc = ImPlotLocation_East;
|
|
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);
|
|
|
|
static ImPlotLegendFlags flags = 0;
|
|
|
|
CHECKBOX_FLAG(flags, ImPlotLegendFlags_Horizontal);
|
|
CHECKBOX_FLAG(flags, ImPlotLegendFlags_Outside);
|
|
CHECKBOX_FLAG(flags, ImPlotLegendFlags_Sort);
|
|
|
|
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",ImVec2(-1,0))) {
|
|
ImPlot::SetupLegend(loc, flags);
|
|
static MyImPlot::WaveData data1(0.001, 0.2, 4, 0.2);
|
|
static MyImPlot::WaveData data2(0.001, 0.2, 4, 0.4);
|
|
static MyImPlot::WaveData data3(0.001, 0.2, 4, 0.6);
|
|
static MyImPlot::WaveData data4(0.001, 0.2, 4, 0.8);
|
|
static MyImPlot::WaveData data5(0.001, 0.2, 4, 1.0);
|
|
|
|
ImPlot::PlotLineG("Item B", MyImPlot::SawWave, &data1, 1000); // "Item B" added to legend
|
|
ImPlot::PlotLineG("Item A##IDText", MyImPlot::SawWave, &data2, 1000); // "Item A" 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 C", MyImPlot::SawWave, &data4, 1000); // "Item C" added to legend
|
|
ImPlot::PlotLineG("Item C", MyImPlot::SawWave, &data5, 1000); // combined with previous "Item C"
|
|
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_DragPoints() {
|
|
ImGui::BulletText("Click and drag each point.");
|
|
static ImPlotDragToolFlags flags = ImPlotDragToolFlags_None;
|
|
ImGui::CheckboxFlags("NoCursors", (unsigned int*)&flags, ImPlotDragToolFlags_NoCursors); ImGui::SameLine();
|
|
ImGui::CheckboxFlags("NoFit", (unsigned int*)&flags, ImPlotDragToolFlags_NoFit); ImGui::SameLine();
|
|
ImGui::CheckboxFlags("NoInput", (unsigned int*)&flags, ImPlotDragToolFlags_NoInputs);
|
|
ImPlotAxisFlags ax_flags = ImPlotAxisFlags_NoTickLabels | ImPlotAxisFlags_NoTickMarks;
|
|
if (ImPlot::BeginPlot("##Bezier",ImVec2(-1,0),ImPlotFlags_CanvasOnly)) {
|
|
ImPlot::SetupAxes(0,0,ax_flags,ax_flags);
|
|
ImPlot::SetupAxesLimits(0,1,0,1);
|
|
static ImPlotPoint P[] = {ImPlotPoint(.05f,.05f), ImPlotPoint(0.2,0.4), ImPlotPoint(0.8,0.6), ImPlotPoint(.95f,.95f)};
|
|
|
|
ImPlot::DragPoint(0,&P[0].x,&P[0].y, ImVec4(0,0.9f,0,1),4,flags);
|
|
ImPlot::DragPoint(1,&P[1].x,&P[1].y, ImVec4(1,0.5f,1,1),4,flags);
|
|
ImPlot::DragPoint(2,&P[2].x,&P[2].y, ImVec4(0,0.5f,1,1),4,flags);
|
|
ImPlot::DragPoint(3,&P[3].x,&P[3].y, ImVec4(0,0.9f,0,1),4,flags);
|
|
|
|
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(1,0.5f,1,1));
|
|
ImPlot::PlotLine("##h1",&P[0].x, &P[0].y, 2, 0, 0, sizeof(ImPlotPoint));
|
|
ImPlot::SetNextLineStyle(ImVec4(0,0.5f,1,1));
|
|
ImPlot::PlotLine("##h2",&P[2].x, &P[2].y, 2, 0, 0, sizeof(ImPlotPoint));
|
|
ImPlot::SetNextLineStyle(ImVec4(0,0.9f,0,1), 2);
|
|
ImPlot::PlotLine("##bez",&B[0].x, &B[0].y, 100, 0, 0, sizeof(ImPlotPoint));
|
|
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_DragLines() {
|
|
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 ImPlotDragToolFlags flags = ImPlotDragToolFlags_None;
|
|
ImGui::CheckboxFlags("NoCursors", (unsigned int*)&flags, ImPlotDragToolFlags_NoCursors); ImGui::SameLine();
|
|
ImGui::CheckboxFlags("NoFit", (unsigned int*)&flags, ImPlotDragToolFlags_NoFit); ImGui::SameLine();
|
|
ImGui::CheckboxFlags("NoInput", (unsigned int*)&flags, ImPlotDragToolFlags_NoInputs);
|
|
if (ImPlot::BeginPlot("##lines",ImVec2(-1,0))) {
|
|
ImPlot::SetupAxesLimits(0,1,0,1);
|
|
ImPlot::DragLineX(0,&x1,ImVec4(1,1,1,1),1,flags);
|
|
ImPlot::DragLineX(1,&x2,ImVec4(1,1,1,1),1,flags);
|
|
ImPlot::DragLineY(2,&y1,ImVec4(1,1,1,1),1,flags);
|
|
ImPlot::DragLineY(3,&y2,ImVec4(1,1,1,1),1,flags);
|
|
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::DragLineY(120482,&f,ImVec4(1,0.5f,1,1),1,flags);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_DragRects() {
|
|
|
|
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("Click and drag the edges, corners, and center of the rect.");
|
|
static ImPlotRect rect(0.0025,0.0045,0,0.5);
|
|
static ImPlotDragToolFlags flags = ImPlotDragToolFlags_None;
|
|
ImGui::CheckboxFlags("NoCursors", (unsigned int*)&flags, ImPlotDragToolFlags_NoCursors); ImGui::SameLine();
|
|
ImGui::CheckboxFlags("NoFit", (unsigned int*)&flags, ImPlotDragToolFlags_NoFit); ImGui::SameLine();
|
|
ImGui::CheckboxFlags("NoInput", (unsigned int*)&flags, ImPlotDragToolFlags_NoInputs);
|
|
|
|
if (ImPlot::BeginPlot("##Main",ImVec2(-1,150))) {
|
|
ImPlot::SetupAxes(NULL,NULL,ImPlotAxisFlags_NoTickLabels,ImPlotAxisFlags_NoTickLabels);
|
|
ImPlot::SetupAxesLimits(0,0.01,-1,1);
|
|
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::DragRect(0,&rect.X.Min,&rect.Y.Min,&rect.X.Max,&rect.Y.Max,ImVec4(1,0,1,1),flags);
|
|
ImPlot::EndPlot();
|
|
}
|
|
if (ImPlot::BeginPlot("##rect",ImVec2(-1,150), ImPlotFlags_CanvasOnly)) {
|
|
ImPlot::SetupAxes(NULL,NULL,ImPlotAxisFlags_NoDecorations,ImPlotAxisFlags_NoDecorations);
|
|
ImPlot::SetupAxesLimits(rect.X.Min, rect.X.Max, rect.Y.Min, rect.Y.Max, ImGuiCond_Always);
|
|
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();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ImPlotPoint FindCentroid(const ImVector<ImPlotPoint>& data, const ImPlotRect& bounds, int& cnt) {
|
|
cnt = 0;
|
|
ImPlotPoint avg;
|
|
ImPlotRect bounds_fixed;
|
|
bounds_fixed.X.Min = bounds.X.Min < bounds.X.Max ? bounds.X.Min : bounds.X.Max;
|
|
bounds_fixed.X.Max = bounds.X.Min < bounds.X.Max ? bounds.X.Max : bounds.X.Min;
|
|
bounds_fixed.Y.Min = bounds.Y.Min < bounds.Y.Max ? bounds.Y.Min : bounds.Y.Max;
|
|
bounds_fixed.Y.Max = bounds.Y.Min < bounds.Y.Max ? bounds.Y.Max : bounds.Y.Min;
|
|
for (int i = 0; i < data.size(); ++i) {
|
|
if (bounds_fixed.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;
|
|
}
|
|
return avg;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_Querying() {
|
|
static ImVector<ImPlotPoint> data;
|
|
static ImVector<ImPlotRect> rects;
|
|
static ImPlotRect limits, select;
|
|
static bool init = true;
|
|
if (init) {
|
|
for (int i = 0; i < 50; ++i)
|
|
{
|
|
double x = RandomRange(0.1, 0.9);
|
|
double y = RandomRange(0.1, 0.9);
|
|
data.push_back(ImPlotPoint(x,y));
|
|
}
|
|
init = false;
|
|
}
|
|
|
|
ImGui::BulletText("Box select and left click mouse to create a new query rect.");
|
|
ImGui::BulletText("Ctrl + click in the plot area to draw points.");
|
|
|
|
if (ImGui::Button("Clear Queries"))
|
|
rects.shrink(0);
|
|
|
|
if (ImPlot::BeginPlot("##Centroid")) {
|
|
ImPlot::SetupAxesLimits(0,1,0,1);
|
|
if (ImPlot::IsPlotHovered() && ImGui::IsMouseClicked(0) && ImGui::GetIO().KeyCtrl) {
|
|
ImPlotPoint pt = ImPlot::GetPlotMousePos();
|
|
data.push_back(pt);
|
|
}
|
|
ImPlot::PlotScatter("Points", &data[0].x, &data[0].y, data.size(), 0, 0, 2 * sizeof(double));
|
|
if (ImPlot::IsPlotSelected()) {
|
|
select = ImPlot::GetPlotSelection();
|
|
int cnt;
|
|
ImPlotPoint centroid = FindCentroid(data,select,cnt);
|
|
if (cnt > 0) {
|
|
ImPlot::SetNextMarkerStyle(ImPlotMarker_Square,6);
|
|
ImPlot::PlotScatter("Centroid", ¢roid.x, ¢roid.y, 1);
|
|
}
|
|
if (ImGui::IsMouseClicked(ImPlot::GetInputMap().SelectCancel)) {
|
|
CancelPlotSelection();
|
|
rects.push_back(select);
|
|
}
|
|
}
|
|
for (int i = 0; i < rects.size(); ++i) {
|
|
int cnt;
|
|
ImPlotPoint centroid = FindCentroid(data,rects[i],cnt);
|
|
if (cnt > 0) {
|
|
ImPlot::SetNextMarkerStyle(ImPlotMarker_Square,6);
|
|
ImPlot::PlotScatter("Centroid", ¢roid.x, ¢roid.y, 1);
|
|
}
|
|
ImPlot::DragRect(i,&rects[i].X.Min,&rects[i].Y.Min,&rects[i].X.Max,&rects[i].Y.Max,ImVec4(1,0,1,1));
|
|
}
|
|
limits = ImPlot::GetPlotLimits();
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_Annotations() {
|
|
static bool clamp = false;
|
|
ImGui::Checkbox("Clamp",&clamp);
|
|
if (ImPlot::BeginPlot("##Annotations")) {
|
|
ImPlot::SetupAxesLimits(0,2,0,1);
|
|
static float p[] = {0.25f, 0.25f, 0.75f, 0.75f, 0.25f};
|
|
ImPlot::PlotScatter("##Points",&p[0],&p[1],4);
|
|
ImVec4 col = GetLastItemColor();
|
|
ImPlot::Annotation(0.25,0.25,col,ImVec2(-15,15),clamp,"BL");
|
|
ImPlot::Annotation(0.75,0.25,col,ImVec2(15,15),clamp,"BR");
|
|
ImPlot::Annotation(0.75,0.75,col,ImVec2(15,-15),clamp,"TR");
|
|
ImPlot::Annotation(0.25,0.75,col,ImVec2(-15,-15),clamp,"TL");
|
|
ImPlot::Annotation(0.5,0.5,col,ImVec2(0,0),clamp,"Center");
|
|
|
|
ImPlot::Annotation(1.25,0.75,ImVec4(0,1,0,1),ImVec2(0,0),clamp);
|
|
|
|
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::Annotation(bx[i],by[i],ImVec4(0,0,0,0),ImVec2(0,-5),clamp,"B[%d]=%.2f",i,by[i]);
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_Tags() {
|
|
static bool show = true;
|
|
ImGui::Checkbox("Show Tags",&show);
|
|
if (ImPlot::BeginPlot("##Tags")) {
|
|
ImPlot::SetupAxis(ImAxis_X2);
|
|
ImPlot::SetupAxis(ImAxis_Y2);
|
|
if (show) {
|
|
ImPlot::TagX(0.25, ImVec4(1,1,0,1));
|
|
ImPlot::TagY(0.75, ImVec4(1,1,0,1));
|
|
static double drag_tag = 0.25;
|
|
ImPlot::DragLineY(0,&drag_tag,ImVec4(1,0,0,1),1,ImPlotDragToolFlags_NoFit);
|
|
ImPlot::TagY(drag_tag, ImVec4(1,0,0,1), "Drag");
|
|
SetAxes(ImAxis_X2, ImAxis_Y2);
|
|
ImPlot::TagX(0.5, ImVec4(0,1,1,1), "%s", "MyTag");
|
|
ImPlot::TagY(0.5, ImVec4(0,1,1,1), "Tag: %d", 42);
|
|
}
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_DragAndDrop() {
|
|
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 Item Labels");
|
|
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;
|
|
ImAxis Yax;
|
|
char Label[16];
|
|
ImVector<ImVec2> Data;
|
|
ImVec4 Color;
|
|
MyDndItem() {
|
|
static int i = 0;
|
|
Idx = i++;
|
|
Plt = 0;
|
|
Yax = ImAxis_Y1;
|
|
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 = ImAxis_Y1; }
|
|
};
|
|
|
|
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")) {
|
|
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 | ImPlotAxisFlags_NoHighlight;
|
|
if (ImPlot::BeginPlot("##DND1", ImVec2(-1,195))) {
|
|
ImPlot::SetupAxis(ImAxis_X1, NULL, flags|ImPlotAxisFlags_Lock);
|
|
ImPlot::SetupAxis(ImAxis_Y1, "[drop here]", flags);
|
|
ImPlot::SetupAxis(ImAxis_Y2, "[drop here]", flags|ImPlotAxisFlags_Opposite);
|
|
ImPlot::SetupAxis(ImAxis_Y3, "[drop here]", flags|ImPlotAxisFlags_Opposite);
|
|
|
|
for (int k = 0; k < k_dnd; ++k) {
|
|
if (dnd[k].Plt == 1 && dnd[k].Data.size() > 0) {
|
|
ImPlot::SetAxis(dnd[k].Yax);
|
|
ImPlot::SetNextLineStyle(dnd[k].Color);
|
|
ImPlot::PlotLine(dnd[k].Label, &dnd[k].Data[0].x, &dnd[k].Data[0].y, dnd[k].Data.size(), 0, 0, 2 * sizeof(float));
|
|
// allow legend item labels to be DND sources
|
|
if (ImPlot::BeginDragDropSourceItem(dnd[k].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::BeginDragDropTargetPlot()) {
|
|
if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("MY_DND")) {
|
|
int i = *(int*)payload->Data; dnd[i].Plt = 1; dnd[i].Yax = ImAxis_Y1;
|
|
}
|
|
ImPlot::EndDragDropTarget();
|
|
}
|
|
// allow each y-axis to be a DND target
|
|
for (int y = ImAxis_Y1; y <= ImAxis_Y3; ++y) {
|
|
if (ImPlot::BeginDragDropTargetAxis(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 = ImAxis_Y1;
|
|
}
|
|
ImPlot::EndDragDropTarget();
|
|
}
|
|
ImPlot::EndPlot();
|
|
}
|
|
// plot 2 (Lissajous)
|
|
if (ImPlot::BeginPlot("##DND2", ImVec2(-1,195))) {
|
|
ImPlot::PushStyleColor(ImPlotCol_AxisBg, dndx != NULL ? dndx->Color : ImPlot::GetStyle().Colors[ImPlotCol_AxisBg]);
|
|
ImPlot::SetupAxis(ImAxis_X1, dndx == NULL ? "[drop here]" : dndx->Label, flags);
|
|
ImPlot::PushStyleColor(ImPlotCol_AxisBg, dndy != NULL ? dndy->Color : ImPlot::GetStyle().Colors[ImPlotCol_AxisBg]);
|
|
ImPlot::SetupAxis(ImAxis_Y1, dndy == NULL ? "[drop here]" : dndy->Label, flags);
|
|
ImPlot::PopStyleColor(2);
|
|
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, 0, 2 * sizeof(float));
|
|
}
|
|
// allow the x-axis to be a DND target
|
|
if (ImPlot::BeginDragDropTargetAxis(ImAxis_X1)) {
|
|
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::BeginDragDropSourceAxis(ImAxis_X1)) {
|
|
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::BeginDragDropTargetAxis(ImAxis_Y1)) {
|
|
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::BeginDragDropSourceAxis(ImAxis_Y1)) {
|
|
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::BeginDragDropTargetPlot()) {
|
|
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::BeginDragDropSourcePlot()) {
|
|
ImGui::TextUnformatted("Yes, you can\ndrag this!");
|
|
ImPlot::EndDragDropSource();
|
|
}
|
|
ImPlot::EndPlot();
|
|
}
|
|
ImGui::EndChild();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_Tables() {
|
|
#ifdef IMGUI_HAS_TABLE
|
|
static ImGuiTableFlags flags = ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersV |
|
|
ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable;
|
|
static bool anim = true;
|
|
static int offset = 0;
|
|
ImGui::BulletText("Plots can be used inside of ImGui tables as another means of creating subplots.");
|
|
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
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_OffsetAndStride() {
|
|
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",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, 0, offset, 2*k_circles*sizeof(double));
|
|
}
|
|
ImPlot::EndPlot();
|
|
ImPlot::PopColormap();
|
|
}
|
|
// offset++; uncomment for animation!
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_CustomDataAndGetters() {
|
|
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, 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();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int MetricFormatter(double value, char* buff, int size, void* data) {
|
|
const char* unit = (const char*)data;
|
|
static double v[] = {1000000000,1000000,1000,1,0.001,0.000001,0.000000001};
|
|
static const char* p[] = {"G","M","k","","m","u","n"};
|
|
if (value == 0) {
|
|
return snprintf(buff,size,"0 %s", unit);
|
|
}
|
|
for (int i = 0; i < 7; ++i) {
|
|
if (fabs(value) >= v[i]) {
|
|
return snprintf(buff,size,"%g %s%s",value/v[i],p[i],unit);
|
|
}
|
|
}
|
|
return snprintf(buff,size,"%g %s%s",value/v[6],p[6],unit);
|
|
}
|
|
|
|
void Demo_TickLabels() {
|
|
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);
|
|
}
|
|
const double pi = 3.14;
|
|
const char* pi_str[] = {"PI"};
|
|
static double yticks[] = {100,300,700,900};
|
|
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 (ImPlot::BeginPlot("##Ticks")) {
|
|
ImPlot::SetupAxesLimits(2.5,5,0,1000);
|
|
ImPlot::SetupAxis(ImAxis_Y2, NULL, ImPlotAxisFlags_AuxDefault);
|
|
ImPlot::SetupAxis(ImAxis_Y3, NULL, ImPlotAxisFlags_AuxDefault);
|
|
if (custom_fmt) {
|
|
ImPlot::SetupAxisFormat(ImAxis_X1, "%g ms");
|
|
ImPlot::SetupAxisFormat(ImAxis_Y1, MetricFormatter, (void*)"Hz");
|
|
ImPlot::SetupAxisFormat(ImAxis_Y2, "%g dB");
|
|
ImPlot::SetupAxisFormat(ImAxis_Y3, MetricFormatter, (void*)"m");
|
|
}
|
|
if (custom_ticks) {
|
|
ImPlot::SetupAxisTicks(ImAxis_X1, &pi,1,custom_labels ? pi_str : NULL, true);
|
|
ImPlot::SetupAxisTicks(ImAxis_Y1, yticks, 4, custom_labels ? ylabels : NULL, false);
|
|
ImPlot::SetupAxisTicks(ImAxis_Y2, yticks_aux, 3, custom_labels ? ylabels_aux : NULL, false);
|
|
ImPlot::SetupAxisTicks(ImAxis_Y3, 0, 1, 6, custom_labels ? ylabels_aux : NULL, false);
|
|
}
|
|
ImPlot::EndPlot();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Demo_CustomStyles() {
|
|
ImPlot::PushColormap(ImPlotColormap_Deep);
|
|
// normally you wouldn't change the entire style each frame
|
|
ImPlotStyle backup = ImPlot::GetStyle();
|
|
MyImPlot::StyleSeaborn();
|
|
if (ImPlot::BeginPlot("seaborn style")) {
|
|
ImPlot::SetupAxes( "x-axis", "y-axis");
|
|
ImPlot::SetupAxesLimits(-0.5f, 9.5f, 0, 10);
|
|
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 |