gwm17/implot
1
0
Fork 0
mirror of https://github.com/gwm17/implot.git synced 2024-10-09 23:57:26 -04:00
Code Issues Projects Releases Wiki Activity

double precision work complete

Browse Source
This commit is contained in:
Evan Pezent 2020-05-29 12:39:30 -05:00
parent 5e82afdbdd
commit 43625257b0
3 changed files with 544 additions and 347 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

517
implot.cpp
View File

@ -20,7 +20,7 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE. // SOFTWARE.
// ImPlot v0.2 WIP // ImPlot v0.3 WIP
/* /*
@ -31,6 +31,7 @@ Below is a change-log of API breaking changes only. If you are using one of the
When you are not sure about a old symbol or function name, try using the Search/Find function of your IDE to look for comments or references in all implot files. When you are not sure about a old symbol or function name, try using the Search/Find function of your IDE to look for comments or references in all implot files.
You can read releases logs https://github.com/epezent/implot/releases for more details. You can read releases logs https://github.com/epezent/implot/releases for more details.
- 2020/05/29 (0.3) - The signature of ImPlotLimits::Contains was changed to take two doubles instead of ImVec2
- 2020/05/16 (0.2) - All plotting functions were reverted to being prefixed with "Plot" to maintain a consistent VerbNoun style. `Plot` was split into `PlotLine` - 2020/05/16 (0.2) - All plotting functions were reverted to being prefixed with "Plot" to maintain a consistent VerbNoun style. `Plot` was split into `PlotLine`
and `PlotScatter` (however, `PlotLine` can still be used to plot scatter points as `Plot` did before.). `Bar` is not `PlotBars`, to indicate and `PlotScatter` (however, `PlotLine` can still be used to plot scatter points as `Plot` did before.). `Bar` is not `PlotBars`, to indicate
that multiple bars will be plotted. that multiple bars will be plotted.
@ -78,6 +79,9 @@ You can read releases logs https://github.com/epezent/implot/releases for more d
// The maximum number of support y-axes // The maximum number of support y-axes
#define MAX_Y_AXES 3 #define MAX_Y_AXES 3
// static inline float ImLog10(float x) { return log10f(x); }
static inline double ImLog10(double x) { return log10(x); }
ImPlotStyle::ImPlotStyle() { ImPlotStyle::ImPlotStyle() {
LineWeight = 1; LineWeight = 1;
Marker = ImPlotMarker_None; Marker = ImPlotMarker_None;
@ -108,18 +112,18 @@ ImPlotRange::ImPlotRange() {
Max = NAN; Max = NAN;
} }
bool ImPlotRange::Contains(ImPlotFloat v) const { bool ImPlotRange::Contains(double v) const {
return v >= Min && v <= Max; return v >= Min && v <= Max;
} }
ImPlotFloat ImPlotRange::Size() const { double ImPlotRange::Size() const {
return Max - Min; return Max - Min;
} }
ImPlotLimits::ImPlotLimits() {} ImPlotLimits::ImPlotLimits() {}
bool ImPlotLimits::Contains(const ImVec2& p) const { bool ImPlotLimits::Contains(double x, double y) const {
return X.Contains(p.x) && Y.Contains(p.y); return X.Contains(x) && Y.Contains(y);
} }
namespace ImPlot { namespace ImPlot {
@ -130,30 +134,6 @@ namespace {
// Private Utils // Private Utils
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
template <typename F>
struct FloatProps {
static inline F Min();
static inline F Max();
static inline F Eps();
static inline F Inf();
};
template <>
struct FloatProps<float> {
static inline float Min() { return FLT_MIN; }
static inline float Max() { return FLT_MAX; }
static inline float Eps() { return FLT_EPSILON; }
static inline float Inf() { return HUGE_VALF; }
};
template <>
struct FloatProps<double> {
static inline double Min() { return DBL_MIN; }
static inline double Max() { return DBL_MAX; }
static inline double Eps() { return DBL_EPSILON; }
static inline double Inf() { return HUGE_VAL; }
};
/// Returns true if a flag is set /// Returns true if a flag is set
template <typename TSet, typename TFlag> template <typename TSet, typename TFlag>
inline bool HasFlag(TSet set, TFlag flag) { inline bool HasFlag(TSet set, TFlag flag) {
@ -172,23 +152,23 @@ inline float Remap(float x, float x0, float x1, float y0, float y1) {
} }
/// Turns NANs to 0s /// Turns NANs to 0s
inline ImPlotFloat ConstrainNan(ImPlotFloat val) { inline double ConstrainNan(double val) {
return isnan(val) ? 0 : val; return isnan(val) ? 0 : val;
} }
/// Turns infinity to floating point maximums /// Turns infinity to floating point maximums
inline ImPlotFloat ConstrainInf(ImPlotFloat val) { inline double ConstrainInf(double val) {
return val == FloatProps<ImPlotFloat>::Inf() ? FloatProps<ImPlotFloat>::Max() : val == -FloatProps<ImPlotFloat>::Inf() ? - FloatProps<ImPlotFloat>::Max() : val; return val == HUGE_VAL ? DBL_MAX : val == -HUGE_VAL ? - DBL_MAX : val;
} }
/// Turns numbers less than or equal to 0 to 0.001 (sort of arbitrary, is there a better way?) /// Turns numbers less than or equal to 0 to 0.001 (sort of arbitrary, is there a better way?)
inline ImPlotFloat ConstrainLog(ImPlotFloat val) { inline double ConstrainLog(double val) {
return val <= 0 ? 0.001f : val; return val <= 0 ? 0.001f : val;
} }
/// Returns true if val is NAN or INFINITY /// Returns true if val is NAN or INFINITY
inline bool NanOrInf(ImPlotFloat val) { inline bool NanOrInf(double val) {
return val == FloatProps<ImPlotFloat>::Inf() || val == -FloatProps<ImPlotFloat>::Inf() || isnan(val); return val == HUGE_VAL || val == -HUGE_VAL || isnan(val);
} }
/// Utility function to that rounds x to powers of 2,5 and 10 for generating axis labels /// Utility function to that rounds x to powers of 2,5 and 10 for generating axis labels
@ -196,7 +176,7 @@ inline bool NanOrInf(ImPlotFloat val) {
inline double NiceNum(double x, bool round) { inline double NiceNum(double x, bool round) {
double f; /* fractional part of x */ double f; /* fractional part of x */
double nf; /* nice, rounded fraction */ double nf; /* nice, rounded fraction */
int expv = (int)floor(log10(x)); int expv = (int)floor(ImLog10(x));
f = x / ImPow(10.0, (double)expv); /* between 1 and 10 */ f = x / ImPow(10.0, (double)expv); /* between 1 and 10 */
if (round) if (round)
if (f < 1.5) if (f < 1.5)
@ -260,12 +240,12 @@ ImVec4 NextColor();
/// Tick mark info /// Tick mark info
struct ImTick { struct ImTick {
ImTick(ImPlotFloat value, bool major, bool render_label = true) { ImTick(double value, bool major, bool render_label = true) {
PlotPos = value; PlotPos = value;
Major = major; Major = major;
RenderLabel = render_label; RenderLabel = render_label;
} }
ImPlotFloat PlotPos; double PlotPos;
float PixelPos; float PixelPos;
ImVec2 Size; ImVec2 Size;
int TextOffset; int TextOffset;
@ -380,11 +360,11 @@ struct ImPlotContext {
// Transformation cache // Transformation cache
ImRect PixelRange[MAX_Y_AXES]; ImRect PixelRange[MAX_Y_AXES];
// linear scale (slope) // linear scale (slope)
ImPlotFloat Mx; double Mx;
ImPlotFloat My[MAX_Y_AXES]; double My[MAX_Y_AXES];
// log scale denominator // log scale denominator
ImPlotFloat LogDenX; double LogDenX;
ImPlotFloat LogDenY[MAX_Y_AXES]; double LogDenY[MAX_Y_AXES];
// Data extents // Data extents
ImPlotRange ExtentsX; ImPlotRange ExtentsX;
ImPlotRange ExtentsY[MAX_Y_AXES]; ImPlotRange ExtentsY[MAX_Y_AXES];
@ -451,9 +431,9 @@ inline void UpdateTransformCache() {
gp.My[i] = (gp.PixelRange[i].Max.y - gp.PixelRange[i].Min.y) / gp.CurrentPlot->YAxis[i].Range.Size(); gp.My[i] = (gp.PixelRange[i].Max.y - gp.PixelRange[i].Min.y) / gp.CurrentPlot->YAxis[i].Range.Size();
} }
gp.LogDenX = log10(gp.CurrentPlot->XAxis.Range.Max / gp.CurrentPlot->XAxis.Range.Min); gp.LogDenX = ImLog10(gp.CurrentPlot->XAxis.Range.Max / gp.CurrentPlot->XAxis.Range.Min);
for (int i = 0; i < MAX_Y_AXES; i++) { for (int i = 0; i < MAX_Y_AXES; i++) {
gp.LogDenY[i] = log10(gp.CurrentPlot->YAxis[i].Range.Max / gp.CurrentPlot->YAxis[i].Range.Min); gp.LogDenY[i] = ImLog10(gp.CurrentPlot->YAxis[i].Range.Max / gp.CurrentPlot->YAxis[i].Range.Min);
} }
gp.Mx = (gp.PixelRange[0].Max.x - gp.PixelRange[0].Min.x) / gp.CurrentPlot->XAxis.Range.Size(); gp.Mx = (gp.PixelRange[0].Max.x - gp.PixelRange[0].Min.x) / gp.CurrentPlot->XAxis.Range.Size();
} }
@ -465,12 +445,12 @@ inline ImPlotPoint PixelsToPlot(float x, float y, int y_axis_in = -1) {
plt.x = (x - gp.PixelRange[y_axis].Min.x) / gp.Mx + gp.CurrentPlot->XAxis.Range.Min; plt.x = (x - gp.PixelRange[y_axis].Min.x) / gp.Mx + gp.CurrentPlot->XAxis.Range.Min;
plt.y = (y - gp.PixelRange[y_axis].Min.y) / gp.My[y_axis] + gp.CurrentPlot->YAxis[y_axis].Range.Min; plt.y = (y - gp.PixelRange[y_axis].Min.y) / gp.My[y_axis] + gp.CurrentPlot->YAxis[y_axis].Range.Min;
if (HasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_LogScale)) { if (HasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_LogScale)) {
ImPlotFloat t = (plt.x - gp.CurrentPlot->XAxis.Range.Min) / gp.CurrentPlot->XAxis.Range.Size(); double t = (plt.x - gp.CurrentPlot->XAxis.Range.Min) / gp.CurrentPlot->XAxis.Range.Size();
plt.x = pow(10.0f, t * gp.LogDenX) * gp.CurrentPlot->XAxis.Range.Min; plt.x = ImPow(10, t * gp.LogDenX) * gp.CurrentPlot->XAxis.Range.Min;
} }
if (HasFlag(gp.CurrentPlot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) { if (HasFlag(gp.CurrentPlot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) {
ImPlotFloat t = (plt.y - gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.CurrentPlot->YAxis[y_axis].Range.Size(); double t = (plt.y - gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.CurrentPlot->YAxis[y_axis].Range.Size();
plt.y = pow(10.0f, t * gp.LogDenY[y_axis]) * gp.CurrentPlot->YAxis[y_axis].Range.Min; plt.y = ImPow(10, t * gp.LogDenY[y_axis]) * gp.CurrentPlot->YAxis[y_axis].Range.Min;
} }
return plt; return plt;
} }
@ -480,16 +460,16 @@ ImPlotPoint PixelsToPlot(const ImVec2& pix, int y_axis) {
} }
// This function is convenient but should not be used to process a high volume of points. Use the Transformer structs below instead. // This function is convenient but should not be used to process a high volume of points. Use the Transformer structs below instead.
inline ImVec2 PlotToPixels(ImPlotFloat x, ImPlotFloat y, int y_axis_in = -1) { inline ImVec2 PlotToPixels(double x, double y, int y_axis_in = -1) {
IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "PlotToPixels() Needs to be called between BeginPlot() and EndPlot()!"); IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "PlotToPixels() Needs to be called between BeginPlot() and EndPlot()!");
const int y_axis = y_axis_in >= 0 ? y_axis_in : gp.CurrentPlot->CurrentYAxis; const int y_axis = y_axis_in >= 0 ? y_axis_in : gp.CurrentPlot->CurrentYAxis;
ImVec2 pix; ImVec2 pix;
if (HasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_LogScale)) { if (HasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_LogScale)) {
ImPlotFloat t = log10(x / gp.CurrentPlot->XAxis.Range.Min) / gp.LogDenX; double t = ImLog10(x / gp.CurrentPlot->XAxis.Range.Min) / gp.LogDenX;
x = ImLerp(gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max, (float)t); x = ImLerp(gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max, (float)t);
} }
if (HasFlag(gp.CurrentPlot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) { if (HasFlag(gp.CurrentPlot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) {
ImPlotFloat t = log10(y / gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.LogDenY[y_axis]; double t = ImLog10(y / gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.LogDenY[y_axis];
y = ImLerp(gp.CurrentPlot->YAxis[y_axis].Range.Min, gp.CurrentPlot->YAxis[y_axis].Range.Max, (float)t); y = ImLerp(gp.CurrentPlot->YAxis[y_axis].Range.Min, gp.CurrentPlot->YAxis[y_axis].Range.Max, (float)t);
} }
pix.x = (float)(gp.PixelRange[y_axis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min)); pix.x = (float)(gp.PixelRange[y_axis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min));
@ -502,13 +482,13 @@ ImVec2 PlotToPixels(const ImPlotPoint& plt, int y_axis) {
return PlotToPixels(plt.x, plt.y, y_axis); return PlotToPixels(plt.x, plt.y, y_axis);
} }
// Transformer structs // Transformer functors
struct TransformerLinLin { struct TransformerLinLin {
TransformerLinLin(int y_axis_in) : y_axis(y_axis_in) {} TransformerLinLin(int y_axis_in) : y_axis(y_axis_in) {}
inline ImVec2 operator()(const ImPlotPoint& plt) { return (*this)(plt.x, plt.y); } inline ImVec2 operator()(const ImPlotPoint& plt) { return (*this)(plt.x, plt.y); }
inline ImVec2 operator()(ImPlotFloat x, ImPlotFloat y) { inline ImVec2 operator()(double x, double y) {
return ImVec2( (float)(gp.PixelRange[y_axis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min)), return ImVec2( (float)(gp.PixelRange[y_axis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min)),
(float)(gp.PixelRange[y_axis].Min.y + gp.My[y_axis] * (y - gp.CurrentPlot->YAxis[y_axis].Range.Min)) ); (float)(gp.PixelRange[y_axis].Min.y + gp.My[y_axis] * (y - gp.CurrentPlot->YAxis[y_axis].Range.Min)) );
} }
@ -520,8 +500,8 @@ struct TransformerLogLin {
TransformerLogLin(int y_axis_in) : y_axis(y_axis_in) {} TransformerLogLin(int y_axis_in) : y_axis(y_axis_in) {}
inline ImVec2 operator()(const ImPlotPoint& plt) { return (*this)(plt.x, plt.y); } inline ImVec2 operator()(const ImPlotPoint& plt) { return (*this)(plt.x, plt.y); }
inline ImVec2 operator()(ImPlotFloat x, ImPlotFloat y) { inline ImVec2 operator()(double x, double y) {
ImPlotFloat t = log10(x / gp.CurrentPlot->XAxis.Range.Min) / gp.LogDenX; double t = ImLog10(x / gp.CurrentPlot->XAxis.Range.Min) / gp.LogDenX;
x = ImLerp(gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max, (float)t); x = ImLerp(gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max, (float)t);
return ImVec2( (float)(gp.PixelRange[y_axis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min)), return ImVec2( (float)(gp.PixelRange[y_axis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min)),
(float)(gp.PixelRange[y_axis].Min.y + gp.My[y_axis] * (y - gp.CurrentPlot->YAxis[y_axis].Range.Min)) ); (float)(gp.PixelRange[y_axis].Min.y + gp.My[y_axis] * (y - gp.CurrentPlot->YAxis[y_axis].Range.Min)) );
@ -534,8 +514,8 @@ struct TransformerLinLog {
TransformerLinLog(int y_axis_in) : y_axis(y_axis_in) {} TransformerLinLog(int y_axis_in) : y_axis(y_axis_in) {}
inline ImVec2 operator()(const ImPlotPoint& plt) { return (*this)(plt.x, plt.y); } inline ImVec2 operator()(const ImPlotPoint& plt) { return (*this)(plt.x, plt.y); }
inline ImVec2 operator()(ImPlotFloat x, ImPlotFloat y) { inline ImVec2 operator()(double x, double y) {
ImPlotFloat t = log10(y / gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.LogDenY[y_axis]; double t = ImLog10(y / gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.LogDenY[y_axis];
y = ImLerp(gp.CurrentPlot->YAxis[y_axis].Range.Min, gp.CurrentPlot->YAxis[y_axis].Range.Max, (float)t); y = ImLerp(gp.CurrentPlot->YAxis[y_axis].Range.Min, gp.CurrentPlot->YAxis[y_axis].Range.Max, (float)t);
return ImVec2( (float)(gp.PixelRange[y_axis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min)), return ImVec2( (float)(gp.PixelRange[y_axis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min)),
(float)(gp.PixelRange[y_axis].Min.y + gp.My[y_axis] * (y - gp.CurrentPlot->YAxis[y_axis].Range.Min)) ); (float)(gp.PixelRange[y_axis].Min.y + gp.My[y_axis] * (y - gp.CurrentPlot->YAxis[y_axis].Range.Min)) );
@ -549,10 +529,10 @@ struct TransformerLogLog {
} }
inline ImVec2 operator()(const ImPlotPoint& plt) { return (*this)(plt.x, plt.y); } inline ImVec2 operator()(const ImPlotPoint& plt) { return (*this)(plt.x, plt.y); }
inline ImVec2 operator()(ImPlotFloat x, ImPlotFloat y) { inline ImVec2 operator()(double x, double y) {
ImPlotFloat t = log10(x / gp.CurrentPlot->XAxis.Range.Min) / gp.LogDenX; double t = ImLog10(x / gp.CurrentPlot->XAxis.Range.Min) / gp.LogDenX;
x = ImLerp(gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max, (float)t); x = ImLerp(gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max, (float)t);
t = log10(y / gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.LogDenY[y_axis]; t = ImLog10(y / gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.LogDenY[y_axis];
y = ImLerp(gp.CurrentPlot->YAxis[y_axis].Range.Min, gp.CurrentPlot->YAxis[y_axis].Range.Max, (float)t); y = ImLerp(gp.CurrentPlot->YAxis[y_axis].Range.Min, gp.CurrentPlot->YAxis[y_axis].Range.Max, (float)t);
return ImVec2( (float)(gp.PixelRange[y_axis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min)), return ImVec2( (float)(gp.PixelRange[y_axis].Min.x + gp.Mx * (x - gp.CurrentPlot->XAxis.Range.Min)),
(float)(gp.PixelRange[y_axis].Min.y + gp.My[y_axis] * (y - gp.CurrentPlot->YAxis[y_axis].Range.Min)) ); (float)(gp.PixelRange[y_axis].Min.y + gp.My[y_axis] * (y - gp.CurrentPlot->YAxis[y_axis].Range.Min)) );
@ -601,17 +581,17 @@ inline void GetTicks(const ImPlotRange& range, int nMajor, int nMinor, bool logs
if (logscale) { if (logscale) {
if (range.Min <= 0 || range.Max <= 0) if (range.Min <= 0 || range.Max <= 0)
return; return;
int exp_min = (int)log10(range.Min); int exp_min = (int)ImLog10(range.Min);
int exp_max = (int)(ceil(log10(range.Max))); int exp_max = (int)(ceil(ImLog10(range.Max)));
for (int e = exp_min - 1; e < exp_max + 1; ++e) { for (int e = exp_min - 1; e < exp_max + 1; ++e) {
double major1 = ImPow(10, (double)(e)); double major1 = ImPow(10, (double)(e));
double major2 = ImPow(10, (double)(e + 1)); double major2 = ImPow(10, (double)(e + 1));
double interval = (major2 - major1) / 9; double interval = (major2 - major1) / 9;
if (major1 >= (range.Min - FloatProps<ImPlotFloat>::Eps()) && major1 <= (range.Max + FloatProps<ImPlotFloat>::Eps())) if (major1 >= (range.Min - DBL_EPSILON) && major1 <= (range.Max + DBL_EPSILON))
out.push_back(ImTick(major1, true)); out.push_back(ImTick(major1, true));
for (int i = 1; i < 9; ++i) { for (int i = 1; i < 9; ++i) {
double minor = major1 + i * interval; double minor = major1 + i * interval;
if (minor >= (range.Min - FloatProps<ImPlotFloat>::Eps()) && minor <= (range.Max + FloatProps<ImPlotFloat>::Eps())) if (minor >= (range.Min - DBL_EPSILON) && minor <= (range.Max + DBL_EPSILON))
out.push_back(ImTick(minor, false, false)); out.push_back(ImTick(minor, false, false));
} }
} }
@ -844,10 +824,10 @@ bool BeginPlot(const char* title, const char* x_label, const char* y_label, cons
} }
if (plot.XAxis.Range.Max <= plot.XAxis.Range.Min) if (plot.XAxis.Range.Max <= plot.XAxis.Range.Min)
plot.XAxis.Range.Max = plot.XAxis.Range.Min + FloatProps<ImPlotFloat>::Eps(); plot.XAxis.Range.Max = plot.XAxis.Range.Min + DBL_EPSILON;
for (int i = 0; i < MAX_Y_AXES; i++) { for (int i = 0; i < MAX_Y_AXES; i++) {
if (plot.YAxis[i].Range.Max <= plot.YAxis[i].Range.Min) if (plot.YAxis[i].Range.Max <= plot.YAxis[i].Range.Min)
plot.YAxis[i].Range.Max = plot.YAxis[i].Range.Min + FloatProps<ImPlotFloat>::Eps(); plot.YAxis[i].Range.Max = plot.YAxis[i].Range.Min + DBL_EPSILON;
} }
// adaptive divisions // adaptive divisions
@ -1322,11 +1302,11 @@ bool BeginPlot(const char* title, const char* x_label, const char* y_label, cons
// reset items count // reset items count
gp.VisibleItemCount = 0; gp.VisibleItemCount = 0;
// reset extents // reset extents
gp.ExtentsX.Min = FloatProps<ImPlotFloat>::Inf(); gp.ExtentsX.Min = HUGE_VAL;
gp.ExtentsX.Max = -FloatProps<ImPlotFloat>::Inf(); gp.ExtentsX.Max = -HUGE_VAL;
for (int i = 0; i < MAX_Y_AXES; i++) { for (int i = 0; i < MAX_Y_AXES; i++) {
gp.ExtentsY[i].Min = FloatProps<ImPlotFloat>::Inf(); gp.ExtentsY[i].Min = HUGE_VAL;
gp.ExtentsY[i].Max = -FloatProps<ImPlotFloat>::Inf(); gp.ExtentsY[i].Max = -HUGE_VAL;
} }
// clear item names // clear item names
gp.LegendLabels.Buf.resize(0); gp.LegendLabels.Buf.resize(0);
@ -1341,17 +1321,17 @@ bool BeginPlot(const char* title, const char* x_label, const char* y_label, cons
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
template <typename F> template <typename F>
bool DragImPlotFloat(const char* label, F* v, float v_speed, F v_min, F v_max) { bool Dragdouble(const char* label, F* v, float v_speed, F v_min, F v_max) {
return false; return false;
} }
template <> template <>
bool DragImPlotFloat<double>(const char* label, double* v, float v_speed, double v_min, double v_max) { bool Dragdouble<double>(const char* label, double* v, float v_speed, double v_min, double v_max) {
return ImGui::DragScalar(label, ImGuiDataType_Double, v, v_speed, &v_min, &v_max, "%.3f", 1); return ImGui::DragScalar(label, ImGuiDataType_Double, v, v_speed, &v_min, &v_max, "%.3f", 1);
} }
template <> template <>
bool DragImPlotFloat<float>(const char* label, float* v, float v_speed, float v_min, float v_max) { bool Dragdouble<float>(const char* label, float* v, float v_speed, float v_min, float v_max) {
return ImGui::DragScalar(label, ImGuiDataType_Float, v, v_speed, &v_min, &v_max, "%.3f", 1); return ImGui::DragScalar(label, ImGuiDataType_Float, v, v_speed, &v_min, &v_max, "%.3f", 1);
} }
@ -1371,7 +1351,7 @@ inline void AxisMenu(ImPlotAxis& Axis) {
ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true); ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.25f); ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.25f);
} }
DragImPlotFloat("Min", &Axis.Range.Min, 0.01f + 0.01f * (float)Axis.Range.Size(), -FloatProps<ImPlotFloat>::Inf(), Axis.Range.Max - FloatProps<ImPlotFloat>::Eps()); Dragdouble("Min", &Axis.Range.Min, 0.01f + 0.01f * (float)Axis.Range.Size(), -HUGE_VAL, Axis.Range.Max - DBL_EPSILON);
if (lock_min) { if (lock_min) {
ImGui::PopItemFlag(); ImGui::PopItemFlag();
ImGui::PopStyleVar(); } ImGui::PopStyleVar(); }
@ -1382,7 +1362,7 @@ inline void AxisMenu(ImPlotAxis& Axis) {
if (lock_max) { if (lock_max) {
ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true); ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.25f); } ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.25f); }
DragImPlotFloat("Max", &Axis.Range.Max, 0.01f + 0.01f * (float)Axis.Range.Size(), Axis.Range.Min + FloatProps<ImPlotFloat>::Eps(), FloatProps<ImPlotFloat>::Inf()); Dragdouble("Max", &Axis.Range.Max, 0.01f + 0.01f * (float)Axis.Range.Size(), Axis.Range.Min + DBL_EPSILON, HUGE_VAL);
if (lock_max) { if (lock_max) {
ImGui::PopItemFlag(); ImGui::PopItemFlag();
ImGui::PopStyleVar(); ImGui::PopStyleVar();
@ -1752,12 +1732,12 @@ void EndPlot() {
// MISC API // MISC API
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void SetNextPlotLimits(ImPlotFloat x_min, ImPlotFloat x_max, ImPlotFloat y_min, ImPlotFloat y_max, ImGuiCond cond) { void SetNextPlotLimits(double x_min, double x_max, double y_min, double y_max, ImGuiCond cond) {
SetNextPlotLimitsX(x_min, x_max, cond); SetNextPlotLimitsX(x_min, x_max, cond);
SetNextPlotLimitsY(y_min, y_max, cond); SetNextPlotLimitsY(y_min, y_max, cond);
} }
void SetNextPlotLimitsX(ImPlotFloat x_min, ImPlotFloat x_max, ImGuiCond cond) { void SetNextPlotLimitsX(double x_min, double x_max, ImGuiCond cond) {
IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags. IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
gp.NextPlotData.HasXRange = true; gp.NextPlotData.HasXRange = true;
gp.NextPlotData.XRangeCond = cond; gp.NextPlotData.XRangeCond = cond;
@ -1765,7 +1745,7 @@ void SetNextPlotLimitsX(ImPlotFloat x_min, ImPlotFloat x_max, ImGuiCond cond) {
gp.NextPlotData.X.Max = x_max; gp.NextPlotData.X.Max = x_max;
} }
void SetNextPlotLimitsY(ImPlotFloat y_min, ImPlotFloat y_max, ImGuiCond cond, int y_axis) { void SetNextPlotLimitsY(double y_min, double y_max, ImGuiCond cond, int y_axis) {
IM_ASSERT_USER_ERROR(y_axis >= 0 && y_axis < MAX_Y_AXES, "y_axis Needs to be between 0 and MAX_Y_AXES"); IM_ASSERT_USER_ERROR(y_axis >= 0 && y_axis < MAX_Y_AXES, "y_axis Needs to be between 0 and MAX_Y_AXES");
IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags. IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
gp.NextPlotData.HasYRange[y_axis] = true; gp.NextPlotData.HasYRange[y_axis] = true;
@ -2070,7 +2050,7 @@ inline void MarkerCross(ImDrawList& DrawList, const ImVec2& c, float s, bool /*o
} }
template <typename Transformer, typename Getter> template <typename Transformer, typename Getter>
inline void RenderMarkers(Transformer transformer, ImDrawList& DrawList, Getter getter, int count, int offset, bool rend_mk_line, ImU32 col_mk_line, bool rend_mk_fill, ImU32 col_mk_fill, bool cull) { inline void RenderMarkers(Getter getter, Transformer transformer, ImDrawList& DrawList, int count, int offset, bool rend_mk_line, ImU32 col_mk_line, bool rend_mk_fill, ImU32 col_mk_fill, bool cull) {
int idx = offset; int idx = offset;
for (int i = 0; i < count; ++i) { for (int i = 0; i < count; ++i) {
ImVec2 c; ImVec2 c;
@ -2140,8 +2120,8 @@ inline void RenderLineAA(ImDrawList& DrawList, const ImVec2& p1, const ImVec2& p
DrawList.AddLine(p1, p2, col_line, line_weight); DrawList.AddLine(p1, p2, col_line, line_weight);
} }
template <typename Transformer, typename Getter> template <typename Getter, typename Transformer>
inline void RenderLineStrip(Transformer transformer, ImDrawList& DrawList, Getter getter, int count, int offset, float line_weight, ImU32 col_line, bool cull) { inline void RenderLineStrip(Getter getter, Transformer transformer, ImDrawList& DrawList, int count, int offset, float line_weight, ImU32 col_line, bool cull) {
// render line segments // render line segments
offset %= count; offset %= count;
if (offset < 0) offset += count; // shift negative offset to positive range if (offset < 0) offset += count; // shift negative offset to positive range
@ -2199,8 +2179,8 @@ struct GetterYs {
}; };
template <typename T> template <typename T>
struct Getter2D { struct GetterXsYs {
Getter2D(const T* xs, const T* ys, int stride) { Xs = xs; Ys = ys; Stride = stride; } GetterXsYs(const T* xs, const T* ys, int stride) { Xs = xs; Ys = ys; Stride = stride; }
const T* Xs; const T* Xs;
const T* Ys; const T* Ys;
int Stride; int Stride;
@ -2209,6 +2189,19 @@ struct Getter2D {
} }
}; };
struct GetterImPlotPoint {
GetterImPlotPoint(const ImPlotPoint* data) { Data = data; }
inline ImPlotPoint operator()(int idx) { return Data[idx]; }
const ImPlotPoint* Data;
};
struct GetterFuncPtrImPlotPoint {
GetterFuncPtrImPlotPoint(ImPlotPoint (*g)(void* data, int idx), void* d) { getter = g; data = d;}
inline ImPlotPoint operator()(int idx) { return getter(data, idx); }
ImPlotPoint (*getter)(void* data, int idx);
void* data;
};
struct GetterImVec2 { struct GetterImVec2 {
GetterImVec2(const ImVec2* data) { Data = data; } GetterImVec2(const ImVec2* data) { Data = data; }
inline ImPlotPoint operator()(int idx) { return ImPlotPoint(Data[idx].x, Data[idx].y); } inline ImPlotPoint operator()(int idx) { return ImPlotPoint(Data[idx].x, Data[idx].y); }
@ -2222,13 +2215,6 @@ struct GetterFuncPtrImVec2 {
void* data; void* data;
}; };
struct GetterFuncPtrImVec4 {
GetterFuncPtrImVec4(ImVec4 (*g)(void* data, int idx), void* d) { getter = g; data = d;}
inline ImVec4 operator()(int idx) { return getter(data, idx); }
ImVec4 (*getter)(void* data, int idx);
void* data;
};
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// PLOT // PLOT
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -2271,35 +2257,38 @@ inline void PlotEx(const char* label_id, Getter getter, int count, int offset)
PushPlotClipRect(); PushPlotClipRect();
if (count > 1 && rend_line) { if (count > 1 && rend_line) {
if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale) && HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale) && HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale))
RenderLineStrip(TransformerLogLog(y_axis), DrawList, getter, count, offset, line_weight, col_line, cull); RenderLineStrip(getter, TransformerLogLog(y_axis), DrawList, count, offset, line_weight, col_line, cull);
else if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale)) else if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale))
RenderLineStrip(TransformerLogLin(y_axis), DrawList, getter, count, offset, line_weight, col_line, cull); RenderLineStrip(getter, TransformerLogLin(y_axis), DrawList, count, offset, line_weight, col_line, cull);
else if (HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) else if (HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale))
RenderLineStrip(TransformerLinLog(y_axis), DrawList, getter, count, offset, line_weight, col_line, cull); RenderLineStrip(getter, TransformerLinLog(y_axis), DrawList, count, offset, line_weight, col_line, cull);
else else
RenderLineStrip(TransformerLinLin(y_axis), DrawList, getter, count, offset, line_weight, col_line, cull); RenderLineStrip(getter, TransformerLinLin(y_axis), DrawList, count, offset, line_weight, col_line, cull);
} }
// render markers // render markers
if (gp.Style.Marker != ImPlotMarker_None) { if (gp.Style.Marker != ImPlotMarker_None) {
if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale) && HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale) && HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale))
RenderMarkers(TransformerLogLog(y_axis), DrawList, getter, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull); RenderMarkers(getter, TransformerLogLog(y_axis), DrawList, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull);
else if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale)) else if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale))
RenderMarkers(TransformerLogLin(y_axis), DrawList, getter, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull); RenderMarkers(getter, TransformerLogLin(y_axis), DrawList, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull);
else if (HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) else if (HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale))
RenderMarkers(TransformerLinLog(y_axis), DrawList, getter, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull); RenderMarkers(getter, TransformerLinLog(y_axis), DrawList, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull);
else else
RenderMarkers(TransformerLinLin(y_axis), DrawList, getter, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull); RenderMarkers(getter, TransformerLinLin(y_axis), DrawList, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull);
} }
PopPlotClipRect(); PopPlotClipRect();
} }
//-----------------------------------------------------------------------------
// float
void PlotLine(const char* label_id, const float* values, int count, int offset, int stride) { void PlotLine(const char* label_id, const float* values, int count, int offset, int stride) {
GetterYs getter(values,stride); GetterYs<float> getter(values,stride);
PlotEx(label_id, getter, count, offset); PlotEx(label_id, getter, count, offset);
} }
void PlotLine(const char* label_id, const float* xs, const float* ys, int count, int offset, int stride) { void PlotLine(const char* label_id, const float* xs, const float* ys, int count, int offset, int stride) {
Getter2D getter(xs,ys,stride); GetterXsYs<float> getter(xs,ys,stride);
return PlotEx(label_id, getter, count, offset); return PlotEx(label_id, getter, count, offset);
} }
@ -2313,56 +2302,99 @@ void PlotLine(const char* label_id, ImVec2 (*getter_func)(void* data, int idx),
return PlotEx(label_id, getter, count, offset); return PlotEx(label_id, getter, count, offset);
} }
//-----------------------------------------------------------------------------
// double
void PlotLine(const char* label_id, const double* values, int count, int offset, int stride) {
GetterYs<double> getter(values,stride);
PlotEx(label_id, getter, count, offset);
}
void PlotLine(const char* label_id, const double* xs, const double* ys, int count, int offset, int stride) {
GetterXsYs<double> getter(xs,ys,stride);
return PlotEx(label_id, getter, count, offset);
}
void PlotLine(const char* label_id, const ImPlotPoint* data, int count, int offset) {
GetterImPlotPoint getter(data);
return PlotEx(label_id, getter, count, offset);
}
void PlotLine(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, int offset) {
GetterFuncPtrImPlotPoint getter(getter_func,data);
return PlotEx(label_id, getter, count, offset);
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// PLOT SCATTER // PLOT SCATTER
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void PlotScatter(const char* label_id, const float* values, int count, int offset, int stride) { inline int PushScatterStyle() {
int pops = 1; int vars = 1;
PushStyleVar(ImPlotStyleVar_LineWeight, 0); PushStyleVar(ImPlotStyleVar_LineWeight, 0);
if (GetStyle().Marker == ImPlotMarker_None) { if (GetStyle().Marker == ImPlotMarker_None) {
PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle); PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle);
pops++; vars++;
} }
PlotLine(label_id, values, count, offset, stride); return vars;
PopStyleVar(pops);
}
void PlotScatter(const char* label_id, const float* xs, const float* ys, int count, int offset, int stride) {
int pops = 1;
PushStyleVar(ImPlotStyleVar_LineWeight, 0);
if (GetStyle().Marker == ImPlotMarker_None) {
PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle);
pops++;
}
PlotLine(label_id, xs, ys, count, offset, stride);
PopStyleVar(pops);
}
void PlotScatter(const char* label_id, const ImVec2* data, int count, int offset) {
int pops = 1;
PushStyleVar(ImPlotStyleVar_LineWeight, 0);
if (GetStyle().Marker == ImPlotMarker_None) {
PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle);
pops++;
}
PlotLine(label_id, data, count, offset);
PopStyleVar(pops);
}
void PlotScatter(const char* label_id, ImVec2 (*getter)(void* data, int idx), void* data, int count, int offset) {
int pops = 1;
PushStyleVar(ImPlotStyleVar_LineWeight, 0);
if (GetStyle().Marker == ImPlotMarker_None) {
PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle);
pops++;
}
PlotLine(label_id, getter, data, count, offset);
PopStyleVar(pops);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// PLOT BAR // float
void PlotScatter(const char* label_id, const float* values, int count, int offset, int stride) {
int vars = PushScatterStyle();
PlotLine(label_id, values, count, offset, stride);
PopStyleVar(vars);
}
void PlotScatter(const char* label_id, const float* xs, const float* ys, int count, int offset, int stride) {
int vars = PushScatterStyle();
PlotLine(label_id, xs, ys, count, offset, stride);
PopStyleVar(vars);
}
void PlotScatter(const char* label_id, const ImVec2* data, int count, int offset) {
int vars = PushScatterStyle();
PlotLine(label_id, data, count, offset);
PopStyleVar(vars);
}
void PlotScatter(const char* label_id, ImVec2 (*getter)(void* data, int idx), void* data, int count, int offset) {
int vars = PushScatterStyle();
PlotLine(label_id, getter, data, count, offset);
PopStyleVar(vars);
}
//-----------------------------------------------------------------------------
// double
void PlotScatter(const char* label_id, const double* values, int count, int offset, int stride) {
int vars = PushScatterStyle();
PlotLine(label_id, values, count, offset, stride);
PopStyleVar(vars);
}
void PlotScatter(const char* label_id, const double* xs, const double* ys, int count, int offset, int stride) {
int vars = PushScatterStyle();
PlotLine(label_id, xs, ys, count, offset, stride);
PopStyleVar(vars);
}
void PlotScatter(const char* label_id, const ImPlotPoint* data, int count, int offset) {
int vars = PushScatterStyle();
PlotLine(label_id, data, count, offset);
PopStyleVar(vars);
}
void PlotScatter(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset) {
int vars = PushScatterStyle();
PlotLine(label_id, getter, data, count, offset);
PopStyleVar(vars);
}
//-----------------------------------------------------------------------------
// PLOT BAR V
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
template <typename T> template <typename T>
@ -2380,8 +2412,8 @@ struct GetterBarH {
}; };
template <typename Getter> template <typename Getter, typename TWidth>
void PlotBarsEx(const char* label_id, Getter getter, int count, float width, int offset) { void PlotBarsEx(const char* label_id, Getter getter, int count, TWidth width, int offset) {
IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "Bar() Needs to be called between BeginPlot() and EndPlot()!"); IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "Bar() Needs to be called between BeginPlot() and EndPlot()!");
@ -2405,7 +2437,7 @@ void PlotBarsEx(const char* label_id, Getter getter, int count, float width, int
PushPlotClipRect(); PushPlotClipRect();
float half_width = width * 0.5f; TWidth half_width = width / 2;
// find data extents // find data extents
if (gp.FitThisFrame) { if (gp.FitThisFrame) {
@ -2433,13 +2465,16 @@ void PlotBarsEx(const char* label_id, Getter getter, int count, float width, int
PopPlotClipRect(); PopPlotClipRect();
} }
//-----------------------------------------------------------------------------
// float
void PlotBars(const char* label_id, const float* values, int count, float width, float shift, int offset, int stride) { void PlotBars(const char* label_id, const float* values, int count, float width, float shift, int offset, int stride) {
GetterBarV getter(values,shift,stride); GetterBarV<float> getter(values,shift,stride);
PlotBarsEx(label_id, getter, count, width, offset); PlotBarsEx(label_id, getter, count, width, offset);
} }
void PlotBars(const char* label_id, const float* xs, const float* ys, int count, float width, int offset, int stride) { void PlotBars(const char* label_id, const float* xs, const float* ys, int count, float width, int offset, int stride) {
Getter2D getter(xs,ys,stride); GetterXsYs<float> getter(xs,ys,stride);
PlotBarsEx(label_id, getter, count, width, offset); PlotBarsEx(label_id, getter, count, width, offset);
} }
@ -2449,9 +2484,29 @@ void PlotBars(const char* label_id, ImVec2 (*getter_func)(void* data, int idx),
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// double
template <typename Getter> void PlotBars(const char* label_id, const double* values, int count, double width, double shift, int offset, int stride) {
void PlotBarsHEx(const char* label_id, Getter getter, int count, float height, int offset) { GetterBarV<double> getter(values,shift,stride);
PlotBarsEx(label_id, getter, count, width, offset);
}
void PlotBars(const char* label_id, const double* xs, const double* ys, int count, double width, int offset, int stride) {
GetterXsYs<double> getter(xs,ys,stride);
PlotBarsEx(label_id, getter, count, width, offset);
}
void PlotBars(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, double width, int offset) {
GetterFuncPtrImPlotPoint getter(getter_func, data);
PlotBarsEx(label_id, getter, count, width, offset);
}
//-----------------------------------------------------------------------------
// PLOT BAR H
//-----------------------------------------------------------------------------
template <typename Getter, typename THeight>
void PlotBarsHEx(const char* label_id, Getter getter, int count, THeight height, int offset) {
IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "BarH() Needs to be called between BeginPlot() and EndPlot()!"); IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "BarH() Needs to be called between BeginPlot() and EndPlot()!");
@ -2475,7 +2530,7 @@ void PlotBarsHEx(const char* label_id, Getter getter, int count, float height,
PushPlotClipRect(); PushPlotClipRect();
float half_height = height * 0.5f; THeight half_height = height / 2;
// find data extents // find data extents
if (gp.FitThisFrame) { if (gp.FitThisFrame) {
@ -2503,13 +2558,16 @@ void PlotBarsHEx(const char* label_id, Getter getter, int count, float height,
PopPlotClipRect(); PopPlotClipRect();
} }
//-----------------------------------------------------------------------------
// float
void PlotBarsH(const char* label_id, const float* values, int count, float height, float shift, int offset, int stride) { void PlotBarsH(const char* label_id, const float* values, int count, float height, float shift, int offset, int stride) {
GetterBarH getter(values,shift,stride); GetterBarH<float> getter(values,shift,stride);
PlotBarsHEx(label_id, getter, count, height, offset); PlotBarsHEx(label_id, getter, count, height, offset);
} }
void PlotBarsH(const char* label_id, const float* xs, const float* ys, int count, float height, int offset, int stride) { void PlotBarsH(const char* label_id, const float* xs, const float* ys, int count, float height, int offset, int stride) {
Getter2D getter(xs,ys,stride); GetterXsYs<float> getter(xs,ys,stride);
PlotBarsHEx(label_id, getter, count, height, offset); PlotBarsHEx(label_id, getter, count, height, offset);
} }
@ -2518,17 +2576,43 @@ void PlotBarsH(const char* label_id, ImVec2 (*getter_func)(void* data, int idx),
PlotBarsHEx(label_id, getter, count, height, offset); PlotBarsHEx(label_id, getter, count, height, offset);
} }
//-----------------------------------------------------------------------------
// double
void PlotBarsH(const char* label_id, const double* values, int count, double height, double shift, int offset, int stride) {
GetterBarH<double> getter(values,shift,stride);
PlotBarsHEx(label_id, getter, count, height, offset);
}
void PlotBarsH(const char* label_id, const double* xs, const double* ys, int count, double height, int offset, int stride) {
GetterXsYs<double> getter(xs,ys,stride);
PlotBarsHEx(label_id, getter, count, height, offset);
}
void PlotBarsH(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, double height, int offset) {
GetterFuncPtrImPlotPoint getter(getter_func, data);
PlotBarsHEx(label_id, getter, count, height, offset);
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// PLOT ERROR BARS // PLOT ERROR BARS
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct ImPlotPointError {
ImPlotPointError(double _x, double _y, double _neg, double _pos) {
x = _x; y = _y; neg = _neg; pos = _pos;
}
double x, y, neg, pos;
};
template <typename T>
struct GetterError { struct GetterError {
const float* Xs; const float* Ys; const float* Neg; const float* Pos; int Stride; const T* Xs; const T* Ys; const T* Neg; const T* Pos; int Stride;
GetterError(const float* xs, const float* ys, const float* neg, const float* pos, int stride) { GetterError(const T* xs, const T* ys, const T* neg, const T* pos, int stride) {
Xs = xs; Ys = ys; Neg = neg; Pos = pos; Stride = stride; Xs = xs; Ys = ys; Neg = neg; Pos = pos; Stride = stride;
} }
ImVec4 operator()(int idx) { ImPlotPointError operator()(int idx) {
return ImVec4(StrideIndex(Xs, idx, Stride), return ImPlotPointError(StrideIndex(Xs, idx, Stride),
StrideIndex(Ys, idx, Stride), StrideIndex(Ys, idx, Stride),
StrideIndex(Neg, idx, Stride), StrideIndex(Neg, idx, Stride),
StrideIndex(Pos, idx, Stride)); StrideIndex(Pos, idx, Stride));
@ -2556,19 +2640,18 @@ void PlotErrorBarsEx(const char* label_id, Getter getter, int count, int offset)
// find data extents // find data extents
if (gp.FitThisFrame) { if (gp.FitThisFrame) {
for (int i = 0; i < count; ++i) { for (int i = 0; i < count; ++i) {
ImVec4 e = getter(i); ImPlotPointError e = getter(i);
FitPoint(ImPlotPoint(e.x , e.y - e.z)); FitPoint(ImPlotPoint(e.x , e.y - e.neg));
FitPoint(ImPlotPoint(e.x , e.y + e.w )); FitPoint(ImPlotPoint(e.x , e.y + e.pos ));
} }
} }
int idx = offset; int idx = offset;
for (int i = 0; i < count; ++i) { for (int i = 0; i < count; ++i) {
ImVec4 e; ImPlotPointError e = getter(idx);
e = getter(idx);
idx = (idx + 1) % count; idx = (idx + 1) % count;
ImVec2 p1 = PlotToPixels(e.x, e.y - e.z); ImVec2 p1 = PlotToPixels(e.x, e.y - e.neg);
ImVec2 p2 = PlotToPixels(e.x, e.y + e.w); ImVec2 p2 = PlotToPixels(e.x, e.y + e.pos);
DrawList.AddLine(p1,p2,col, gp.Style.ErrorBarWeight); DrawList.AddLine(p1,p2,col, gp.Style.ErrorBarWeight);
if (rend_whisker) { if (rend_whisker) {
DrawList.AddLine(p1 - ImVec2(half_whisker, 0), p1 + ImVec2(half_whisker, 0), col, gp.Style.ErrorBarWeight); DrawList.AddLine(p1 - ImVec2(half_whisker, 0), p1 + ImVec2(half_whisker, 0), col, gp.Style.ErrorBarWeight);
@ -2578,44 +2661,55 @@ void PlotErrorBarsEx(const char* label_id, Getter getter, int count, int offset)
PopPlotClipRect(); PopPlotClipRect();
} }
//-----------------------------------------------------------------------------
// float
void PlotErrorBars(const char* label_id, const float* xs, const float* ys, const float* err, int count, int offset, int stride) { void PlotErrorBars(const char* label_id, const float* xs, const float* ys, const float* err, int count, int offset, int stride) {
GetterError getter(xs, ys, err, err, stride); GetterError<float> getter(xs, ys, err, err, stride);
PlotErrorBarsEx(label_id, getter, count, offset); PlotErrorBarsEx(label_id, getter, count, offset);
} }
void PlotErrorBars(const char* label_id, const float* xs, const float* ys, const float* neg, const float* pos, int count, int offset, int stride) { void PlotErrorBars(const char* label_id, const float* xs, const float* ys, const float* neg, const float* pos, int count, int offset, int stride) {
GetterError getter(xs, ys, neg, pos, stride); GetterError<float> getter(xs, ys, neg, pos, stride);
PlotErrorBarsEx(label_id, getter, count, offset);
}
void PlotErrorBars(const char* label_id, ImVec4 (*getter_func)(void* data, int idx), void* data, int count, int offset) {
GetterFuncPtrImVec4 getter(getter_func, data);
PlotErrorBarsEx(label_id, getter, count, offset); PlotErrorBarsEx(label_id, getter, count, offset);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// PLOT MISC // double
void PlotErrorBars(const char* label_id, const double* xs, const double* ys, const double* err, int count, int offset, int stride) {
GetterError<double> getter(xs, ys, err, err, stride);
PlotErrorBarsEx(label_id, getter, count, offset);
}
void PlotErrorBars(const char* label_id, const double* xs, const double* ys, const double* neg, const double* pos, int count, int offset, int stride) {
GetterError<double> getter(xs, ys, neg, pos, stride);
PlotErrorBarsEx(label_id, getter, count, offset);
}
//-----------------------------------------------------------------------------
// PLOT PIE CHART
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
inline void DrawPieSlice(ImDrawList& DrawList, const ImPlotPoint& center, float radius, float a0, float a1, ImU32 col) { inline void DrawPieSlice(ImDrawList& DrawList, const ImPlotPoint& center, double radius, double a0, double a1, ImU32 col) {
static const float resolution = 50 / (2 * IM_PI); static const float resolution = 50 / (2 * IM_PI);
static ImVec2 buffer[50]; static ImVec2 buffer[50];
buffer[0] = PlotToPixels(center); buffer[0] = PlotToPixels(center);
int n = ImMax(3, (int)((a1 - a0) * resolution)); int n = ImMax(3, (int)((a1 - a0) * resolution));
float da = (a1 - a0) / (n - 1); double da = (a1 - a0) / (n - 1);
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
float a = a0 + i * da; double a = a0 + i * da;
buffer[i + 1] = PlotToPixels(center.x + radius * cos(a), center.y + radius * sin(a)); buffer[i + 1] = PlotToPixels(center.x + radius * cos(a), center.y + radius * sin(a));
} }
DrawList.AddConvexPolyFilled(buffer, n + 1, col); DrawList.AddConvexPolyFilled(buffer, n + 1, col);
} }
template <typename T>
void PlotPieChart(const char** label_ids, float* values, int count, float x, float y, float radius, bool show_percents, float angle0) { void PlotPieChartEx(const char** label_ids, T* values, int count, T x, T y, T radius, bool show_percents, T angle0) {
IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "PieChart() Needs to be called between BeginPlot() and EndPlot()!"); IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "PieChart() Needs to be called between BeginPlot() and EndPlot()!");
ImDrawList & DrawList = *ImGui::GetWindowDrawList(); ImDrawList & DrawList = *ImGui::GetWindowDrawList();
float sum = 0; T sum = 0;
for (int i = 0; i < count; ++i) for (int i = 0; i < count; ++i)
sum += values[i]; sum += values[i];
@ -2624,12 +2718,12 @@ void PlotPieChart(const char** label_ids, float* values, int count, float x, flo
ImPlotPoint center(x,y); ImPlotPoint center(x,y);
PushPlotClipRect(); PushPlotClipRect();
float a0 = angle0 * 2 * IM_PI / 360.0f; T a0 = angle0 * 2 * IM_PI / 360.0f;
float a1 = angle0 * 2 * IM_PI / 360.0f; T a1 = angle0 * 2 * IM_PI / 360.0f;
for (int i = 0; i < count; ++i) { for (int i = 0; i < count; ++i) {
ImPlotItem* item = RegisterItem(label_ids[i]); ImPlotItem* item = RegisterItem(label_ids[i]);
ImU32 col = ImGui::GetColorU32(item->Color); ImU32 col = ImGui::GetColorU32(item->Color);
float percent = normalize ? values[i] / sum : values[i]; T percent = normalize ? values[i] / sum : values[i];
a1 = a0 + 2 * IM_PI * percent; a1 = a0 + 2 * IM_PI * percent;
if (item->Show) { if (item->Show) {
if (percent < 0.5) { if (percent < 0.5) {
@ -2643,7 +2737,7 @@ void PlotPieChart(const char** label_ids, float* values, int count, float x, flo
char buffer[8]; char buffer[8];
sprintf(buffer, "%.0f%%", percent * 100); sprintf(buffer, "%.0f%%", percent * 100);
ImVec2 size = ImGui::CalcTextSize(buffer); ImVec2 size = ImGui::CalcTextSize(buffer);
float angle = a0 + (a1 - a0) * 0.5f; T angle = a0 + (a1 - a0) * 0.5f;
ImVec2 pos = PlotToPixels(center.x + 0.5f * radius * cos(angle), center.y + 0.5f * radius * sin(angle)); ImVec2 pos = PlotToPixels(center.x + 0.5f * radius * cos(angle), center.y + 0.5f * radius * sin(angle));
DrawList.AddText(pos - size * 0.5f + ImVec2(1,1), IM_COL32(0,0,0,255), buffer); DrawList.AddText(pos - size * 0.5f + ImVec2(1,1), IM_COL32(0,0,0,255), buffer);
DrawList.AddText(pos - size * 0.5f, IM_COL32(255,255,255,255), buffer); DrawList.AddText(pos - size * 0.5f, IM_COL32(255,255,255,255), buffer);
@ -2654,18 +2748,24 @@ void PlotPieChart(const char** label_ids, float* values, int count, float x, flo
PopPlotClipRect(); PopPlotClipRect();
} }
void PlotText(const char* text, float x, float y, bool vertical, const ImVec2& pixel_offset) { //-----------------------------------------------------------------------------
IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "Text() Needs to be called between BeginPlot() and EndPlot()!"); // float
ImDrawList & DrawList = *ImGui::GetWindowDrawList();
PushPlotClipRect(); void PlotPieChart(const char** label_ids, float* values, int count, float x, float y, float radius, bool show_percents, float angle0) {
ImVec2 pos = PlotToPixels(ImPlotPoint(x,y)) + pixel_offset; return PlotPieChartEx(label_ids, values, count, x, y, radius, show_percents, angle0);
if (vertical)
AddTextVertical(&DrawList, text, pos, gp.Col_Txt);
else
DrawList.AddText(pos, gp.Col_Txt, text);
PopPlotClipRect();
} }
//-----------------------------------------------------------------------------
// double
void PlotPieChart(const char** label_ids, double* values, int count, double x, double y, double radius, bool show_percents, double angle0) {
return PlotPieChartEx(label_ids, values, count, x, y, radius, show_percents, angle0);
}
//-----------------------------------------------------------------------------
// PLOT DIGITAL
//-----------------------------------------------------------------------------
template <typename Getter> template <typename Getter>
inline void PlotDigitalEx(const char* label_id, Getter getter, int count, int offset) inline void PlotDigitalEx(const char* label_id, Getter getter, int count, int offset)
{ {
@ -2747,8 +2847,11 @@ inline void PlotDigitalEx(const char* label_id, Getter getter, int count, int of
ImGui::PopClipRect(); ImGui::PopClipRect();
} }
//-----------------------------------------------------------------------------
// float
void PlotDigital(const char* label_id, const float* xs, const float* ys, int count, int offset, int stride) { void PlotDigital(const char* label_id, const float* xs, const float* ys, int count, int offset, int stride) {
Getter2D getter(xs,ys,stride); GetterXsYs<float> getter(xs,ys,stride);
return PlotDigitalEx(label_id, getter, count, offset); return PlotDigitalEx(label_id, getter, count, offset);
} }
@ -2757,4 +2860,40 @@ void PlotDigital(const char* label_id, ImVec2 (*getter_func)(void* data, int idx
return PlotDigitalEx(label_id, getter, count, offset); return PlotDigitalEx(label_id, getter, count, offset);
} }
//-----------------------------------------------------------------------------
// double
void PlotDigital(const char* label_id, const double* xs, const double* ys, int count, int offset, int stride) {
GetterXsYs<double> getter(xs,ys,stride);
return PlotDigitalEx(label_id, getter, count, offset);
}
void PlotDigital(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, int offset) {
GetterFuncPtrImPlotPoint getter(getter_func,data);
return PlotDigitalEx(label_id, getter, count, offset);
}
//-----------------------------------------------------------------------------
// PLOT TEXT
//-----------------------------------------------------------------------------
// float
void PlotText(const char* text, float x, float y, bool vertical, const ImVec2& pixel_offset) {
return PlotText(text, (double)x, (double)y, vertical, pixel_offset);
}
//-----------------------------------------------------------------------------
// double
void PlotText(const char* text, double x, double y, bool vertical, const ImVec2& pixel_offset) {
IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "Text() Needs to be called between BeginPlot() and EndPlot()!");
ImDrawList & DrawList = *ImGui::GetWindowDrawList();
PushPlotClipRect();
ImVec2 pos = PlotToPixels(ImPlotPoint(x,y)) + pixel_offset;
if (vertical)
AddTextVertical(&DrawList, text, pos, gp.Col_Txt);
else
DrawList.AddText(pos, gp.Col_Txt, text);
PopPlotClipRect();
}
} // namespace ImPlot } // namespace ImPlot

65
implot.h
View File

@ -20,14 +20,11 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE. // SOFTWARE.
// ImPlot v0.2 WIP // ImPlot v0.3 WIP
#pragma once #pragma once
#include "imgui.h" #include "imgui.h"
// The desired plot precision (float or double)
typedef double ImPlotFloat;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Basic types and flags // Basic types and flags
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -117,25 +114,31 @@ enum ImPlotMarker_ {
ImPlotMarker_Asterisk = 1 << 10, // a asterisk marker will be rendered at each point (not filled) ImPlotMarker_Asterisk = 1 << 10, // a asterisk marker will be rendered at each point (not filled)
}; };
/// Double precision version of ImVec2 used by ImPlot and extensible by end users
struct ImPlotPoint { struct ImPlotPoint {
ImPlotFloat x, y; double x, y;
ImPlotPoint() { x = y = 0; } ImPlotPoint() { x = y = 0.0; }
ImPlotPoint(ImPlotFloat _x, ImPlotFloat _y) { x = _x; y = _y; } ImPlotPoint(double _x, double _y) { x = _x; y = _y; }
double operator[] (size_t idx) const { return (&x)[idx]; }
double& operator[] (size_t idx) { return (&x)[idx]; }
#ifdef IMPLOT_POINT_CLASS_EXTRA
IMPLOT_POINT_CLASS_EXTRA // Define additional constructors and implicit cast operators in imconfig.h to convert back and forth between your math types and ImVec2.
#endif
}; };
// A range defined by a min/max value. Used for plot axes ranges. // A range defined by a min/max value. Used for plot axes ranges.
struct ImPlotRange { struct ImPlotRange {
ImPlotFloat Min, Max; double Min, Max;
ImPlotRange(); ImPlotRange();
bool Contains(ImPlotFloat value) const; bool Contains(double value) const;
ImPlotFloat Size() const; double Size() const;
}; };
// Combination of two ranges for X and Y axes. // Combination of two ranges for X and Y axes.
struct ImPlotLimits { struct ImPlotLimits {
ImPlotRange X, Y; ImPlotRange X, Y;
ImPlotLimits(); ImPlotLimits();
bool Contains(const ImVec2& p) const; bool Contains(double x, double y) const;
}; };
// Plot style structure // Plot style structure
@ -177,7 +180,7 @@ bool BeginPlot(const char* title_id,
void EndPlot(); void EndPlot();
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Plot Items (float) // Plot Items (single precision data)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Plots a standard 2D line plot. // Plots a standard 2D line plot.
@ -201,7 +204,6 @@ void PlotBarsH(const char* label_id, ImVec2 (*getter)(void* data, int idx), void
// Plots vertical error bar. // Plots vertical error bar.
void PlotErrorBars(const char* label_id, const float* xs, const float* ys, const float* err, int count, int offset = 0, int stride = sizeof(float)); void PlotErrorBars(const char* label_id, const float* xs, const float* ys, const float* err, int count, int offset = 0, int stride = sizeof(float));
void PlotErrorBars(const char* label_id, const float* xs, const float* ys, const float* neg, const float* pos, int count, int offset = 0, int stride = sizeof(float)); void PlotErrorBars(const char* label_id, const float* xs, const float* ys, const float* neg, const float* pos, int count, int offset = 0, int stride = sizeof(float));
void PlotErrorBars(const char* label_id, ImVec4 (*getter)(void* data, int idx), void* data, int count, int offset = 0);
// Plots a pie chart. If the sum of values > 1, each value will be normalized. Center and radius are in plot coordinates. // Plots a pie chart. If the sum of values > 1, each value will be normalized. Center and radius are in plot coordinates.
void PlotPieChart(const char** label_ids, float* values, int count, float x, float y, float radius, bool show_percents = true, float angle0 = 90); void PlotPieChart(const char** label_ids, float* values, int count, float x, float y, float radius, bool show_percents = true, float angle0 = 90);
// Plots digital data. // Plots digital data.
@ -210,7 +212,38 @@ void PlotDigital(const char* label_id, ImVec2 (*getter)(void* data, int idx), vo
// Plots a text label at point x,y. // Plots a text label at point x,y.
void PlotText(const char* text, float x, float y, bool vertical = false, const ImVec2& pixel_offset = ImVec2(0,0)); void PlotText(const char* text, float x, float y, bool vertical = false, const ImVec2& pixel_offset = ImVec2(0,0));
//-----------------------------------------------------------------------------
// Plot Items (double precision data)
//-----------------------------------------------------------------------------
// Plots a standard 2D line plot.
void PlotLine(const char* label_id, const double* values, int count, int offset = 0, int stride = sizeof(double));
void PlotLine(const char* label_id, const double* xs, const double* ys, int count, int offset = 0, int stride = sizeof(double));
void PlotLine(const char* label_id, const ImPlotPoint* data, int count, int offset = 0);
void PlotLine(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset = 0);
// Plots a standard 2D scatter plot.
void PlotScatter(const char* label_id, const double* values, int count, int offset = 0, int stride = sizeof(double));
void PlotScatter(const char* label_id, const double* xs, const double* ys, int count, int offset = 0, int stride = sizeof(double));
void PlotScatter(const char* label_id, const ImPlotPoint* data, int count, int offset = 0);
void PlotScatter(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset = 0);
// Plots a vertical bar graph.
void PlotBars(const char* label_id, const double* values, int count, double width = 0.67f, double shift = 0, int offset = 0, int stride = sizeof(double));
void PlotBars(const char* label_id, const double* xs, const double* ys, int count, double width, int offset = 0, int stride = sizeof(double));
void PlotBars(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, double width, int offset = 0);
// Plots a horizontal bar graph.
void PlotBarsH(const char* label_id, const double* values, int count, double height = 0.67f, double shift = 0, int offset = 0, int stride = sizeof(double));
void PlotBarsH(const char* label_id, const double* xs, const double* ys, int count, double height, int offset = 0, int stride = sizeof(double));
void PlotBarsH(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, double height, int offset = 0);
// Plots vertical error bar.
void PlotErrorBars(const char* label_id, const double* xs, const double* ys, const double* err, int count, int offset = 0, int stride = sizeof(double));
void PlotErrorBars(const char* label_id, const double* xs, const double* ys, const double* neg, const double* pos, int count, int offset = 0, int stride = sizeof(double));
// Plots a pie chart. If the sum of values > 1, each value will be normalized. Center and radius are in plot coordinates.
void PlotPieChart(const char** label_ids, double* values, int count, double x, double y, double radius, bool show_percents = true, double angle0 = 90);
// Plots digital data.
void PlotDigital(const char* label_id, const double* xs, const double* ys, int count, int offset = 0, int stride = sizeof(double));
void PlotDigital(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset = 0);
// Plots a text label at point x,y.
void PlotText(const char* text, double x, double y, bool vertical = false, const ImVec2& pixel_offset = ImVec2(0,0));
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Plot Queries // Plot Queries
@ -258,11 +291,11 @@ void PopStyleVar(int count = 1);
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/// Set the axes range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the axes limits will be locked. /// Set the axes range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the axes limits will be locked.
void SetNextPlotLimits(ImPlotFloat x_min, ImPlotFloat x_max, ImPlotFloat y_min, ImPlotFloat y_max, ImGuiCond cond = ImGuiCond_Once); void SetNextPlotLimits(double x_min, double x_max, double y_min, double y_max, ImGuiCond cond = ImGuiCond_Once);
/// Set the X axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the axis limits will be locked. /// Set the X axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the axis limits will be locked.
void SetNextPlotLimitsX(ImPlotFloat x_min, ImPlotFloat x_max, ImGuiCond cond = ImGuiCond_Once); void SetNextPlotLimitsX(double x_min, double x_max, ImGuiCond cond = ImGuiCond_Once);
/// Set the Y axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the axis limits will be locked. /// Set the Y axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the axis limits will be locked.
void SetNextPlotLimitsY(ImPlotFloat y_min, ImPlotFloat y_max, ImGuiCond cond = ImGuiCond_Once, int y_axis = 0); void SetNextPlotLimitsY(double y_min, double y_max, ImGuiCond cond = ImGuiCond_Once, int y_axis = 0);
/// Select which Y axis will be used for subsequent plot elements. The default is '0', or the first Y axis. /// Select which Y axis will be used for subsequent plot elements. The default is '0', or the first Y axis.
void SetPlotYAxis(int y_axis); void SetPlotYAxis(int y_axis);

229
implot_demo.cpp
View File

@ -20,40 +20,62 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE. // SOFTWARE.
// ImPlot v0.2 WIP // ImPlot v0.3 WIP
#include "implot.h" #include "implot.h"
#include <math.h> #include <math.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <cmath> // for 'float' overloads of elementary functions (sin,cos,etc)
#ifdef _MSC_VER #ifdef _MSC_VER
#define sprintf sprintf_s #define sprintf sprintf_s
#endif #endif
/// Choose whether the demo uses double or float versions of the ImPlot API.
/// NB: You don't ever need to typdef of define values for ImPlot. This
/// is only being done here for the sake of demoing both precision types.
// #define IMPLOT_DEMO_USE_DOUBLE
#ifdef IMPLOT_DEMO_USE_DOUBLE
typedef double t_float;
typedef ImPlotPoint t_float2;
#define Sin sin
#define Cos cos
#define Pow pow
#define Log log
#define Fmod fmod
#else
typedef float t_float;
typedef ImVec2 t_float2;
#define Sin sinf
#define Cos cosf
#define Pow powf
#define Log logf
#define Fmod fmodf
#endif
namespace { namespace {
float RandomRange( float min, float max ) { t_float RandomRange(t_float min, t_float max) {
float scale = rand() / (float) RAND_MAX; t_float scale = rand() / (t_float) RAND_MAX;
return min + scale * ( max - min ); return min + scale * ( max - min );
} }
// utility structure for realtime plot
struct ScrollingData { struct ScrollingData {
int MaxSize; int MaxSize;
int Offset; int Offset;
ImVector<ImVec2> Data; ImVector<t_float2> Data;
ScrollingData() { ScrollingData() {
MaxSize = 1000; MaxSize = 1000;
Offset = 0; Offset = 0;
Data.reserve(MaxSize); Data.reserve(MaxSize);
} }
void AddPoint(float x, float y) { void AddPoint(t_float x, t_float y) {
if (Data.size() < MaxSize) if (Data.size() < MaxSize)
Data.push_back(ImVec2(x,y)); Data.push_back(t_float2(x,y));
else { else {
Data[Offset] = ImVec2(x,y); Data[Offset] = t_float2(x,y);
Offset = (Offset + 1) % MaxSize; Offset = (Offset + 1) % MaxSize;
} }
} }
@ -65,33 +87,35 @@ struct ScrollingData {
} }
}; };
// utility structure for realtime plot
struct RollingData { struct RollingData {
float Span; t_float Span;
ImVector<ImVec2> Data; ImVector<t_float2> Data;
RollingData() { RollingData() {
Span = 10.0f; Span = 10.0f;
Data.reserve(1000); Data.reserve(1000);
} }
void AddPoint(float x, float y) { void AddPoint(t_float x, t_float y) {
float xmod = fmodf(x, Span); t_float xmod = Fmod(x, Span);
if (!Data.empty() && xmod < Data.back().x) if (!Data.empty() && xmod < Data.back().x)
Data.shrink(0); Data.shrink(0);
Data.push_back(ImVec2(xmod, y)); Data.push_back(t_float2(xmod, y));
} }
}; };
// utility structure for benchmark data
struct BenchmarkItem { struct BenchmarkItem {
BenchmarkItem() { BenchmarkItem() {
float y = RandomRange(0,1); t_float y = RandomRange(0,1);
Data = new ImVec2[1000]; Data = new t_float2[1000];
for (int i = 0; i < 1000; ++i) { for (int i = 0; i < 1000; ++i) {
Data[i].x = i*0.001f; Data[i].x = i*0.001f;
Data[i].y = y + RandomRange(-0.01f,0.01f); Data[i].y = y + RandomRange(-0.01f,0.01f);
} }
Col = ImVec4(RandomRange(0,1),RandomRange(0,1),RandomRange(0,1),1); Col = ImVec4((float)RandomRange(0,1),(float)RandomRange(0,1),(float)RandomRange(0,1),1);
} }
~BenchmarkItem() { delete Data; } ~BenchmarkItem() { delete Data; }
ImVec2* Data; t_float2* Data;
ImVec4 Col; ImVec4 Col;
}; };
@ -139,15 +163,21 @@ void ShowDemoWindow(bool* p_open) {
ImGui::Unindent(); ImGui::Unindent();
ImGui::BulletText("Double right click to open the plot context menu."); ImGui::BulletText("Double right click to open the plot context menu.");
ImGui::BulletText("Click legend label icons to show/hide plot items."); ImGui::BulletText("Click legend label icons to show/hide plot items.");
#ifdef IMPLOT_DEMO_USE_DOUBLE
ImGui::BulletText("The demo data precision is: double");
#else
ImGui::BulletText("The demo data precision is: float");
#endif
} }
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
if (ImGui::CollapsingHeader("Line Plots")) { if (ImGui::CollapsingHeader("Line Plots")) {
static float xs1[1001], ys1[1001]; static t_float xs1[1001], ys1[1001];
for (int i = 0; i < 1001; ++i) { for (int i = 0; i < 1001; ++i) {
xs1[i] = i * 0.001f; xs1[i] = i * 0.001f;
ys1[i] = 0.5f + 0.5f * sin(50 * xs1[i]); ys1[i] = 0.5f + 0.5f * Sin(50 * xs1[i]);
} }
static float xs2[11], ys2[11]; static t_float xs2[11], ys2[11];
for (int i = 0; i < 11; ++i) { for (int i = 0; i < 11; ++i) {
xs2[i] = i * 0.1f; xs2[i] = i * 0.1f;
ys2[i] = xs2[i] * xs2[i]; ys2[i] = xs2[i] * xs2[i];
@ -163,19 +193,18 @@ void ShowDemoWindow(bool* p_open) {
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
if (ImGui::CollapsingHeader("Scatter Plots")) { if (ImGui::CollapsingHeader("Scatter Plots")) {
srand(0); srand(0);
static float xs1[100], ys1[100]; static t_float xs1[100], ys1[100];
for (int i = 0; i < 100; ++i) { for (int i = 0; i < 100; ++i) {
xs1[i] = i * 0.01f; xs1[i] = i * 0.01f;
ys1[i] = xs1[i] + 0.1f * ((float)rand() / (float)RAND_MAX); ys1[i] = xs1[i] + 0.1f * ((t_float)rand() / (t_float)RAND_MAX);
} }
static float xs2[50], ys2[50]; static t_float xs2[50], ys2[50];
for (int i = 0; i < 50; i++) { for (int i = 0; i < 50; i++) {
xs2[i] = 0.25f + 0.2f * ((float)rand() / (float)RAND_MAX); xs2[i] = 0.25f + 0.2f * ((t_float)rand() / (t_float)RAND_MAX);
ys2[i] = 0.75f + 0.2f * ((float)rand() / (float)RAND_MAX); ys2[i] = 0.75f + 0.2f * ((t_float)rand() / (t_float)RAND_MAX);
} }
if (ImPlot::BeginPlot("Scatter Plot", NULL, NULL)) { if (ImPlot::BeginPlot("Scatter Plot", NULL, NULL)) {
ImPlot::PlotScatter("Data 1", xs1, ys1, 100); ImPlot::PlotScatter("Data 1", xs1, ys1, 100);
ImPlot::PushStyleVar(ImPlotStyleVar_MarkerSize, 6); ImPlot::PushStyleVar(ImPlotStyleVar_MarkerSize, 6);
ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Square); ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Square);
ImPlot::PushStyleColor(ImPlotCol_MarkerFill, ImVec4(1,0,0,0.25f)); ImPlot::PushStyleColor(ImPlotCol_MarkerFill, ImVec4(1,0,0,0.25f));
@ -183,7 +212,6 @@ void ShowDemoWindow(bool* p_open) {
ImPlot::PlotScatter("Data 2", xs2, ys2, 50); ImPlot::PlotScatter("Data 2", xs2, ys2, 50);
ImPlot::PopStyleColor(2); ImPlot::PopStyleColor(2);
ImPlot::PopStyleVar(2); ImPlot::PopStyleVar(2);
ImPlot::EndPlot(); ImPlot::EndPlot();
} }
} }
@ -192,13 +220,13 @@ void ShowDemoWindow(bool* p_open) {
static bool horz = false; static bool horz = false;
ImGui::Checkbox("Horizontal",&horz); ImGui::Checkbox("Horizontal",&horz);
if (horz) if (horz)
ImPlot::SetNextPlotLimits(0, 110, -0.5f, 9.5f, ImGuiCond_Always); ImPlot::SetNextPlotLimits(0, 110, -0.5, 9.5, ImGuiCond_Always);
else else
ImPlot::SetNextPlotLimits(-0.5f, 9.5f, 0, 110, ImGuiCond_Always); ImPlot::SetNextPlotLimits(-0.5, 9.5, 0, 110, ImGuiCond_Always);
if (ImPlot::BeginPlot("Bar Plot", horz ? "Score": "Student", horz ? "Student" : "Score")) { if (ImPlot::BeginPlot("Bar Plot", horz ? "Score": "Student", horz ? "Student" : "Score")) {
static float midtm[10] = {83, 67, 23, 89, 83, 78, 91, 82, 85, 90}; static t_float midtm[10] = {83, 67, 23, 89, 83, 78, 91, 82, 85, 90};
static float final[10] = {80, 62, 56, 99, 55, 78, 88, 78, 90, 100}; static t_float final[10] = {80, 62, 56, 99, 55, 78, 88, 78, 90, 100};
static float grade[10] = {80, 69, 52, 92, 72, 78, 75, 76, 89, 95}; static t_float grade[10] = {80, 69, 52, 92, 72, 78, 75, 76, 89, 95};
if (horz) { if (horz) {
ImPlot::PlotBarsH("Midterm Exam", midtm, 10, 0.2f, -0.2f); ImPlot::PlotBarsH("Midterm Exam", midtm, 10, 0.2f, -0.2f);
ImPlot::PlotBarsH("Final Exam", final, 10, 0.2f, 0); ImPlot::PlotBarsH("Final Exam", final, 10, 0.2f, 0);
@ -214,17 +242,15 @@ void ShowDemoWindow(bool* p_open) {
} }
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
if (ImGui::CollapsingHeader("Error Bars")) { if (ImGui::CollapsingHeader("Error Bars")) {
float xs[5] = {1,2,3,4,5}; t_float xs[5] = {1,2,3,4,5};
float lin[5] = {8,8,9,7,8}; t_float lin[5] = {8,8,9,7,8};
float bar[5] = {1,2,5,3,4}; t_float bar[5] = {1,2,5,3,4};
float err1[5] = {0.2f, 0.4f, 0.2f, 0.6f, 0.4f}; t_float err1[5] = {0.2f, 0.4f, 0.2f, 0.6f, 0.4f};
float err2[5] = {0.4f, 0.2f, 0.4f, 0.8f, 0.6f}; t_float err2[5] = {0.4f, 0.2f, 0.4f, 0.8f, 0.6f};
ImPlot::SetNextPlotLimits(0, 6, 0, 10); ImPlot::SetNextPlotLimits(0, 6, 0, 10);
if (ImPlot::BeginPlot("##ErrorBars",NULL,NULL)) { if (ImPlot::BeginPlot("##ErrorBars",NULL,NULL)) {
ImPlot::PlotBars("Bar", xs, bar, 5, 0.5f); ImPlot::PlotBars("Bar", xs, bar, 5, 0.5f);
ImPlot::PlotErrorBars("Bar", xs, bar, err1, 5); ImPlot::PlotErrorBars("Bar", xs, bar, err1, 5);
ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle); ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle);
ImPlot::PushStyleVar(ImPlotStyleVar_MarkerSize, 3); ImPlot::PushStyleVar(ImPlotStyleVar_MarkerSize, 3);
ImPlot::PushStyleColor(ImPlotCol_ErrorBar, ImVec4(1,0,0,1)); ImPlot::PushStyleColor(ImPlotCol_ErrorBar, ImVec4(1,0,0,1));
@ -232,14 +258,13 @@ void ShowDemoWindow(bool* p_open) {
ImPlot::PlotLine("Line", xs, lin, 5); ImPlot::PlotLine("Line", xs, lin, 5);
ImPlot::PopStyleVar(2); ImPlot::PopStyleVar(2);
ImPlot::PopStyleColor(); ImPlot::PopStyleColor();
ImPlot::EndPlot(); ImPlot::EndPlot();
} }
} }
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
if (ImGui::CollapsingHeader("Pie Charts")) { if (ImGui::CollapsingHeader("Pie Charts")) {
static const char* labels1[] = {"Frogs","Hogs","Dogs","Logs"}; static const char* labels1[] = {"Frogs","Hogs","Dogs","Logs"};
static float pre_normalized[] = {0.15f, 0.30f, 0.45f, 0.10f}; static t_float pre_normalized[] = {0.15f, 0.30f, 0.45f, 0.10f};
SetNextPlotLimits(0,1,0,1,ImGuiCond_Always); SetNextPlotLimits(0,1,0,1,ImGuiCond_Always);
if (ImPlot::BeginPlot("##Pie1", NULL, NULL, ImVec2(250,250), ImPlotFlags_Legend, 0, 0)) { if (ImPlot::BeginPlot("##Pie1", NULL, NULL, ImVec2(250,250), ImPlotFlags_Legend, 0, 0)) {
@ -258,7 +283,7 @@ void ShowDemoWindow(bool* p_open) {
ImPlot::SetPalette(YlOrRd, 5); ImPlot::SetPalette(YlOrRd, 5);
SetNextPlotLimits(0,1,0,1,ImGuiCond_Always); SetNextPlotLimits(0,1,0,1,ImGuiCond_Always);
static const char* labels2[] = {"One","Two","Three","Four","Five"}; static const char* labels2[] = {"One","Two","Three","Four","Five"};
static float not_normalized[] = {1,2,3,4,5}; static t_float not_normalized[] = {1,2,3,4,5};
if (ImPlot::BeginPlot("##Pie2", NULL, NULL, ImVec2(250,250), ImPlotFlags_Legend, 0, 0)) { if (ImPlot::BeginPlot("##Pie2", NULL, NULL, ImVec2(250,250), ImPlotFlags_Legend, 0, 0)) {
ImPlot::PlotPieChart(labels2, not_normalized, 5, 0.5f, 0.5f, 0.4f); ImPlot::PlotPieChart(labels2, not_normalized, 5, 0.5f, 0.5f, 0.4f);
ImPlot::EndPlot(); ImPlot::EndPlot();
@ -273,7 +298,7 @@ void ShowDemoWindow(bool* p_open) {
static ScrollingData sdata1, sdata2; static ScrollingData sdata1, sdata2;
static RollingData rdata1, rdata2; static RollingData rdata1, rdata2;
ImVec2 mouse = ImGui::GetMousePos(); ImVec2 mouse = ImGui::GetMousePos();
static float t = 0; static t_float t = 0;
if (!paused) { if (!paused) {
t += ImGui::GetIO().DeltaTime; t += ImGui::GetIO().DeltaTime;
sdata1.AddPoint(t, mouse.x * 0.0005f); sdata1.AddPoint(t, mouse.x * 0.0005f);
@ -284,14 +309,14 @@ void ShowDemoWindow(bool* p_open) {
ImPlot::SetNextPlotLimitsX(t - 10, t, paused ? ImGuiCond_Once : ImGuiCond_Always); ImPlot::SetNextPlotLimitsX(t - 10, t, paused ? ImGuiCond_Once : ImGuiCond_Always);
static int rt_axis = ImPlotAxisFlags_Default & ~ImPlotAxisFlags_TickLabels; static int rt_axis = ImPlotAxisFlags_Default & ~ImPlotAxisFlags_TickLabels;
if (ImPlot::BeginPlot("##Scrolling", NULL, NULL, ImVec2(-1,150), ImPlotFlags_Default, rt_axis, rt_axis)) { if (ImPlot::BeginPlot("##Scrolling", NULL, NULL, ImVec2(-1,150), ImPlotFlags_Default, rt_axis, rt_axis)) {
ImPlot::PlotLine("Data 1", &sdata1.Data[0].x, &sdata1.Data[0].y, sdata1.Data.size(), sdata1.Offset, 2 * sizeof(float)); ImPlot::PlotLine("Data 1", &sdata1.Data[0].x, &sdata1.Data[0].y, sdata1.Data.size(), sdata1.Offset, 2 * sizeof(t_float));
ImPlot::PlotLine("Data 2", &sdata2.Data[0].x, &sdata2.Data[0].y, sdata2.Data.size(), sdata2.Offset, 2 * sizeof(float)); ImPlot::PlotLine("Data 2", &sdata2.Data[0].x, &sdata2.Data[0].y, sdata2.Data.size(), sdata2.Offset, 2 * sizeof(t_float));
ImPlot::EndPlot(); ImPlot::EndPlot();
} }
ImPlot::SetNextPlotLimitsX(0, 10, ImGuiCond_Always); ImPlot::SetNextPlotLimitsX(0, 10, ImGuiCond_Always);
if (ImPlot::BeginPlot("##Rolling", NULL, NULL, ImVec2(-1,150), ImPlotFlags_Default, rt_axis, rt_axis)) { if (ImPlot::BeginPlot("##Rolling", NULL, NULL, ImVec2(-1,150), ImPlotFlags_Default, rt_axis, rt_axis)) {
ImPlot::PlotLine("Data 1", &rdata1.Data[0].x, &rdata1.Data[0].y, rdata1.Data.size(), 0, 2 * sizeof(float)); ImPlot::PlotLine("Data 1", &rdata1.Data[0].x, &rdata1.Data[0].y, rdata1.Data.size(), 0, 2 * sizeof(t_float));
ImPlot::PlotLine("Data 2", &rdata2.Data[0].x, &rdata2.Data[0].y, rdata2.Data.size(), 0, 2 * sizeof(float)); ImPlot::PlotLine("Data 2", &rdata2.Data[0].x, &rdata2.Data[0].y, rdata2.Data.size(), 0, 2 * sizeof(t_float));
ImPlot::EndPlot(); ImPlot::EndPlot();
} }
} }
@ -299,8 +324,8 @@ void ShowDemoWindow(bool* p_open) {
if (ImGui::CollapsingHeader("Markers and Text")) { if (ImGui::CollapsingHeader("Markers and Text")) {
ImPlot::SetNextPlotLimits(0, 10, 0, 12); ImPlot::SetNextPlotLimits(0, 10, 0, 12);
if (ImPlot::BeginPlot("##MarkerStyles", NULL, NULL, ImVec2(-1,0), 0, 0, 0)) { if (ImPlot::BeginPlot("##MarkerStyles", NULL, NULL, ImVec2(-1,0), 0, 0, 0)) {
float xs[2] = {1,4}; t_float xs[2] = {1,4};
float ys[2] = {10,11}; t_float ys[2] = {10,11};
// filled // filled
ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle); ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle);
ImPlot::PlotLine("Circle##Fill", xs, ys, 2); ImPlot::PlotLine("Circle##Fill", xs, ys, 2);
@ -374,14 +399,14 @@ void ShowDemoWindow(bool* p_open) {
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
if (ImGui::CollapsingHeader("Log Scale")) { if (ImGui::CollapsingHeader("Log Scale")) {
ImGui::BulletText("Open the plot context menu (double right click) to change scales."); ImGui::BulletText("Open the plot context menu (double right click) to change scales.");
static float xs[1001], ys1[1001], ys2[1001], ys3[1001]; static t_float xs[1001], ys1[1001], ys2[1001], ys3[1001];
for (int i = 0; i < 1001; ++i) { for (int i = 0; i < 1001; ++i) {
xs[i] = (float)(i*0.1f); xs[i] = i*0.1f;
ys1[i] = sin(xs[i]) + 1; ys1[i] = Sin(xs[i]) + 1;
ys2[i] = log(xs[i]); ys2[i] = Log(xs[i]);
ys3[i] = pow(10.0f, xs[i]); ys3[i] = Pow(10.0f, xs[i]);
} }
ImPlot::SetNextPlotLimits(0.1f, 100, 0, 10); ImPlot::SetNextPlotLimits(0.1, 100, 0, 10);
if (ImPlot::BeginPlot("Log Plot", NULL, NULL, ImVec2(-1,0), ImPlotFlags_Default, ImPlotAxisFlags_Default | ImPlotAxisFlags_LogScale )) { if (ImPlot::BeginPlot("Log Plot", NULL, NULL, ImVec2(-1,0), ImPlotFlags_Default, ImPlotAxisFlags_Default | ImPlotAxisFlags_LogScale )) {
ImPlot::PlotLine("f(x) = x", xs, xs, 1001); ImPlot::PlotLine("f(x) = x", xs, xs, 1001);
ImPlot::PlotLine("f(x) = sin(x)+1", xs, ys1, 1001); ImPlot::PlotLine("f(x) = sin(x)+1", xs, ys1, 1001);
@ -398,7 +423,7 @@ void ShowDemoWindow(bool* p_open) {
static ImVec4 y2_col = txt_col; static ImVec4 y2_col = txt_col;
static ImVec4 y3_col = txt_col; static ImVec4 y3_col = txt_col;
static float xs[1001], xs2[1001], ys1[1001], ys2[1001], ys3[1001]; static t_float xs[1001], xs2[1001], ys1[1001], ys2[1001], ys3[1001];
static bool y2_axis = true; static bool y2_axis = true;
static bool y3_axis = false; static bool y3_axis = false;
ImGui::Checkbox("Y-Axis 2", &y2_axis); ImGui::Checkbox("Y-Axis 2", &y2_axis);
@ -411,13 +436,13 @@ void ShowDemoWindow(bool* p_open) {
ImGui::SameLine(); ImGui::SameLine();
ImGui::ColorEdit4("##Col3", &y3_col.x, ImGuiColorEditFlags_NoInputs); ImGui::ColorEdit4("##Col3", &y3_col.x, ImGuiColorEditFlags_NoInputs);
for (int i = 0; i < 1001; ++i) { for (int i = 0; i < 1001; ++i) {
xs[i] = (float)(i*0.1f); xs[i] = (i*0.1f);
ys1[i] = sin(xs[i]) * 3 + 1; ys1[i] = Sin(xs[i]) * 3 + 1;
ys2[i] = cos(xs[i]) * 0.2f + 0.5f; ys2[i] = Cos(xs[i]) * 0.2f + 0.5f;
ys3[i] = sin(xs[i]+0.5f) * 100 + 200; ys3[i] = Sin(xs[i]+0.5f) * 100 + 200;
xs2[i] = xs[i] + 10.0f; xs2[i] = xs[i] + 10.0f;
} }
ImPlot::SetNextPlotLimits(0.1f, 100, 0, 10); ImPlot::SetNextPlotLimits(0.1, 100, 0, 10);
ImPlot::SetNextPlotLimitsY(0, 1, ImGuiCond_Once, 1); ImPlot::SetNextPlotLimitsY(0, 1, ImGuiCond_Once, 1);
ImPlot::SetNextPlotLimitsY(0, 300, ImGuiCond_Once, 2); ImPlot::SetNextPlotLimitsY(0, 300, ImGuiCond_Once, 2);
ImPlot::PushStyleColor(ImPlotCol_YAxis, y1_col); ImPlot::PushStyleColor(ImPlotCol_YAxis, y1_col);
@ -454,23 +479,23 @@ void ShowDemoWindow(bool* p_open) {
ImGui::BulletText("Hold Shift to expand query vertically."); ImGui::BulletText("Hold Shift to expand query vertically.");
ImGui::BulletText("The query rect can be dragged after it's created."); ImGui::BulletText("The query rect can be dragged after it's created.");
ImGui::Unindent(); ImGui::Unindent();
static ImVector<ImVec2> data; static ImVector<t_float2> data;
ImPlotLimits range, query; ImPlotLimits range, query;
if (ImPlot::BeginPlot("##Drawing", NULL, NULL, ImVec2(-1,0), ImPlotFlags_Default | ImPlotFlags_Query, ImPlotAxisFlags_GridLines, ImPlotAxisFlags_GridLines)) { if (ImPlot::BeginPlot("##Drawing", NULL, NULL, ImVec2(-1,0), ImPlotFlags_Default | ImPlotFlags_Query, ImPlotAxisFlags_GridLines, ImPlotAxisFlags_GridLines)) {
if (ImPlot::IsPlotHovered() && ImGui::IsMouseClicked(0) && ImGui::GetIO().KeyCtrl) { if (ImPlot::IsPlotHovered() && ImGui::IsMouseClicked(0) && ImGui::GetIO().KeyCtrl) {
ImPlotPoint pt = ImPlot::GetPlotMousePos(); ImPlotPoint pt = ImPlot::GetPlotMousePos();
data.push_back(ImVec2((float)pt.x, (float)pt.y)); data.push_back(t_float2((t_float)pt.x, (t_float)pt.y));
} }
ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Diamond); ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Diamond);
if (data.size() > 0) if (data.size() > 0)
ImPlot::PlotScatter("Points", &data[0].x, &data[0].y, data.size(), 0, 2 * sizeof(float)); ImPlot::PlotScatter("Points", &data[0].x, &data[0].y, data.size(), 0, 2 * sizeof(t_float));
if (ImPlot::IsPlotQueried() && data.size() > 0) { if (ImPlot::IsPlotQueried() && data.size() > 0) {
ImPlotLimits range2 = ImPlot::GetPlotQuery(); ImPlotLimits range2 = ImPlot::GetPlotQuery();
int cnt = 0; int cnt = 0;
ImVec2 avg; t_float2 avg;
for (int i = 0; i < data.size(); ++i) { for (int i = 0; i < data.size(); ++i) {
if (range2.Contains(data[i])) { if (range2.Contains(data[i].x, data[i].y)) {
avg.x += data[i].x; avg.x += data[i].x;
avg.y += data[i].y; avg.y += data[i].y;
cnt++; cnt++;
@ -493,22 +518,22 @@ void ShowDemoWindow(bool* p_open) {
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
if (ImGui::CollapsingHeader("Views")) { if (ImGui::CollapsingHeader("Views")) {
// mimic's soulthread's imgui_plot demo // mimic's soulthread's imgui_plot demo
static float x_data[512]; static t_float x_data[512];
static float y_data1[512]; static t_float y_data1[512];
static float y_data2[512]; static t_float y_data2[512];
static float y_data3[512]; static t_float y_data3[512];
static float sampling_freq = 44100; static t_float sampling_freq = 44100;
static float freq = 500; static t_float freq = 500;
for (size_t i = 0; i < 512; ++i) { for (size_t i = 0; i < 512; ++i) {
const float t = i / sampling_freq; const t_float t = i / sampling_freq;
x_data[i] = t; x_data[i] = t;
const float arg = 2 * 3.14f * freq * t; const t_float arg = 2 * 3.14f * freq * t;
y_data1[i] = sin(arg); y_data1[i] = Sin(arg);
y_data2[i] = y_data1[i] * -0.6f + sin(2 * arg) * 0.4f; y_data2[i] = y_data1[i] * -0.6f + Sin(2 * arg) * 0.4f;
y_data3[i] = y_data2[i] * -0.6f + sin(3 * arg) * 0.4f; y_data3[i] = y_data2[i] * -0.6f + Sin(3 * arg) * 0.4f;
} }
ImGui::BulletText("Query the first plot to render a subview in the second plot (see above for controls)."); ImGui::BulletText("Query the first plot to render a subview in the second plot (see above for controls).");
ImPlot::SetNextPlotLimits(0,0.01f,-1,1); ImPlot::SetNextPlotLimits(0,0.01,-1,1);
ImPlotAxisFlags flgs = ImPlotAxisFlags_Default & ~ImPlotAxisFlags_TickLabels; ImPlotAxisFlags flgs = ImPlotAxisFlags_Default & ~ImPlotAxisFlags_TickLabels;
ImPlotLimits query; ImPlotLimits query;
if (ImPlot::BeginPlot("##View1",NULL,NULL,ImVec2(-1,150), ImPlotFlags_Default | ImPlotFlags_Query, flgs, flgs)) { if (ImPlot::BeginPlot("##View1",NULL,NULL,ImVec2(-1,150), ImPlotFlags_Default | ImPlotFlags_Query, flgs, flgs)) {
@ -563,23 +588,23 @@ void ShowDemoWindow(bool* p_open) {
} }
ImGui::EndGroup(); ImGui::EndGroup();
ImGui::SameLine(); ImGui::SameLine();
static float t = 0; static t_float t = 0;
if (!paused) { if (!paused) {
t += ImGui::GetIO().DeltaTime; t += ImGui::GetIO().DeltaTime;
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
if (show[i]) if (show[i])
data[i].AddPoint(t, data[i].Data.empty() ? data[i].AddPoint(t, data[i].Data.empty() ?
0.25f + 0.5f * (float)rand() / float(RAND_MAX) : 0.25f + 0.5f * (t_float)rand() / t_float(RAND_MAX) :
data[i].Data.back().y + (0.005f + 0.0002f * (float)rand() / float(RAND_MAX)) * (-1 + 2 * (float)rand() / float(RAND_MAX))); data[i].Data.back().y + (0.005f + 0.0002f * (t_float)rand() / t_float(RAND_MAX)) * (-1 + 2 * (t_float)rand() / t_float(RAND_MAX)));
} }
} }
ImPlot::SetNextPlotLimitsX(t - 10, t, paused ? ImGuiCond_Once : ImGuiCond_Always); ImPlot::SetNextPlotLimitsX((double)t - 10, t, paused ? ImGuiCond_Once : ImGuiCond_Always);
if (ImPlot::BeginPlot("##DND")) { if (ImPlot::BeginPlot("##DND")) {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
if (show[i]) { if (show[i]) {
char label[8]; char label[8];
sprintf(label, "data_%d", i); sprintf(label, "data_%d", i);
ImPlot::PlotLine(label, &data[i].Data[0].x, &data[i].Data[0].y, data[i].Data.size(), data[i].Offset, 2 * sizeof(float)); ImPlot::PlotLine(label, &data[i].Data[0].x, &data[i].Data[0].y, data[i].Data.size(), data[i].Offset, 2 * sizeof(t_float));
} }
} }
ImPlot::EndPlot(); ImPlot::EndPlot();
@ -645,38 +670,38 @@ void ShowDemoWindow(bool* p_open) {
} }
ImGui::EndGroup(); ImGui::EndGroup();
ImGui::SameLine(); ImGui::SameLine();
static float t = 0; static t_float t = 0;
if (!paused) { if (!paused) {
t += ImGui::GetIO().DeltaTime; t += ImGui::GetIO().DeltaTime;
//digital signal values //digital signal values
int i = 0; int i = 0;
if (showDigital[i]) if (showDigital[i])
dataDigital[i].AddPoint(t, sin(2*t) > 0.45); dataDigital[i].AddPoint(t, Sin(2*t) > 0.45);
i++; i++;
if (showDigital[i]) if (showDigital[i])
dataDigital[i].AddPoint(t, sin(2*t) < 0.45); dataDigital[i].AddPoint(t, Sin(2*t) < 0.45);
i++; i++;
if (showDigital[i]) if (showDigital[i])
dataDigital[i].AddPoint(t, fmod(t,5.0f)); dataDigital[i].AddPoint(t, Fmod(t,5.0f));
i++; i++;
if (showDigital[i]) if (showDigital[i])
dataDigital[i].AddPoint(t, sin(2*t) < 0.17); dataDigital[i].AddPoint(t, Sin(2*t) < 0.17);
//Analog signal values //Analog signal values
i = 0; i = 0;
if (showAnalog[i]) if (showAnalog[i])
dataAnalog[i].AddPoint(t, sin(2*t)); dataAnalog[i].AddPoint(t, Sin(2*t));
i++; i++;
if (showAnalog[i]) if (showAnalog[i])
dataAnalog[i].AddPoint(t, cos(2*t)); dataAnalog[i].AddPoint(t, Cos(2*t));
i++; i++;
if (showAnalog[i]) if (showAnalog[i])
dataAnalog[i].AddPoint(t, sin(2*t) * cos(2*t)); dataAnalog[i].AddPoint(t, Sin(2*t) * Cos(2*t));
i++; i++;
if (showAnalog[i]) if (showAnalog[i])
dataAnalog[i].AddPoint(t, sin(2*t) - cos(2*t)); dataAnalog[i].AddPoint(t, Sin(2*t) - Cos(2*t));
} }
ImPlot::SetNextPlotLimitsY(-1, 1); ImPlot::SetNextPlotLimitsY(-1, 1);
ImPlot::SetNextPlotLimitsX(t - 10.0f, t, paused ? ImGuiCond_Once : ImGuiCond_Always); ImPlot::SetNextPlotLimitsX(t - 10.0, t, paused ? ImGuiCond_Once : ImGuiCond_Always);
if (ImPlot::BeginPlot("##Digital")) { if (ImPlot::BeginPlot("##Digital")) {
for (int i = 0; i < K_PLOT_DIGITAL_CH_COUNT; ++i) { for (int i = 0; i < K_PLOT_DIGITAL_CH_COUNT; ++i) {
if (showDigital[i]) { if (showDigital[i]) {
@ -684,7 +709,7 @@ void ShowDemoWindow(bool* p_open) {
sprintf(label, "digital_%d", i); sprintf(label, "digital_%d", i);
ImPlot::PushStyleVar(ImPlotStyleVar_DigitalBitHeight, bitHeight); ImPlot::PushStyleVar(ImPlotStyleVar_DigitalBitHeight, bitHeight);
ImPlot::PushStyleVar(ImPlotStyleVar_DigitalBitGap, bitGap); ImPlot::PushStyleVar(ImPlotStyleVar_DigitalBitGap, bitGap);
ImPlot::PlotDigital(label, &dataDigital[i].Data[0].x, &dataDigital[i].Data[0].y, dataDigital[i].Data.size(), dataDigital[i].Offset, 2 * sizeof(float)); ImPlot::PlotDigital(label, &dataDigital[i].Data[0].x, &dataDigital[i].Data[0].y, dataDigital[i].Data.size(), dataDigital[i].Offset, 2 * sizeof(t_float));
ImPlot::PopStyleVar(2); ImPlot::PopStyleVar(2);
} }
} }
@ -693,7 +718,7 @@ void ShowDemoWindow(bool* p_open) {
char label[32]; char label[32];
sprintf(label, "analog_%d", i); sprintf(label, "analog_%d", i);
if (dataAnalog[i].Data.size() > 0) if (dataAnalog[i].Data.size() > 0)
ImPlot::PlotLine(label, &dataAnalog[i].Data[0].x, &dataAnalog[i].Data[0].y, dataAnalog[i].Data.size(), dataAnalog[i].Offset, 2 * sizeof(float)); ImPlot::PlotLine(label, &dataAnalog[i].Data[0].x, &dataAnalog[i].Data[0].y, dataAnalog[i].Data.size(), dataAnalog[i].Offset, 2 * sizeof(t_float));
} }
} }
ImPlot::EndPlot(); ImPlot::EndPlot();
@ -717,10 +742,10 @@ void ShowDemoWindow(bool* p_open) {
} }
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
if (ImGui::CollapsingHeader("Offset Data")) { if (ImGui::CollapsingHeader("Offset Data")) {
float xs[50], ys[50]; t_float xs[50], ys[50];
for (int i = 0; i < 50; ++i) { for (int i = 0; i < 50; ++i) {
xs[i] = 0.5f + 0.4f * cos(i/50.f * 6.28f); xs[i] = 0.5f + 0.4f * Cos(i/50.f * 6.28f);
ys[i] = 0.5f + 0.4f * sin(i/50.f * 6.28f); ys[i] = 0.5f + 0.4f * Sin(i/50.f * 6.28f);
} }
static int offset = 0; static int offset = 0;
ImGui::SliderInt("Offset", &offset, -100, 100); ImGui::SliderInt("Offset", &offset, -100, 100);
@ -745,9 +770,9 @@ void ShowDemoWindow(bool* p_open) {
ImPlot::PushStyleVar(ImPlotStyleVar_LineWeight, 2); ImPlot::PushStyleVar(ImPlotStyleVar_LineWeight, 2);
ImPlot::SetNextPlotLimits(-0.5f, 9.5f, -0.5f, 9.5f); ImPlot::SetNextPlotLimits(-0.5f, 9.5f, -0.5f, 9.5f);
if (ImPlot::BeginPlot("##Custom", NULL, NULL, ImVec2(-1,0), ImPlotFlags_Default & ~ImPlotFlags_Legend, 0)) { if (ImPlot::BeginPlot("##Custom", NULL, NULL, ImVec2(-1,0), ImPlotFlags_Default & ~ImPlotFlags_Legend, 0)) {
float lin[10] = {8,8,9,7,8,8,8,9,7,8}; t_float lin[10] = {8,8,9,7,8,8,8,9,7,8};
float bar[10] = {1,2,5,3,4,1,2,5,3,4}; t_float bar[10] = {1,2,5,3,4,1,2,5,3,4};
float dot[10] = {7,6,6,7,8,5,6,5,8,7}; t_float dot[10] = {7,6,6,7,8,5,6,5,8,7};
ImPlot::PlotBars("Bar", bar, 10, 0.5f); ImPlot::PlotBars("Bar", bar, 10, 0.5f);
ImPlot::PlotLine("Line", lin, 10); ImPlot::PlotLine("Line", lin, 10);
ImPlot::PushStyleVar(ImPlotStyleVar_LineWeight, 0); ImPlot::PushStyleVar(ImPlotStyleVar_LineWeight, 0);