1285 lines
54 KiB
C
1285 lines
54 KiB
C
|
// # Low level plotting features and components for creating basic to advanced plots and charts
|
||
|
|
|
||
|
|
// BUGS:
|
||
|
|
// - titles does not move in both x/y directions correctly relative to the figure
|
||
|
|
|
||
|
|
#pragma once
|
||
|
|
|
||
|
|
#include "imgui.h"
|
||
|
|
#define IMGUI_DEFINE_MATH_OPERATORS
|
||
|
|
#include "imgui_internal.h"
|
||
|
|
|
||
|
|
#include <iostream> //delete when finished debugging
|
||
|
|
#include <vector>
|
||
|
|
|
||
|
|
namespace ImGui
|
||
|
|
{
|
||
|
|
// ## Interpolation
|
||
|
|
// - interpolate
|
||
|
|
// - sample
|
||
|
|
// - splines
|
||
|
|
// static inline time_t ImLerp(const time_t& a, const time_t& b, const time_t& t); //TODO [DM]
|
||
|
|
// static inline float ImBSBasis(float t1, float v0, float v1, float v2, float v3); //TODO [DM] BSpline basis function
|
||
|
|
// static inline ImVec4 ImBSBasis(const ImVec4& t1, const ImVec4& v0, const ImVec4& v1, const ImVec4& v2, const ImVec4& v3); //TODO [DM] BSpline basis function used for colors
|
||
|
|
// static inline int ImBSerp(int* v, float t, bool closed = false); //TODO [DM] BSpline interpolate from [a, b) or [a, b] (closed=true)
|
||
|
|
// static inline float ImBSerp(float* v, float t, bool closed = false); //TODO [DM] BSpline interpolate from [a, b) or [a, b] (closed=true)
|
||
|
|
// static inline ImVec4 ImBSerp(const ImVec4* v, const ImVec4& t, bool closed = false); //TODO [DM] BSpline interpolate used for colors from [a, b) or [a, b] (closed=true)
|
||
|
|
// static inline int* ImQuaLerp(int a, int b, float t, int n); //TODO [DM] Quantized linear sampler
|
||
|
|
// static inline float* ImQuaLerp(float a, float b, float t, int n); //TODO [DM] Quantized linear sampler
|
||
|
|
// static inline time_t* ImQuaLerp(const time_t& a, const time_t& b, const time_t& t, int n); //TODO [DM] Quantized linear sampler
|
||
|
|
// static inline int* ImQuaBSerp(int a, int b, float t, int n, bool closed = false); //TODO [DM] Quantized BSpline sampler
|
||
|
|
// static inline float* ImQuaBSerp(float a, float b, float t, int n, bool closed = false); //TODO [DM] Quantized BSpline sampler
|
||
|
|
// static inline ImVec4* ImQuaBSerp(const ImVec4& a, const ImVec4& b, const ImVec4& t, int n, bool closed = false); //TODO [DM] Quantized BSpline sampler used for colors
|
||
|
|
|
||
|
|
bool is_inside_area(const ImVec2& P, const ImVector<ImVec2>& V);
|
||
|
|
|
||
|
|
// ## Scales
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImScales
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
void SetDomain(const Ta& min, const Ta& max){domain_min_ = min; domain_max_ = max;} // input data ranges
|
||
|
|
void SetRange(const Tb min, const Tb max){range_min_ = min; range_max_ = max;} // output data ranges
|
||
|
|
Ta GetDomainMin(){return domain_min_;}
|
||
|
|
Ta GetDomainMax(){return domain_max_;}
|
||
|
|
Tb GetRangeMin(){return range_min_;}
|
||
|
|
Tb GetRangeMax(){return range_max_;}
|
||
|
|
virtual Tb Scale(const Ta& t) = 0;
|
||
|
|
protected:
|
||
|
|
Ta domain_min_;
|
||
|
|
Ta domain_max_;
|
||
|
|
Tb range_min_;
|
||
|
|
Tb range_max_;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Continuous linear scales used for ImVec2 and ImVec4 (colors
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImLinearScales : public ImScales<Ta, Tb>
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
Tb Scale(const Ta& t)
|
||
|
|
{
|
||
|
|
const Ta tx = (t - this->domain_min_) / (this->domain_max_ - this->domain_min_);
|
||
|
|
const Tb ty = ImLerp(this->range_min_, this->range_max_, tx);
|
||
|
|
return ty;
|
||
|
|
}
|
||
|
|
// void Pow();
|
||
|
|
// void Log();
|
||
|
|
// void Time();
|
||
|
|
// void Sequential();
|
||
|
|
// void Continuous(); // used for colors
|
||
|
|
// // quantized scales
|
||
|
|
// void Quantize(); // maps a continouus variable to a discrete scale
|
||
|
|
// void Quantile(ImVec2& range, float& val); // maps a continuous varible to a sampled domain
|
||
|
|
// void Threshold();
|
||
|
|
// // discrete scales
|
||
|
|
// void Ordered();
|
||
|
|
// void Categorical();
|
||
|
|
// void Band();
|
||
|
|
// void Round();
|
||
|
|
// void Point();
|
||
|
|
};
|
||
|
|
|
||
|
|
// ## Plot element
|
||
|
|
struct ImPlotProperties
|
||
|
|
{
|
||
|
|
ImVec2 plot_size = ImVec2(480.0f, 480.0f);
|
||
|
|
float margin_bottom = 50.0f;
|
||
|
|
float margin_top = 50.0f;
|
||
|
|
float margin_left = 50.0f;
|
||
|
|
float margin_right = 50.0f;
|
||
|
|
ImU32 bg_col = GetColorU32(ImGuiCol_FrameBg);
|
||
|
|
const char* title = NULL;
|
||
|
|
ImFont* title_font = NULL;
|
||
|
|
float title_font_size = 18.0f;
|
||
|
|
ImU32 title_font_col = 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImPlot
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
|
||
|
|
ImVec2 _(ImVec2 &a, ImVec2 &b) { return ImVec2(a.x + b.x, a.y + b.y); }
|
||
|
|
ImVec2 _(const ImVec2 a, const ImVec2 b) { return ImVec2(a.x + b.x, a.y + b.y); }
|
||
|
|
ImVec2 __(ImVec2 &a, ImVec2 &b) { return ImVec2(a.x - b.x, a.y - b.y); }
|
||
|
|
ImVec2 __(const ImVec2 a, const ImVec2 b) { return ImVec2(a.x - b.x, a.y - b.y); }
|
||
|
|
/**
|
||
|
|
* @brief Draw the figure with an optional title
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawFigure()
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
ImGuiContext& g = *GImGui;
|
||
|
|
const ImGuiStyle& style = g.Style;
|
||
|
|
|
||
|
|
// Create the window
|
||
|
|
const ImRect frame_bb(window->DC.CursorPos, _(window->DC.CursorPos , ImVec2(properties_.plot_size.x, properties_.plot_size.y)));
|
||
|
|
const ImRect inner_bb(_(frame_bb.Min , style.FramePadding), __(frame_bb.Max , style.FramePadding));
|
||
|
|
const ImRect figure_bb(ImVec2(inner_bb.Min.x + properties_.margin_left, inner_bb.Min.y + properties_.margin_top),
|
||
|
|
ImVec2(inner_bb.Max.x - properties_.margin_right, inner_bb.Max.y - properties_.margin_bottom));
|
||
|
|
const ImRect total_bb(frame_bb.Min, frame_bb.Max);
|
||
|
|
RenderFrame(frame_bb.Min, frame_bb.Max, properties_.bg_col, true, style.FrameRounding);
|
||
|
|
|
||
|
|
// Draw the title
|
||
|
|
const ImVec2 title_size = CalcTextSize(properties_.title, NULL, true);
|
||
|
|
if (title_size.x > 0.0f)
|
||
|
|
{
|
||
|
|
// centered by default (add parameter for title position)
|
||
|
|
const ImVec2 title_pos(
|
||
|
|
inner_bb.Min.x + (inner_bb.Max.x - inner_bb.Min.x)*0.5f - title_size.x*0.5,
|
||
|
|
inner_bb.Min.y);
|
||
|
|
window->DrawList->AddText(properties_.title_font, properties_.title_font_size, title_pos, properties_.title_font_col, properties_.title);
|
||
|
|
}
|
||
|
|
|
||
|
|
// update scales range
|
||
|
|
scales_x_->SetRange(figure_bb.Min.x, figure_bb.Max.x);
|
||
|
|
scales_y_->SetRange(figure_bb.Max.y, figure_bb.Min.y);
|
||
|
|
};
|
||
|
|
|
||
|
|
void SetProperties(ImPlotProperties& properties){properties_ = properties;}
|
||
|
|
void SetScales(ImScales<Ta, float>* scales_x, ImScales<Tb, float>* scales_y){scales_x_ = scales_x; scales_y_ = scales_y;}
|
||
|
|
ImScales<Ta, float>* GetScalesX(){return scales_x_;}
|
||
|
|
ImScales<Tb, float>* GetScalesY(){return scales_y_;}
|
||
|
|
|
||
|
|
protected:
|
||
|
|
ImScales<Ta, float>* scales_x_;
|
||
|
|
ImScales<Tb, float>* scales_y_;
|
||
|
|
ImPlotProperties properties_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ## Axes
|
||
|
|
struct ImAxisProperties
|
||
|
|
{
|
||
|
|
const char* axis_title = NULL;
|
||
|
|
ImFont* axis_title_font = NULL;
|
||
|
|
float axis_title_font_size = 0.0f;
|
||
|
|
ImU32 axis_title_font_col = 0;
|
||
|
|
const char* axis_tick_format = "%4.2f"; ///< string format
|
||
|
|
float axis_thickness = 1.0f;
|
||
|
|
ImU32 axis_col = 0;
|
||
|
|
ImFont* axis_tick_font = NULL;
|
||
|
|
float axis_tick_font_size = 12.0f;
|
||
|
|
ImU32 axis_font_col = 0;
|
||
|
|
float grid_lines_thickness = 1.0f;
|
||
|
|
ImU32 grid_lines_col = 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImAxis
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
ImVec2 _(ImVec2 &a, ImVec2 &b) { return ImVec2(a.x + b.x, a.y + b.y); }
|
||
|
|
ImVec2 _(const ImVec2 a, const ImVec2 b) { return ImVec2(a.x + b.x, a.y + b.y); }
|
||
|
|
ImVec2 __(ImVec2 &a, ImVec2 &b) { return ImVec2(a.x - b.x, a.y - b.y); }
|
||
|
|
ImVec2 __(const ImVec2 a, const ImVec2 b) { return ImVec2(a.x - b.x, a.y - b.y); }
|
||
|
|
/**
|
||
|
|
* @brief Draw X axis
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param orientation Options are Top, Bottom
|
||
|
|
* @param axis_tick_min Minimum axis tick value
|
||
|
|
* @param axis_tick_max Maximum axis tick value
|
||
|
|
* @param axis_tick_span Spacing between axis ticks
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawXAxis(ImPlot<Ta, Tb>& figure, const char* orientation,
|
||
|
|
const Ta& axis_tick_min, const Ta& axis_tick_max, const Ta& axis_tick_span)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Tick major
|
||
|
|
const ImVec2 tick_size = CalcTextSize(properties_.axis_title, NULL, true);
|
||
|
|
|
||
|
|
Ta tick_value = axis_tick_min;
|
||
|
|
while (tick_value <= axis_tick_max)
|
||
|
|
{
|
||
|
|
// Tick label
|
||
|
|
char tick_label[64];
|
||
|
|
sprintf(tick_label, properties_.axis_tick_format, tick_value);
|
||
|
|
|
||
|
|
// Tick Position
|
||
|
|
if (strcmp(orientation, "Top") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 tick_pos = ImVec2(figure.GetScalesX()->Scale(tick_value), figure.GetScalesY()->GetRangeMax() - tick_size.y); // interpolate the position
|
||
|
|
window->DrawList->AddText(properties_.axis_tick_font, properties_.axis_tick_font_size, tick_pos, properties_.axis_font_col, tick_label);
|
||
|
|
}
|
||
|
|
else if (strcmp(orientation, "Bottom") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 tick_pos = ImVec2(figure.GetScalesX()->Scale(tick_value), figure.GetScalesY()->GetRangeMin() + tick_size.y); // interpolate the position
|
||
|
|
window->DrawList->AddText(properties_.axis_tick_font, properties_.axis_tick_font_size, tick_pos, properties_.axis_font_col, tick_label);
|
||
|
|
}
|
||
|
|
|
||
|
|
tick_value += axis_tick_span;
|
||
|
|
}
|
||
|
|
|
||
|
|
_DrawXAxisAxis(figure, orientation);
|
||
|
|
_DrawXAxisTitle(figure, orientation);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Draw X axis
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param orientation Options are Top, Bottom
|
||
|
|
* @param axis_tick_pos Positions of the axis ticks
|
||
|
|
* @param axis_tick_labels Labels of the axis ticks
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawXAxis(ImPlot<Ta, Tb>& figure, const char* orientation,
|
||
|
|
const Ta* axis_tick_pos, const char* axis_tick_labels[], const int& n_ticks)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Tick major
|
||
|
|
const ImVec2 tick_size = CalcTextSize(properties_.axis_title, NULL, true);
|
||
|
|
|
||
|
|
for (int n=0; n < n_ticks; ++n)
|
||
|
|
{
|
||
|
|
// Tick label
|
||
|
|
char tick_label[64];
|
||
|
|
sprintf(tick_label, properties_.axis_tick_format, axis_tick_labels[n]);
|
||
|
|
|
||
|
|
// Tick Position
|
||
|
|
if (strcmp(orientation, "Top") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 tick_pos = ImVec2(figure.GetScalesX()->Scale(axis_tick_pos[n]), figure.GetScalesY()->GetRangeMax() - tick_size.y); // interpolate the position
|
||
|
|
window->DrawList->AddText(properties_.axis_tick_font, properties_.axis_tick_font_size, tick_pos, properties_.axis_font_col, tick_label);
|
||
|
|
}
|
||
|
|
else if (strcmp(orientation, "Bottom") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 tick_pos = ImVec2(figure.GetScalesX()->Scale(axis_tick_pos[n]), figure.GetScalesY()->GetRangeMin() + tick_size.y); // interpolate the position
|
||
|
|
window->DrawList->AddText(properties_.axis_tick_font, properties_.axis_tick_font_size, tick_pos, properties_.axis_font_col, tick_label);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
_DrawXAxisAxis(figure, orientation);
|
||
|
|
_DrawXAxisTitle(figure, orientation);
|
||
|
|
};
|
||
|
|
|
||
|
|
void _DrawXAxisAxis(ImPlot<Ta, Tb>& figure, const char* orientation)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Axis
|
||
|
|
if (strcmp(orientation, "Top") == 0)
|
||
|
|
{
|
||
|
|
window->DrawList->AddLine(ImVec2(figure.GetScalesX()->GetRangeMin(), figure.GetScalesY()->GetRangeMax()),
|
||
|
|
ImVec2(figure.GetScalesX()->GetRangeMax(), figure.GetScalesY()->GetRangeMax()), properties_.axis_col, properties_.axis_thickness);
|
||
|
|
}
|
||
|
|
else if (strcmp(orientation, "Bottom") == 0)
|
||
|
|
{
|
||
|
|
window->DrawList->AddLine(ImVec2(figure.GetScalesX()->GetRangeMin(), figure.GetScalesY()->GetRangeMin()),
|
||
|
|
ImVec2(figure.GetScalesX()->GetRangeMax(), figure.GetScalesY()->GetRangeMin()), properties_.axis_col, properties_.axis_thickness);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
void _DrawXAxisTitle(ImPlot<Ta, Tb>& figure, const char* orientation)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Tick major
|
||
|
|
const ImVec2 tick_size = CalcTextSize(properties_.axis_title, NULL, true);
|
||
|
|
|
||
|
|
// Axis title
|
||
|
|
const ImVec2 title_size = CalcTextSize(properties_.axis_title, NULL, true);
|
||
|
|
|
||
|
|
if (strcmp(orientation, "Top") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 title_pos = ImVec2(
|
||
|
|
figure.GetScalesX()->GetRangeMin() + (figure.GetScalesX()->GetRangeMax() - figure.GetScalesX()->GetRangeMin())*0.5f - title_size.x*0.5f,
|
||
|
|
figure.GetScalesY()->GetRangeMax() - (title_size.y + tick_size.y));
|
||
|
|
window->DrawList->AddText(properties_.axis_title_font, properties_.axis_title_font_size, title_pos, properties_.axis_title_font_col, properties_.axis_title);
|
||
|
|
}
|
||
|
|
else if (strcmp(orientation, "Bottom") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 title_pos = ImVec2(
|
||
|
|
figure.GetScalesX()->GetRangeMin() + (figure.GetScalesX()->GetRangeMax() - figure.GetScalesX()->GetRangeMin())*0.5f - title_size.x*0.5f,
|
||
|
|
figure.GetScalesY()->GetRangeMin() + (title_size.y + tick_size.y));
|
||
|
|
window->DrawList->AddText(properties_.axis_title_font, properties_.axis_title_font_size, title_pos, properties_.axis_title_font_col, properties_.axis_title);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Draw Y axis
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param orientation Options are Left, Right
|
||
|
|
* @param axis_tick_min Minimum axis tick value
|
||
|
|
* @param axis_tick_max Maximum axis tick value
|
||
|
|
* @param axis_tick_span Spacing between axis ticks
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawYAxis(ImPlot<Ta, Tb>& figure, const char* orientation,
|
||
|
|
const Tb& axis_tick_min, const Tb& axis_tick_max, const Tb& axis_tick_span)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Tick major
|
||
|
|
const ImVec2 tick_size = CalcTextSize(properties_.axis_title, NULL, true);
|
||
|
|
|
||
|
|
Tb tick_value = axis_tick_min;
|
||
|
|
while (tick_value <= axis_tick_max)
|
||
|
|
{
|
||
|
|
// Tick label
|
||
|
|
char tick_label[64];
|
||
|
|
sprintf(tick_label, properties_.axis_tick_format, tick_value);
|
||
|
|
|
||
|
|
// Tick Position
|
||
|
|
if (strcmp(orientation, "Left") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 tick_pos = ImVec2(figure.GetScalesX()->GetRangeMin() - tick_size.y-20, figure.GetScalesY()->Scale(tick_value)); // interpolate the position
|
||
|
|
window->DrawList->AddText(properties_.axis_tick_font, properties_.axis_tick_font_size, tick_pos, properties_.axis_font_col, tick_label);
|
||
|
|
}
|
||
|
|
else if (strcmp(orientation, "Right") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 tick_pos = ImVec2(figure.GetScalesX()->GetRangeMax() + tick_size.y, figure.GetScalesY()->Scale(tick_value)); // interpolate the position
|
||
|
|
window->DrawList->AddText(properties_.axis_tick_font, properties_.axis_tick_font_size, tick_pos, properties_.axis_font_col, tick_label);
|
||
|
|
}
|
||
|
|
|
||
|
|
tick_value += axis_tick_span;
|
||
|
|
}
|
||
|
|
|
||
|
|
_DrawYAxisAxis(figure, orientation);
|
||
|
|
_DrawYAxisTitle(figure, orientation);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Draw Y axis
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param orientation Options are Left, Right
|
||
|
|
* @param axis_tick_pos Positions of the axis ticks
|
||
|
|
* @param axis_tick_labels Labels of the axis ticks
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawYAxis(ImPlot<Ta, Tb>& figure, const char* orientation,
|
||
|
|
const Tb* axis_tick_pos, const char* axis_tick_labels[], const int& n_ticks)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Tick major
|
||
|
|
const ImVec2 tick_size = CalcTextSize(properties_.axis_title, NULL, true);
|
||
|
|
|
||
|
|
for (int n=0; n < n_ticks; ++n)
|
||
|
|
{
|
||
|
|
// Tick label
|
||
|
|
char tick_label[64];
|
||
|
|
sprintf(tick_label, properties_.axis_tick_format, axis_tick_labels[n]);
|
||
|
|
|
||
|
|
if (strcmp(orientation, "Left") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 tick_pos = ImVec2(figure.GetScalesX()->GetRangeMin() - tick_size.y, figure.GetScalesY()->Scale(axis_tick_pos[n])); // interpolate the position
|
||
|
|
window->DrawList->AddText(properties_.axis_tick_font, properties_.axis_tick_font_size, tick_pos, properties_.axis_font_col, tick_label);
|
||
|
|
}
|
||
|
|
else if (strcmp(orientation, "Right") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 tick_pos = ImVec2(figure.GetScalesX()->GetRangeMax() + tick_size.y, figure.GetScalesY()->Scale(axis_tick_pos[n])); // interpolate the position
|
||
|
|
window->DrawList->AddText(properties_.axis_tick_font, properties_.axis_tick_font_size, tick_pos, properties_.axis_font_col, tick_label);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
_DrawYAxisAxis(figure, orientation);
|
||
|
|
_DrawYAxisTitle(figure, orientation);
|
||
|
|
};
|
||
|
|
|
||
|
|
void _DrawYAxisAxis(ImPlot<Ta, Tb>& figure, const char* orientation)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Axis
|
||
|
|
if (strcmp(orientation, "Left") == 0)
|
||
|
|
{
|
||
|
|
window->DrawList->AddLine(ImVec2(figure.GetScalesX()->GetRangeMin(), figure.GetScalesY()->GetRangeMin()),
|
||
|
|
ImVec2(figure.GetScalesX()->GetRangeMin(), figure.GetScalesY()->GetRangeMax()), properties_.axis_col, properties_.axis_thickness);
|
||
|
|
}
|
||
|
|
else if (strcmp(orientation, "Right") == 0)
|
||
|
|
{
|
||
|
|
window->DrawList->AddLine(ImVec2(figure.GetScalesX()->GetRangeMax(), figure.GetScalesY()->GetRangeMin()),
|
||
|
|
ImVec2(figure.GetScalesX()->GetRangeMax(), figure.GetScalesY()->GetRangeMax()), properties_.axis_col, properties_.axis_thickness);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
void _DrawYAxisTitle(ImPlot<Ta, Tb>& figure, const char* orientation)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
char c;
|
||
|
|
char *title = (char *)properties_.axis_title;
|
||
|
|
const ImFontGlyph *glyph;
|
||
|
|
|
||
|
|
// Tick major
|
||
|
|
const ImVec2 tick_size = CalcTextSize(properties_.axis_title, NULL, true);
|
||
|
|
|
||
|
|
// Axis title
|
||
|
|
const ImVec2 title_size = CalcTextSize(properties_.axis_title, NULL, true);
|
||
|
|
|
||
|
|
if (strcmp(orientation, "Left") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 title_pos = ImVec2(
|
||
|
|
figure.GetScalesX()->GetRangeMin() - (title_size.y * 2 + tick_size.y)-20,
|
||
|
|
figure.GetScalesY()->GetRangeMin() + (figure.GetScalesY()->GetRangeMax() - figure.GetScalesY()->GetRangeMin())*0.5f + title_size.x*0.5f);
|
||
|
|
window->DrawList->AddText(properties_.axis_title_font, properties_.axis_title_font_size, title_pos, properties_.axis_title_font_col, properties_.axis_title);
|
||
|
|
/* while((c = *(title++))) {
|
||
|
|
glyph = properties_.axis_title_font->FindGlyph(c);
|
||
|
|
if (!glyph) continue;
|
||
|
|
window->DrawList->PrimReserve(6, 4);
|
||
|
|
window->DrawList->PrimQuadUV(
|
||
|
|
_(title_pos , ImVec2(glyph->Y0, -glyph->X0)),
|
||
|
|
_(title_pos , ImVec2(glyph->Y0, -glyph->X1)),
|
||
|
|
_(title_pos , ImVec2(glyph->Y1, -glyph->X1)),
|
||
|
|
_(title_pos , ImVec2(glyph->Y1, -glyph->X0)),
|
||
|
|
ImVec2(glyph->U0, glyph->V0),
|
||
|
|
ImVec2(glyph->U1, glyph->V0),
|
||
|
|
ImVec2(glyph->U1, glyph->V1),
|
||
|
|
ImVec2(glyph->U0, glyph->V1),
|
||
|
|
properties_.axis_title_font_col);
|
||
|
|
title_pos.y -= glyph->AdvanceX;
|
||
|
|
}*/
|
||
|
|
}
|
||
|
|
else if (strcmp(orientation, "Right") == 0)
|
||
|
|
{
|
||
|
|
ImVec2 title_pos = ImVec2(
|
||
|
|
figure.GetScalesX()->GetRangeMax() + (title_size.y * 2 + tick_size.y),
|
||
|
|
figure.GetScalesY()->GetRangeMin() + (figure.GetScalesY()->GetRangeMax() - figure.GetScalesY()->GetRangeMin())*0.5f + title_size.x*0.5f);
|
||
|
|
//window->DrawList->AddText(properties_.axis_title_font, properties_.axis_title_font_size, title_pos, properties_.axis_title_font_col, properties_.axis_title);
|
||
|
|
while((c = *(title++))) {
|
||
|
|
glyph = properties_.axis_title_font->FindGlyph(c);
|
||
|
|
if (!glyph) continue;
|
||
|
|
window->DrawList->PrimReserve(6, 4);
|
||
|
|
window->DrawList->PrimQuadUV(
|
||
|
|
_(title_pos , ImVec2(glyph->Y0, -glyph->X0)),
|
||
|
|
_(title_pos , ImVec2(glyph->Y0, -glyph->X1)),
|
||
|
|
_(title_pos , ImVec2(glyph->Y1, -glyph->X1)),
|
||
|
|
_(title_pos , ImVec2(glyph->Y1, -glyph->X0)),
|
||
|
|
ImVec2(glyph->U0, glyph->V0),
|
||
|
|
ImVec2(glyph->U1, glyph->V0),
|
||
|
|
ImVec2(glyph->U1, glyph->V1),
|
||
|
|
ImVec2(glyph->U0, glyph->V1),
|
||
|
|
properties_.axis_title_font_col);
|
||
|
|
title_pos.y -= glyph->AdvanceX;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Draw X Axis Gridlines
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawXGridLines(ImPlot<Ta, Tb>& figure,
|
||
|
|
const Ta& axis_tick_min, const Ta& axis_tick_max, const Ta& axis_tick_span)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
Ta tick_value = axis_tick_min;
|
||
|
|
while (tick_value <= axis_tick_max)
|
||
|
|
{
|
||
|
|
window->DrawList->AddLine(ImVec2(figure.GetScalesX()->Scale(tick_value), figure.GetScalesY()->GetRangeMax()),
|
||
|
|
ImVec2(figure.GetScalesX()->Scale(tick_value), figure.GetScalesY()->GetRangeMin()),
|
||
|
|
properties_.grid_lines_col, properties_.grid_lines_thickness);
|
||
|
|
|
||
|
|
tick_value += axis_tick_span;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Draw Y Axis Gridlines
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawYGridLines(ImPlot<Ta, Tb>& figure,
|
||
|
|
const Tb& axis_tick_min, const Tb& axis_tick_max, const Tb& axis_tick_span)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
Tb tick_value = axis_tick_min;
|
||
|
|
while (tick_value <= axis_tick_max)
|
||
|
|
{
|
||
|
|
window->DrawList->AddLine(ImVec2(figure.GetScalesX()->GetRangeMin(), figure.GetScalesY()->Scale(tick_value)),
|
||
|
|
ImVec2(figure.GetScalesX()->GetRangeMax(), figure.GetScalesY()->Scale(tick_value)),
|
||
|
|
properties_.grid_lines_col, properties_.grid_lines_thickness);
|
||
|
|
|
||
|
|
tick_value += axis_tick_span;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
void SetProperties(ImAxisProperties& properties){properties_ = properties;}
|
||
|
|
|
||
|
|
private:
|
||
|
|
ImAxisProperties properties_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ## Plot legends and other features
|
||
|
|
struct ImColorBarProperties
|
||
|
|
{
|
||
|
|
// TODO
|
||
|
|
};
|
||
|
|
|
||
|
|
struct ImLegendProperties
|
||
|
|
{
|
||
|
|
ImU32 stroke_col = 0;
|
||
|
|
float stroke_width = 1.0f;
|
||
|
|
ImU32 fill_col = 0; ///< Background color of the legend
|
||
|
|
ImFont* series_font = NULL; ///< Font type for series labels
|
||
|
|
float series_font_size = 0.0f; ///< Font size of the series labels
|
||
|
|
ImU32 series_font_col = 0; ///< Color of the series labels
|
||
|
|
};
|
||
|
|
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImLegend
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
|
||
|
|
/**@brief Draw a plot legend
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param pos Pos of the legend (TL, TR, BL, BR)
|
||
|
|
* @param col Background color of the legend
|
||
|
|
* @param series List of series labels
|
||
|
|
* @param series_color List of series colors
|
||
|
|
*/
|
||
|
|
void DrawLegend(ImPlot<Ta, Tb>& figure, const char* pos,
|
||
|
|
const char* series[], const ImU32 series_color[], const int& n_series)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
//assert(IM_ARRAYSIZE(series) == IM_ARRAYSIZE(series_color));
|
||
|
|
|
||
|
|
ImVec2 legend_pos = ImVec2(figure.GetScalesX()->GetRangeMax(), figure.GetScalesY()->GetRangeMax()); //TR
|
||
|
|
if (!strcmp(pos, "TL")) legend_pos = ImVec2(figure.GetScalesX()->GetRangeMax(), figure.GetScalesY()->GetRangeMin());
|
||
|
|
else if (!strcmp(pos, "TR")) legend_pos = ImVec2(figure.GetScalesX()->GetRangeMax(), figure.GetScalesY()->GetRangeMax());
|
||
|
|
else if (!strcmp(pos, "BR")) legend_pos = ImVec2(figure.GetScalesX()->GetRangeMin(), figure.GetScalesY()->GetRangeMax());
|
||
|
|
else if (!strcmp(pos, "BL")) legend_pos = ImVec2(figure.GetScalesX()->GetRangeMin(), figure.GetScalesY()->GetRangeMin());
|
||
|
|
|
||
|
|
|
||
|
|
// Deduce the maximum text size
|
||
|
|
ImVec2 series_size = ImVec2(0.0f, 0.0f);
|
||
|
|
for (int n=0; n<n_series; ++n)
|
||
|
|
{
|
||
|
|
ImVec2 series_size_tmp = CalcTextSize(series[n], NULL, true);
|
||
|
|
if (series_size_tmp.x > series_size.x) series_size = series_size_tmp;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Legend attributes
|
||
|
|
const float series_spacing = 0.1*series_size.y;
|
||
|
|
const float box_length = 0.9*series_size.y;
|
||
|
|
const float height = n_series * series_size.y + n_series * series_spacing + series_spacing;
|
||
|
|
const float width = series_size.x + box_length + 1.0f + 6*series_spacing;
|
||
|
|
|
||
|
|
// Draw box
|
||
|
|
window->DrawList->AddRect(ImVec2(legend_pos.x, legend_pos.y), ImVec2(legend_pos.x + width, legend_pos.y + height), properties_.stroke_col);
|
||
|
|
|
||
|
|
for (int n=0; n<n_series; ++n)
|
||
|
|
{
|
||
|
|
const float start_y_pos = n*series_size.y + n*series_spacing + series_spacing;
|
||
|
|
|
||
|
|
// Draw box and color for each series
|
||
|
|
window->DrawList->AddRectFilled(
|
||
|
|
ImVec2(legend_pos.x + series_spacing, legend_pos.y + start_y_pos),
|
||
|
|
ImVec2(legend_pos.x + series_spacing + box_length, legend_pos.y + start_y_pos + box_length),
|
||
|
|
series_color[n]);
|
||
|
|
|
||
|
|
// Label colored box with series name
|
||
|
|
window->DrawList->AddText(properties_.series_font, properties_.series_font_size,
|
||
|
|
ImVec2(legend_pos.x + series_spacing + box_length + 1.0f, legend_pos.y + start_y_pos),
|
||
|
|
properties_.series_font_col, series[n]);
|
||
|
|
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
void SetProperties(ImLegendProperties& properties){properties_ = properties;}
|
||
|
|
|
||
|
|
private:
|
||
|
|
ImLegendProperties properties_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ## Error Bars
|
||
|
|
struct ImErrorBarProperties
|
||
|
|
{
|
||
|
|
ImU32 error_bar_stroke_col = 0;
|
||
|
|
float error_bar_stroke_width = 1.0f;
|
||
|
|
const char* error_bar_cap_style = "Straight"; ///< Options are "Straight", "Circular"
|
||
|
|
float error_bar_cap_width = 4.0f;
|
||
|
|
};
|
||
|
|
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImErrorBars
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
/**
|
||
|
|
* @brief Draw Error Bars
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param dx1 Upper error bar lengths
|
||
|
|
* @param dx2 Lower error bar lengths
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawErrorBarsX(ImPlot<Ta, Tb>& figure,
|
||
|
|
const Ta* x_data, const Tb* y_data, const int& n_data,
|
||
|
|
const Ta* dx1, const Ta* dx2,
|
||
|
|
const Tb& error_offset, const Ta* error_bottoms)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
for (int n = 0; n < n_data; ++n)
|
||
|
|
{
|
||
|
|
// error bars
|
||
|
|
const float centre_scaled_x = figure.GetScalesX()->Scale(x_data[n] + error_bottoms[n]);
|
||
|
|
const float centre_scaled_y = figure.GetScalesY()->Scale(y_data[n]) + error_offset;
|
||
|
|
|
||
|
|
const ImVec2 point = ImVec2(centre_scaled_x, centre_scaled_y);
|
||
|
|
const ImVec2 error_high = ImVec2(figure.GetScalesX()->Scale(x_data[n] + error_bottoms[n] + dx1[n]), centre_scaled_y);
|
||
|
|
const ImVec2 error_low = ImVec2(figure.GetScalesX()->Scale(x_data[n] + error_bottoms[n] - dx2[n]), centre_scaled_y);
|
||
|
|
|
||
|
|
window->DrawList->AddLine(point, error_high, properties_.error_bar_stroke_col, properties_.error_bar_stroke_width);
|
||
|
|
window->DrawList->AddLine(point, error_low, properties_.error_bar_stroke_col, properties_.error_bar_stroke_width);
|
||
|
|
|
||
|
|
// caps
|
||
|
|
if (strcmp(properties_.error_bar_cap_style, "Straight")==0)
|
||
|
|
{
|
||
|
|
if (dx1[n] > 0)
|
||
|
|
{
|
||
|
|
const ImVec2 error_high_down = ImVec2(figure.GetScalesX()->Scale(x_data[n] + error_bottoms[n] + dx1[n]), centre_scaled_y - properties_.error_bar_cap_width * 0.5);
|
||
|
|
const ImVec2 error_high_up = ImVec2(figure.GetScalesX()->Scale(x_data[n] + error_bottoms[n] + dx1[n]), centre_scaled_y + properties_.error_bar_cap_width * 0.5);
|
||
|
|
window->DrawList->AddLine(error_high_down, error_high_up, properties_.error_bar_stroke_col, properties_.error_bar_stroke_width);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (dx2[n] > 0)
|
||
|
|
{
|
||
|
|
const ImVec2 error_low_down = ImVec2(figure.GetScalesX()->Scale(x_data[n] + error_bottoms[n] - dx2[n]), centre_scaled_y - properties_.error_bar_cap_width * 0.5);
|
||
|
|
const ImVec2 error_low_up = ImVec2(figure.GetScalesX()->Scale(x_data[n] + error_bottoms[n] - dx2[n]), centre_scaled_y + properties_.error_bar_cap_width * 0.5);
|
||
|
|
window->DrawList->AddLine(error_low_down, error_low_up, properties_.error_bar_stroke_col, properties_.error_bar_stroke_width);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Draw Error Bars
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param dy1 Upper error bar lengths
|
||
|
|
* @param dy2 Lower error bar lengths
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawErrorBarsY(ImPlot<Ta, Tb>& figure,
|
||
|
|
const Ta* x_data, const Tb* y_data, const int& n_data,
|
||
|
|
const Tb* dy1, const Tb* dy2,
|
||
|
|
const Ta& error_offset, const Tb* error_bottoms)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
for (int n = 0; n < n_data; ++n)
|
||
|
|
{
|
||
|
|
// error bars
|
||
|
|
const float centre_scaled_x = figure.GetScalesX()->Scale(x_data[n]) + error_offset;
|
||
|
|
const float centre_scaled_y = figure.GetScalesY()->Scale(y_data[n] + error_bottoms[n]);
|
||
|
|
|
||
|
|
const ImVec2 point = ImVec2(centre_scaled_x, centre_scaled_y);
|
||
|
|
const ImVec2 error_high = ImVec2(centre_scaled_x, figure.GetScalesY()->Scale(y_data[n] + error_bottoms[n] + dy1[n]));
|
||
|
|
const ImVec2 error_low = ImVec2(centre_scaled_x, figure.GetScalesY()->Scale(y_data[n] + error_bottoms[n] - dy2[n]));
|
||
|
|
|
||
|
|
window->DrawList->AddLine(point, error_high, properties_.error_bar_stroke_col, properties_.error_bar_stroke_width);
|
||
|
|
window->DrawList->AddLine(point, error_low, properties_.error_bar_stroke_col, properties_.error_bar_stroke_width);
|
||
|
|
|
||
|
|
// caps
|
||
|
|
if (strcmp(properties_.error_bar_cap_style, "Straight")==0)
|
||
|
|
{
|
||
|
|
if (dy1[n] > 0)
|
||
|
|
{
|
||
|
|
const ImVec2 error_high_left = ImVec2(centre_scaled_x - properties_.error_bar_cap_width * 0.5,
|
||
|
|
figure.GetScalesY()->Scale(y_data[n] + error_bottoms[n] + dy1[n]));
|
||
|
|
const ImVec2 error_high_right = ImVec2(centre_scaled_x + properties_.error_bar_cap_width * 0.5,
|
||
|
|
figure.GetScalesY()->Scale(y_data[n] + error_bottoms[n] + dy1[n]));
|
||
|
|
window->DrawList->AddLine(error_high_left, error_high_right, properties_.error_bar_stroke_col, properties_.error_bar_stroke_width);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (dy2[n] > 0)
|
||
|
|
{
|
||
|
|
const ImVec2 error_low_left = ImVec2(centre_scaled_x - properties_.error_bar_cap_width * 0.5,
|
||
|
|
figure.GetScalesY()->Scale(y_data[n] + error_bottoms[n] - dy2[n]));
|
||
|
|
const ImVec2 error_low_right = ImVec2(centre_scaled_x + properties_.error_bar_cap_width * 0.5,
|
||
|
|
figure.GetScalesY()->Scale(y_data[n] + error_bottoms[n] - dy2[n]));
|
||
|
|
window->DrawList->AddLine(error_low_left, error_low_right, properties_.error_bar_stroke_col, properties_.error_bar_stroke_width);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
void SetProperties(ImErrorBarProperties& properties){properties_ = properties;}
|
||
|
|
|
||
|
|
private:
|
||
|
|
ImErrorBarProperties properties_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ## Labels (for e.g., scatter plot)
|
||
|
|
struct ImLabelProperties
|
||
|
|
{
|
||
|
|
ImFont* label_font = NULL; ///< Label font
|
||
|
|
ImU32 label_font_col = 0; ///< Label font color
|
||
|
|
float label_font_size = 12.0f; ///< Label font size
|
||
|
|
ImVec2 label_offset_pos = ImVec2(0.0f, 0.0f); ///< Offset position of the label
|
||
|
|
};
|
||
|
|
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImLabels
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
/**
|
||
|
|
* @brief Draw Labels
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param x_data
|
||
|
|
* @param y_data
|
||
|
|
* @param n_data
|
||
|
|
* @param labels Label for each data point of length n (matching order of x/y_data)
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawLabels(ImPlot<Ta, Tb>& figure,
|
||
|
|
const Ta* x_data, const Tb* y_data, const int& n_data, const char* labels[],
|
||
|
|
const Ta& x_offset, const Tb& y_offset, const Ta* x_bottoms, const Ta* y_bottoms)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
ImGuiContext& g = *GImGui;
|
||
|
|
|
||
|
|
if (labels == NULL) return;
|
||
|
|
|
||
|
|
for (int n = 0; n < n_data; ++n)
|
||
|
|
{
|
||
|
|
// labels
|
||
|
|
const float centre_scaled_x = figure.GetScalesX()->Scale(x_data[n] + x_bottoms[0]) + x_offset;
|
||
|
|
const float centre_scaled_y = figure.GetScalesY()->Scale(y_data[n] + y_bottoms[0]) + y_offset;
|
||
|
|
window->DrawList->AddText(properties_.label_font, properties_.label_font_size, ImVec2(centre_scaled_x, centre_scaled_y), properties_.label_font_col, labels[n]);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
void DrawLabels(ImPlot<Ta, Tb>& figure,
|
||
|
|
const Ta* x_data, const Tb* y_data, const int& n_data, const char* labels[])
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
if (labels == NULL) return;
|
||
|
|
|
||
|
|
for (int n = 0; n < n_data; ++n)
|
||
|
|
{
|
||
|
|
// labels
|
||
|
|
const float centre_scaled_x = figure.GetScalesX()->Scale(x_data[n]);
|
||
|
|
const float centre_scaled_y = figure.GetScalesY()->Scale(y_data[n]);
|
||
|
|
window->DrawList->AddText(properties_.label_font, properties_.label_font_size, ImVec2(centre_scaled_x, centre_scaled_y), properties_.label_font_col, labels[n]);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
void SetProperties(ImLabelProperties& properties){properties_ = properties;}
|
||
|
|
private:
|
||
|
|
ImLabelProperties properties_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ## Markers (for e.g., scatter plot)
|
||
|
|
struct ImMarkerProperties
|
||
|
|
{
|
||
|
|
ImU32 marker_stroke_col = 0; ///< circle (or other symbol) stroke color
|
||
|
|
float marker_stroke_width = 1.0f; ///< circle (or other symbol) stroke width
|
||
|
|
ImU32 marker_fill_col = 0; ///< circle (or other symbol) fill color
|
||
|
|
ImU32 marker_hovered_col = 0; ///< circle (or other symbol) fill color on hover
|
||
|
|
// char* tool_tip_format = "%4.2f"; ///< tooltip format
|
||
|
|
};
|
||
|
|
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImMarkers
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
/**
|
||
|
|
* @brief Draw Markers
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param x_data
|
||
|
|
* @param y_data
|
||
|
|
* @param r_data Radius of the markers
|
||
|
|
* @param n_data
|
||
|
|
* @param series Name of the marker series (used for tooltip)
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawMarkers(ImPlot<Ta, Tb>& figure,
|
||
|
|
const Ta* x_data, const Tb* y_data, const float* r_data, const int& n_data,
|
||
|
|
const char* series)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
ImGuiContext& g = *GImGui;
|
||
|
|
|
||
|
|
for (int n = 0; n < n_data; ++n)
|
||
|
|
{
|
||
|
|
// Points
|
||
|
|
const float centre_scaled_x = figure.GetScalesX()->Scale(x_data[n]);
|
||
|
|
const float centre_scaled_y = figure.GetScalesY()->Scale(y_data[n]);
|
||
|
|
window->DrawList->AddCircleFilled(ImVec2(centre_scaled_x, centre_scaled_y), r_data[n], properties_.marker_fill_col, 12);
|
||
|
|
|
||
|
|
// Tooltip on hover
|
||
|
|
if (centre_scaled_x - r_data[n] <= g.IO.MousePos.x &&
|
||
|
|
centre_scaled_x + r_data[n] >= g.IO.MousePos.x &&
|
||
|
|
centre_scaled_y - r_data[n] <= g.IO.MousePos.y &&
|
||
|
|
centre_scaled_y + r_data[n] >= g.IO.MousePos.y)
|
||
|
|
{
|
||
|
|
SetTooltip("%s\n%s: %8.4g\n%s: %8.4g", series, "x", x_data[n], "y", y_data[n]);
|
||
|
|
window->DrawList->AddCircleFilled(ImVec2(centre_scaled_x, centre_scaled_y), r_data[n], properties_.marker_hovered_col, 12);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
void SetProperties(ImMarkerProperties& properties){properties_ = properties;}
|
||
|
|
private:
|
||
|
|
ImMarkerProperties properties_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ## Lines (for e.g., line plot)
|
||
|
|
struct ImLineProperties
|
||
|
|
{
|
||
|
|
ImU32 line_stroke_col = 0; ///< line stroke color
|
||
|
|
float line_stroke_width = 1.5f; ///< line stroke width
|
||
|
|
float line_stroke_dash = 0.0f; ///< spacing of the dash
|
||
|
|
float line_stroke_gap = 0.0f; ///< spacing between dashes
|
||
|
|
const char* line_interp = "None"; ///< "None" for a straight line and "Bezier" for a curved line
|
||
|
|
};
|
||
|
|
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImLines
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
/**
|
||
|
|
* @brief Draw Lines
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param x_data
|
||
|
|
* @param y_data
|
||
|
|
* @param n_data
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawLines(ImPlot<Ta, Tb>& figure,
|
||
|
|
const Ta* x_data, const Tb* y_data, const int& n_data)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
ImGuiContext& g = *GImGui;
|
||
|
|
|
||
|
|
std::vector<int> xx;
|
||
|
|
std::vector<int> yy;
|
||
|
|
xx.push_back(int(figure.GetScalesX()->Scale(x_data[0])));
|
||
|
|
yy.push_back(int(figure.GetScalesY()->Scale(y_data[0])));
|
||
|
|
for (int i = 1; i < n_data; i++) {
|
||
|
|
if (int(figure.GetScalesX()->Scale(x_data[i])) == xx.back())
|
||
|
|
yy.back() = (yy.back() + int(figure.GetScalesY()->Scale(y_data[i]))) / 2;
|
||
|
|
else {
|
||
|
|
xx.push_back(int(figure.GetScalesX()->Scale(x_data[i])));
|
||
|
|
yy.push_back(int(figure.GetScalesY()->Scale(y_data[i])));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
OutputDebugString((to_string(n_data) + "->" + to_string(xx.size()) + "\n").c_str());
|
||
|
|
|
||
|
|
for (unsigned int n = 1; n < xx.size(); ++n)
|
||
|
|
{
|
||
|
|
// Line
|
||
|
|
if (n > 0 && strcmp(properties_.line_interp, "None") == 0)
|
||
|
|
{
|
||
|
|
window->DrawList->AddLine(
|
||
|
|
ImVec2(xx[n - 1], yy[n - 1]),
|
||
|
|
ImVec2(xx[n], yy[n]),
|
||
|
|
properties_.line_stroke_col, properties_.line_stroke_width);
|
||
|
|
}
|
||
|
|
else if (n > 0 && strcmp(properties_.line_interp, "Bezier") == 0)
|
||
|
|
{
|
||
|
|
// TODO
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (g.IO.MousePos.x >= figure.GetScalesX()->GetRangeMin() && g.IO.MousePos.x <= figure.GetScalesX()->GetRangeMax() &&
|
||
|
|
g.IO.MousePos.y >= figure.GetScalesY()->GetRangeMax() && g.IO.MousePos.y <= figure.GetScalesY()->GetRangeMin())
|
||
|
|
{
|
||
|
|
window->DrawList->AddLine(
|
||
|
|
ImVec2(g.IO.MousePos.x, figure.GetScalesY()->GetRangeMin()),
|
||
|
|
ImVec2(g.IO.MousePos.x, figure.GetScalesY()->GetRangeMax()),
|
||
|
|
ImGui::ColorConvertFloat4ToU32(ImVec4(255.0f, 255.0f, 255.0f, 100.0f)), properties_.line_stroke_width);
|
||
|
|
|
||
|
|
for (unsigned int n = 1; n < xx.size(); ++n)
|
||
|
|
{
|
||
|
|
if (g.IO.MousePos.x >= xx[n - 1] && g.IO.MousePos.x <= xx[n])
|
||
|
|
{
|
||
|
|
int idx;
|
||
|
|
if (g.IO.MousePos.x == xx[n - 1] || g.IO.MousePos.x < (xx[n] - xx[n - 1]) / 2)
|
||
|
|
idx = n - 1;
|
||
|
|
else
|
||
|
|
idx = n;
|
||
|
|
idx = idx * n_data / xx.size();
|
||
|
|
BeginTooltipEx(0, false);
|
||
|
|
ImGui::Text("x: %.3f", x_data[idx]);
|
||
|
|
ImGui::Text("y: %.3f", y_data[idx]);
|
||
|
|
EndTooltip();
|
||
|
|
window->DrawList->AddCircleFilled(ImVec2(xx[n], yy[n]), 5, ImGui::ColorConvertFloat4ToU32(ImVec4(0.0f, 255.0f, 0.0f, 100.0f)), 12);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
void SetProperties(ImLineProperties& properties){properties_ = properties;}
|
||
|
|
private:
|
||
|
|
ImLineProperties properties_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ## Bars (for e.g., bar plot)
|
||
|
|
struct ImBarProperties
|
||
|
|
{
|
||
|
|
float bar_width = 10.0f;
|
||
|
|
ImU32 bar_stroke_col = 0;
|
||
|
|
float bar_stroke_width = 1.0f;
|
||
|
|
ImU32 bar_fill_col = 0;
|
||
|
|
ImU32 bar_hovered_col = 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Bar plots. The orientiation of the bars is specified
|
||
|
|
* by the `orientiation` parameter. Stacked or Staggered bar
|
||
|
|
* representations are controlled manually by the user via
|
||
|
|
* the `bar_bottoms` and `bar_offset` parameters.
|
||
|
|
*/
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImBars
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
/**
|
||
|
|
* @brief Draw vertical Bars
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param y_data
|
||
|
|
* @param n_data
|
||
|
|
* @param series Name of the marker series (used for tooltip)
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawBars(ImPlot<Ta, Tb>& figure,
|
||
|
|
const Tb* y_data, const int& n_data,
|
||
|
|
const Ta& bar_offset, const Tb* bar_bottoms,
|
||
|
|
const char* series)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
ImGuiContext& g = *GImGui;
|
||
|
|
|
||
|
|
const float bar_span = (figure.GetScalesX()->GetRangeMax() - figure.GetScalesX()->GetRangeMin())/(n_data - 1);
|
||
|
|
for (int n = 0; n < n_data; ++n)
|
||
|
|
{
|
||
|
|
// Bars
|
||
|
|
// const ImVec2 bar_BL = ImVec2(figure.GetScalesX()->GetRangeMin() + n*bar_span + bar_offset,
|
||
|
|
// figure.GetScalesY()->GetRangeMin() + figure.GetScalesY()->Scale(bar_bottoms[n]));
|
||
|
|
// const ImVec2 bar_TR = ImVec2(figure.GetScalesX()->GetRangeMin() + n*bar_span + properties_.bar_width + bar_offset,
|
||
|
|
// figure.GetScalesY()->GetRangeMin() + figure.GetScalesY()->Scale(bar_bottoms[n] + y_data[n]));
|
||
|
|
const ImVec2 bar_BL = ImVec2(figure.GetScalesX()->GetRangeMin() + n*bar_span + bar_offset,
|
||
|
|
figure.GetScalesY()->Scale(bar_bottoms[n]));
|
||
|
|
const ImVec2 bar_TR = ImVec2(figure.GetScalesX()->GetRangeMin() + n*bar_span + properties_.bar_width + bar_offset,
|
||
|
|
figure.GetScalesY()->Scale(bar_bottoms[n] + y_data[n]));
|
||
|
|
window->DrawList->AddRectFilled(bar_BL, bar_TR, properties_.bar_fill_col);
|
||
|
|
|
||
|
|
// printf("BL: %f, %f; TR: %f, %f", bar_BL.x, bar_BL.y, bar_TR.x, bar_TR.y);
|
||
|
|
// system("pause");
|
||
|
|
|
||
|
|
// Tooltip on hover
|
||
|
|
if (bar_BL.x <= g.IO.MousePos.x &&
|
||
|
|
bar_TR.x >= g.IO.MousePos.x &&
|
||
|
|
bar_BL.y >= g.IO.MousePos.y &&
|
||
|
|
bar_TR.y <= g.IO.MousePos.y)
|
||
|
|
{
|
||
|
|
SetTooltip("%s\n%s: %8.4g", series, "y", y_data[n]);
|
||
|
|
window->DrawList->AddRectFilled(bar_BL, bar_TR, properties_.bar_hovered_col);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Draw horizontal Bars
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param y_data
|
||
|
|
* @param n_data
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawBarsH(ImPlot<Ta, Tb>& figure,
|
||
|
|
const Ta* x_data, const int& n_data,
|
||
|
|
const Tb& bar_offset, const Ta* bar_bottoms,
|
||
|
|
const char* series)
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
ImGuiContext& g = *GImGui;
|
||
|
|
|
||
|
|
const float bar_span = (figure.GetScalesY()->GetRangeMax() - figure.GetScalesY()->GetRangeMin())/(n_data - 1);
|
||
|
|
for (int n = 0; n < n_data; ++n)
|
||
|
|
{
|
||
|
|
// Bars
|
||
|
|
// const ImVec2 bar_BL = ImVec2(figure.GetScalesX()->GetRangeMin() + n*bar_span + bar_offset,
|
||
|
|
// figure.GetScalesY()->GetRangeMin() + figure.GetScalesY()->Scale(bar_bottoms[n]));
|
||
|
|
// const ImVec2 bar_TR = ImVec2(figure.GetScalesX()->GetRangeMin() + n*bar_span + properties_.bar_width + bar_offset,
|
||
|
|
// figure.GetScalesY()->GetRangeMin() + figure.GetScalesY()->Scale(bar_bottoms[n] + y_data[n]));
|
||
|
|
const ImVec2 bar_BL = ImVec2(figure.GetScalesX()->Scale(bar_bottoms[n]),
|
||
|
|
figure.GetScalesY()->GetRangeMin() + n*bar_span + bar_offset);
|
||
|
|
const ImVec2 bar_TR = ImVec2(figure.GetScalesX()->Scale(bar_bottoms[n] + x_data[n]),
|
||
|
|
figure.GetScalesY()->GetRangeMin() + n*bar_span + properties_.bar_width + bar_offset);
|
||
|
|
window->DrawList->AddRectFilled(bar_BL, bar_TR, properties_.bar_fill_col);
|
||
|
|
|
||
|
|
// printf("BL: %f, %f; TR: %f, %f", bar_BL.x, bar_BL.y, bar_TR.x, bar_TR.y);
|
||
|
|
// system("pause");
|
||
|
|
|
||
|
|
// Tooltip on hover
|
||
|
|
if (bar_BL.x <= g.IO.MousePos.x &&
|
||
|
|
bar_TR.x >= g.IO.MousePos.x &&
|
||
|
|
bar_BL.y <= g.IO.MousePos.y &&
|
||
|
|
bar_TR.y >= g.IO.MousePos.y)
|
||
|
|
{
|
||
|
|
SetTooltip("%s\n%s: %8.4g", series, "x", x_data[n]);
|
||
|
|
window->DrawList->AddRectFilled(bar_BL, bar_TR, properties_.bar_hovered_col);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
void SetProperties(ImBarProperties& properties){properties_ = properties;}
|
||
|
|
private:
|
||
|
|
ImBarProperties properties_;
|
||
|
|
};
|
||
|
|
|
||
|
|
struct ImAreaProperties
|
||
|
|
{
|
||
|
|
ImU32 area_fill_col = 0;
|
||
|
|
ImU32 area_hover_col = 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImArea
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
void DrawArea(
|
||
|
|
ImPlot<Ta, Tb>& figure,
|
||
|
|
const Ta* x_data,
|
||
|
|
const Tb* y_data,
|
||
|
|
const size_t n_data,
|
||
|
|
const Tb * y_data_bottoms,
|
||
|
|
const char* series = NULL
|
||
|
|
)
|
||
|
|
{
|
||
|
|
if (n_data < 2) return;
|
||
|
|
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
ImDrawList* dl = window->DrawList;
|
||
|
|
dl->PathLineTo(ImVec2(figure.GetScalesX()->Scale(x_data[0]), figure.GetScalesY()->Scale(y_data_bottoms[0])));
|
||
|
|
|
||
|
|
for (size_t i = 0; i < n_data; ++i)
|
||
|
|
dl->PathLineTo(ImVec2(figure.GetScalesX()->Scale(x_data[i]), figure.GetScalesY()->Scale(y_data_bottoms[i] + y_data[i])));
|
||
|
|
|
||
|
|
dl->PathLineTo(ImVec2(figure.GetScalesX()->Scale(x_data[n_data-1]), figure.GetScalesY()->Scale(y_data_bottoms[n_data-1])));
|
||
|
|
|
||
|
|
ImVec2 pointer(GImGui->IO.MousePos.x, GImGui->IO.MousePos.y);
|
||
|
|
|
||
|
|
const bool check = is_inside_area(pointer, dl->_Path);
|
||
|
|
|
||
|
|
if (check && series) {
|
||
|
|
SetTooltip("%s", series);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (check && properties_.area_hover_col) {
|
||
|
|
dl->PathFillConvex(properties_.area_hover_col);
|
||
|
|
}
|
||
|
|
|
||
|
|
dl->PathFillConvex(properties_.area_fill_col);
|
||
|
|
};
|
||
|
|
|
||
|
|
void SetProperties(ImAreaProperties& properties)
|
||
|
|
{
|
||
|
|
properties_ = properties;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
ImAreaProperties properties_;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// # High level plotting functions
|
||
|
|
|
||
|
|
// ## Charts
|
||
|
|
// ### Basics
|
||
|
|
// - Line
|
||
|
|
// - Scatter
|
||
|
|
// - Bar (stacked)
|
||
|
|
// - Barh
|
||
|
|
// - BoxPlot
|
||
|
|
// - Area (stacked)
|
||
|
|
// - Heatmap
|
||
|
|
// - Histogram (density and binning)
|
||
|
|
// ### Advanced
|
||
|
|
// - Contour
|
||
|
|
// - Stem
|
||
|
|
// - Stream
|
||
|
|
// - Polar
|
||
|
|
// - Radar
|
||
|
|
// - Hexagonal binning
|
||
|
|
// - Histogram 2D
|
||
|
|
// - Violin
|
||
|
|
// - Joint
|
||
|
|
// - Strip
|
||
|
|
// - Swarm
|
||
|
|
|
||
|
|
// ## Pie (for e.g., pie or donught plot)
|
||
|
|
struct ImPieProperties
|
||
|
|
{
|
||
|
|
float inner_radius = 0.0f; ///< change to create a donught plot
|
||
|
|
float outer_radius = 100.0f; ///< controls the size of the pie
|
||
|
|
ImU32 pie_stroke_col = 0;
|
||
|
|
float pie_stroke_width = 1.0f;
|
||
|
|
ImU32 pie_hovered_col = 0;
|
||
|
|
int pie_segments = 128; ///< number of segments to use when drawing the circle
|
||
|
|
// if this is too low, the segment will not be drawn!
|
||
|
|
};
|
||
|
|
|
||
|
|
template<typename Ta, typename Tb>
|
||
|
|
class ImPie
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
/**
|
||
|
|
* @brief Draw Pie
|
||
|
|
*
|
||
|
|
* @param figure The figure to draw on
|
||
|
|
* @param x_data Numerical values
|
||
|
|
* @param y_data Color used for each of the pie segments
|
||
|
|
* @param n_data
|
||
|
|
* @param series Name of the pie segment series (used for tooltip)
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void DrawPie(ImPlot<Ta, Tb>& figure,
|
||
|
|
const Ta* x_data, const ImU32* colors, const int& n_data, const char* series[])
|
||
|
|
{
|
||
|
|
ImGuiWindow* window = GetCurrentWindow();
|
||
|
|
if (window->SkipItems)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// calculate the total x
|
||
|
|
float x_data_total = 0;
|
||
|
|
for (int n = 0; n < n_data; ++n)
|
||
|
|
x_data_total += x_data[n];
|
||
|
|
|
||
|
|
// add each arc
|
||
|
|
float x_data_prev_rad = 0.0f;
|
||
|
|
for (int n = 0; n < n_data; ++n)
|
||
|
|
{
|
||
|
|
const float x_data_rad = IM_PI*2.0f*x_data[n]/x_data_total + x_data_prev_rad; // convert x_data to radians
|
||
|
|
const int n_segments = (int)ceilf(x_data[n]/x_data_total*(float)properties_.pie_segments); // determine the number of segments
|
||
|
|
const ImVec2 centre = ImVec2(
|
||
|
|
(figure.GetScalesX()->GetRangeMin() + figure.GetScalesX()->GetRangeMax())/2,
|
||
|
|
(figure.GetScalesY()->GetRangeMin() + figure.GetScalesY()->GetRangeMax())/2
|
||
|
|
);
|
||
|
|
|
||
|
|
// // line 1
|
||
|
|
// const ImVec2 vec_line_start = ImVec2(
|
||
|
|
// ImCos(x_data_prev_rad)*properties_.inner_radius + centre.x,
|
||
|
|
// ImSin(x_data_prev_rad)*properties_.inner_radius + centre.y);
|
||
|
|
// const ImVec2 vec_line_end = ImVec2(
|
||
|
|
// ImCos(x_data_prev_rad)*properties_.outer_radius + centre.x,
|
||
|
|
// ImSin(x_data_prev_rad)*properties_.outer_radius + centre.y);
|
||
|
|
|
||
|
|
// start: end of the outer arc. end: start of the inner arc
|
||
|
|
const ImVec2 vec1 = ImVec2(
|
||
|
|
ImCos(x_data_rad)*properties_.inner_radius + centre.x,
|
||
|
|
ImSin(x_data_rad)*properties_.inner_radius + centre.y);
|
||
|
|
|
||
|
|
// start: end of the inner arc. end: start of the outer arc
|
||
|
|
const ImVec2 vec2 = ImVec2(
|
||
|
|
ImCos(x_data_prev_rad)*properties_.outer_radius + centre.x,
|
||
|
|
ImSin(x_data_prev_rad)*properties_.outer_radius + centre.y);
|
||
|
|
|
||
|
|
// draw the pie segment
|
||
|
|
// window->DrawList->AddLine(vec_line_start, vec_line_end, ImGui::ColorConvertFloat4ToU32(ImVec4(255.0f, 255.0f, 255.0f, 255.0f)));
|
||
|
|
window->DrawList->PathArcTo(centre, properties_.outer_radius, x_data_prev_rad, x_data_rad, n_segments); // outer arc
|
||
|
|
window->DrawList->PathLineTo(vec1); // start outer to inner arc line
|
||
|
|
window->DrawList->PathArcTo(centre, properties_.inner_radius, x_data_rad, x_data_prev_rad, n_segments); // inner arc
|
||
|
|
window->DrawList->PathLineTo(vec2); // end inner arc to outer arc line
|
||
|
|
window->DrawList->PathFillConvex(colors[n]);
|
||
|
|
|
||
|
|
// draw the tooltip
|
||
|
|
// [BUG: there appears to be a "gap" in the convex hull...]
|
||
|
|
if (is_inside_area(ImVec2(GImGui->IO.MousePos.x, GImGui->IO.MousePos.y), window->DrawList->_Path)) {
|
||
|
|
SetTooltip("%s\n%s: %8.4g", series[n], "x", x_data[n]);
|
||
|
|
window->DrawList->PathFillConvex(properties_.pie_hovered_col);
|
||
|
|
}
|
||
|
|
|
||
|
|
x_data_prev_rad = x_data_rad;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void SetProperties(ImPieProperties& properties){properties_ = properties;}
|
||
|
|
private:
|
||
|
|
ImPieProperties properties_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ## Layouts and hierarchies
|
||
|
|
// - Pie
|
||
|
|
// - circos layout
|
||
|
|
// - swim lanes
|
||
|
|
// - bundle diagram
|
||
|
|
// - chord diagram
|
||
|
|
// - force directed graph
|
||
|
|
// - force layout
|
||
|
|
// - indented tree layout
|
||
|
|
// - pack layout
|
||
|
|
// - partition layout
|
||
|
|
// - radial dendrogram
|
||
|
|
// - radial tree layout
|
||
|
|
// - sankey diagram
|
||
|
|
// - treemap layout
|
||
|
|
// - vertical dendrogram
|
||
|
|
}
|