namespace ImPlot

Overview

namespace ImPlot {

// structs

template <typename _Getter1>
struct Fitter1;

template <typename _Getter1, typename _Getter2>
struct Fitter2;

template <typename _Getter1, typename _Getter2>
struct FitterBarH;

template <typename _Getter1, typename _Getter2>
struct FitterBarV;

template <typename _Getter1>
struct FitterBubbles1;

struct FitterRect;

template <typename _Getter1>
struct FitterX;

template <typename _Getter1>
struct FitterY;

struct Formatter_Time_Data;
struct GetterConstColor;
struct GetterConstSize;

template <typename T>
struct GetterError;

struct GetterFuncPtr;

template <typename _Indexer>
struct GetterHeatmapColMaj;

template <typename _Indexer>
struct GetterHeatmapRowMaj;

struct GetterIdxColor;
struct GetterIdxSize;

template <typename _Getter>
struct GetterLoop;

template <typename _Getter>
struct GetterOverrideX;

template <typename _Getter>
struct GetterOverrideY;

template <typename _IndexerX, typename _IndexerY>
struct GetterXY;

template <typename _IndexerX, typename _IndexerY, typename _IndexerZ>
struct GetterXYZ;

struct HugeTimeData;
struct ImPlotPoint3D;
struct ImPlotStyleVarInfo;

template <typename _Indexer1, typename _Indexer2>
struct IndexerAdd;

struct IndexerConst;

template <typename T>
struct IndexerIdx;

struct IndexerLin;

template <typename T>
struct MaxIdx;

template <int N>
struct NormalDistribution;

struct RectC;

template <class _Getter1, class _Getter2, class _GetterColor>
struct RendererBarsFillH;

template <class _Getter1, class _Getter2, class _GetterColor>
struct RendererBarsFillV;

template <class _Getter1, class _Getter2, class _GetterColor>
struct RendererBarsLineH;

template <class _Getter1, class _Getter2, class _GetterColor>
struct RendererBarsLineV;

struct RendererBase;

template <class _Getter, class _GetterColor>
struct RendererCircleFill;

template <class _Getter, class _GetterColor>
struct RendererCircleLine;

template <class _Getter, class _GetterColor>
struct RendererLineSegments1;

template <class _Getter1, class _Getter2, class _GetterColor>
struct RendererLineSegments2;

template <class _Getter, class _GetterColor>
struct RendererLineStrip;

template <class _Getter, class _GetterColor>
struct RendererLineStripSkip;

template <class _Getter, class _GetterColor, class _GetterSize>
struct RendererMarkersFill;

template <class _Getter, class _GetterColor, class _GetterSize>
struct RendererMarkersLine;

template <typename _Getter>
struct RendererRectC;

template <class _Getter1, class _Getter2, class _GetterColor>
struct RendererShaded;

template <class _Getter, class _GetterColor>
struct RendererStairsPost;

template <class _Getter, class _GetterColor>
struct RendererStairsPostShaded;

template <class _Getter, class _GetterColor>
struct RendererStairsPre;

template <class _Getter, class _GetterColor>
struct RendererStairsPreShaded;

struct RollingBuffer;
struct ScrollingBuffer;
struct Transformer1;
struct Transformer2;

// global variables

static const ImPlotStyleVarInfo GPlotStyleVarInfo[] = {     { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, PlotDefaultSize)    },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, PlotMinSize)        },      { ImGuiDataType_Float, 1,(ImU32)offsetof(ImPlotStyle, PlotBorderSize)     },      { ImGuiDataType_Float, 1,(ImU32)offsetof(ImPlotStyle, MinorAlpha)         },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, MajorTickLen)       },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, MinorTickLen)       },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, MajorTickSize)      },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, MinorTickSize)      },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, MajorGridSize)      },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, MinorGridSize)      },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, PlotPadding)        },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, LabelPadding)       },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, LegendPadding)      },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, LegendInnerPadding) },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, LegendSpacing)      },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, MousePosPadding)    },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, AnnotationPadding)  },      { ImGuiDataType_Float, 2,(ImU32)offsetof(ImPlotStyle, FitPadding)         },      { ImGuiDataType_Float, 1,(ImU32)offsetof(ImPlotStyle, DigitalPadding)     },      { ImGuiDataType_Float, 1,(ImU32)offsetof(ImPlotStyle, DigitalSpacing)     },  };
constexpr float TICK_FILL_X = 0.8f;
constexpr float TICK_FILL_Y = 1.0f;
constexpr double TimeUnitSpans[ImPlotTimeUnit_COUNT] = {     0.000001,     0.001,     1,     60,     3600,     86400,     2629800,     31557600 };
static const char* MONTH_NAMES[] = {"January","February","March","April","May","June","July","August","September","October","November","December"};
static const char* WD_ABRVS[] = {"Su","Mo","Tu","We","Th","Fr","Sa"};
static const char* MONTH_ABRVS[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
static const ImPlotDateTimeSpec TimeFormatLevel0[ImPlotTimeUnit_COUNT] = {     ImPlotDateTimeSpec(ImPlotDateFmt_None,  ImPlotTimeFmt_Us),     ImPlotDateTimeSpec(ImPlotDateFmt_None,  ImPlotTimeFmt_SMs),     ImPlotDateTimeSpec(ImPlotDateFmt_None,  ImPlotTimeFmt_S),     ImPlotDateTimeSpec(ImPlotDateFmt_None,  ImPlotTimeFmt_HrMin),     ImPlotDateTimeSpec(ImPlotDateFmt_None,  ImPlotTimeFmt_Hr),     ImPlotDateTimeSpec(ImPlotDateFmt_DayMo, ImPlotTimeFmt_None),     ImPlotDateTimeSpec(ImPlotDateFmt_Mo,    ImPlotTimeFmt_None),     ImPlotDateTimeSpec(ImPlotDateFmt_Yr,    ImPlotTimeFmt_None) };
static const ImPlotDateTimeSpec TimeFormatLevel1[ImPlotTimeUnit_COUNT] = {     ImPlotDateTimeSpec(ImPlotDateFmt_None,    ImPlotTimeFmt_HrMin),     ImPlotDateTimeSpec(ImPlotDateFmt_None,    ImPlotTimeFmt_HrMinS),     ImPlotDateTimeSpec(ImPlotDateFmt_None,    ImPlotTimeFmt_HrMin),     ImPlotDateTimeSpec(ImPlotDateFmt_None,    ImPlotTimeFmt_HrMin),     ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),     ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),     ImPlotDateTimeSpec(ImPlotDateFmt_Yr,      ImPlotTimeFmt_None),     ImPlotDateTimeSpec(ImPlotDateFmt_Yr,      ImPlotTimeFmt_None) };
static const ImPlotDateTimeSpec TimeFormatLevel1First[ImPlotTimeUnit_COUNT] = {     ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMinS),     ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMinS),     ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMin),     ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_HrMin),     ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),     ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr, ImPlotTimeFmt_None),     ImPlotDateTimeSpec(ImPlotDateFmt_Yr,      ImPlotTimeFmt_None),     ImPlotDateTimeSpec(ImPlotDateFmt_Yr,      ImPlotTimeFmt_None) };
static const ImPlotDateTimeSpec TimeFormatMouseCursor[ImPlotTimeUnit_COUNT] = {     ImPlotDateTimeSpec(ImPlotDateFmt_None,     ImPlotTimeFmt_Us),     ImPlotDateTimeSpec(ImPlotDateFmt_None,     ImPlotTimeFmt_SUs),     ImPlotDateTimeSpec(ImPlotDateFmt_None,     ImPlotTimeFmt_SMs),     ImPlotDateTimeSpec(ImPlotDateFmt_None,     ImPlotTimeFmt_HrMinS),     ImPlotDateTimeSpec(ImPlotDateFmt_None,     ImPlotTimeFmt_HrMin),     ImPlotDateTimeSpec(ImPlotDateFmt_DayMo,    ImPlotTimeFmt_Hr),     ImPlotDateTimeSpec(ImPlotDateFmt_DayMoYr,  ImPlotTimeFmt_None),     ImPlotDateTimeSpec(ImPlotDateFmt_MoYr,     ImPlotTimeFmt_None) };
constexpr float MOUSE_CURSOR_DRAG_THRESHOLD = 5.0f;
constexpr float BOX_SELECT_DRAG_THRESHOLD = 4.0f;
constexpr float SUBPLOT_BORDER_SIZE = 1.0f;
constexpr float SUBPLOT_SPLITTER_HALF_THICKNESS = 4.0f;
constexpr float SUBPLOT_SPLITTER_FEEDBACK_TIMER = 0.06f;
constexpr float DRAG_GRAB_HALF_SIZE = 4.0f;
constexpr float ITEM_HIGHLIGHT_LINE_SCALE = 2.0f;
constexpr float ITEM_HIGHLIGHT_MARK_SCALE = 1.25f;
static const ImVec2 MARKER_FILL_CIRCLE[10] = {ImVec2(1.0f, 0.0f), ImVec2(0.809017f, 0.58778524f),ImVec2(0.30901697f, 0.95105654f),ImVec2(-0.30901703f, 0.9510565f),ImVec2(-0.80901706f, 0.5877852f),ImVec2(-1.0f, 0.0f),ImVec2(-0.80901694f, -0.58778536f),ImVec2(-0.3090171f, -0.9510565f),ImVec2(0.30901712f, -0.9510565f),ImVec2(0.80901694f, -0.5877853f)};
static const ImVec2 MARKER_FILL_SQUARE[4] = {ImVec2(SQRT_1_2,SQRT_1_2), ImVec2(SQRT_1_2,-SQRT_1_2), ImVec2(-SQRT_1_2,-SQRT_1_2), ImVec2(-SQRT_1_2,SQRT_1_2)};
static const ImVec2 MARKER_FILL_DIAMOND[4] = {ImVec2(1, 0), ImVec2(0, -1), ImVec2(-1, 0), ImVec2(0, 1)};
static const ImVec2 MARKER_FILL_UP[3] = {ImVec2(SQRT_3_2,0.5f),ImVec2(0,-1),ImVec2(-SQRT_3_2,0.5f)};
static const ImVec2 MARKER_FILL_DOWN[3] = {ImVec2(SQRT_3_2,-0.5f),ImVec2(0,1),ImVec2(-SQRT_3_2,-0.5f)};
static const ImVec2 MARKER_FILL_LEFT[3] = {ImVec2(-1,0), ImVec2(0.5, SQRT_3_2), ImVec2(0.5, -SQRT_3_2)};
static const ImVec2 MARKER_FILL_RIGHT[3] = {ImVec2(1,0), ImVec2(-0.5, SQRT_3_2), ImVec2(-0.5, -SQRT_3_2)};
static const ImVec2 MARKER_LINE_CIRCLE[20] = {     ImVec2(1.0f, 0.0f),     ImVec2(0.809017f, 0.58778524f),     ImVec2(0.809017f, 0.58778524f),     ImVec2(0.30901697f, 0.95105654f),     ImVec2(0.30901697f, 0.95105654f),     ImVec2(-0.30901703f, 0.9510565f),     ImVec2(-0.30901703f, 0.9510565f),     ImVec2(-0.80901706f, 0.5877852f),     ImVec2(-0.80901706f, 0.5877852f),     ImVec2(-1.0f, 0.0f),     ImVec2(-1.0f, 0.0f),     ImVec2(-0.80901694f, -0.58778536f),     ImVec2(-0.80901694f, -0.58778536f),     ImVec2(-0.3090171f, -0.9510565f),     ImVec2(-0.3090171f, -0.9510565f),     ImVec2(0.30901712f, -0.9510565f),     ImVec2(0.30901712f, -0.9510565f),     ImVec2(0.80901694f, -0.5877853f),     ImVec2(0.80901694f, -0.5877853f),     ImVec2(1.0f, 0.0f) };
constexpr ImVec2 MARKER_LINE_SQUARE[8] = {ImVec2(SQRT_1_2,SQRT_1_2), ImVec2(SQRT_1_2,-SQRT_1_2), ImVec2(SQRT_1_2,-SQRT_1_2), ImVec2(-SQRT_1_2,-SQRT_1_2), ImVec2(-SQRT_1_2,-SQRT_1_2), ImVec2(-SQRT_1_2,SQRT_1_2), ImVec2(-SQRT_1_2,SQRT_1_2), ImVec2(SQRT_1_2,SQRT_1_2)};
constexpr ImVec2 MARKER_LINE_DIAMOND[8] = {ImVec2(1, 0), ImVec2(0, -1), ImVec2(0, -1), ImVec2(-1, 0), ImVec2(-1, 0), ImVec2(0, 1), ImVec2(0, 1), ImVec2(1, 0)};
constexpr ImVec2 MARKER_LINE_UP[6] = {ImVec2(SQRT_3_2,0.5f), ImVec2(0,-1),ImVec2(0,-1),ImVec2(-SQRT_3_2,0.5f),ImVec2(-SQRT_3_2,0.5f),ImVec2(SQRT_3_2,0.5f)};
constexpr ImVec2 MARKER_LINE_DOWN[6] = {ImVec2(SQRT_3_2,-0.5f),ImVec2(0,1),ImVec2(0,1),ImVec2(-SQRT_3_2,-0.5f), ImVec2(-SQRT_3_2,-0.5f), ImVec2(SQRT_3_2,-0.5f)};
constexpr ImVec2 MARKER_LINE_LEFT[6] = {ImVec2(-1,0), ImVec2(0.5, SQRT_3_2),  ImVec2(0.5, SQRT_3_2),  ImVec2(0.5, -SQRT_3_2) , ImVec2(0.5, -SQRT_3_2) , ImVec2(-1,0) };
constexpr ImVec2 MARKER_LINE_RIGHT[6] = {ImVec2(1,0),  ImVec2(-0.5, SQRT_3_2), ImVec2(-0.5, SQRT_3_2), ImVec2(-0.5, -SQRT_3_2), ImVec2(-0.5, -SQRT_3_2), ImVec2(1,0) };
constexpr ImVec2 MARKER_LINE_ASTERISK[6] = {ImVec2(-SQRT_3_2, -0.5f), ImVec2(SQRT_3_2, 0.5f),  ImVec2(-SQRT_3_2, 0.5f), ImVec2(SQRT_3_2, -0.5f), ImVec2(0, -1), ImVec2(0, 1)};
constexpr ImVec2 MARKER_LINE_PLUS[4] = {ImVec2(-1, 0), ImVec2(1, 0), ImVec2(0, -1), ImVec2(0, 1)};
constexpr ImVec2 MARKER_LINE_CROSS[4] = {ImVec2(-SQRT_1_2,-SQRT_1_2),ImVec2(SQRT_1_2,SQRT_1_2),ImVec2(SQRT_1_2,-SQRT_1_2),ImVec2(-SQRT_1_2,SQRT_1_2)};
constexpr ImVec2 MARKER_LINE_VERTICAL[2] = {ImVec2(0, -1), ImVec2(0, 1)};
constexpr ImVec2 MARKER_LINE_HORIZONTAL[2] = {ImVec2(-1, 0), ImVec2(1, 0)};

// global functions

const char* GetStyleColorName(ImPlotCol col);
const char* GetMarkerName(ImPlotMarker marker);
ImVec4 GetAutoColor(ImPlotCol idx);
static const ImPlotStyleVarInfo* GetPlotStyleVarInfo(ImPlotStyleVar idx);

void AddTextVertical(
    ImDrawList* DrawList,
    ImVec2 pos,
    ImU32 col,
    const char* text_begin,
    const char* text_end
    );

void AddTextCentered(
    ImDrawList* DrawList,
    ImVec2 top_center,
    ImU32 col,
    const char* text_begin,
    const char* text_end
    );

double NiceNum(
    double x,
    bool round
    );

void SetImGuiContext(ImGuiContext* ctx);
ImPlotContext* CreateContext();
void DestroyContext(ImPlotContext* ctx);
ImPlotContext* GetCurrentContext();
void SetCurrentContext(ImPlotContext* ctx);
void Initialize(ImPlotContext* ctx);
void ResetCtxForNextPlot(ImPlotContext* ctx);
void ResetCtxForNextAlignedPlots(ImPlotContext* ctx);
void ResetCtxForNextSubplot(ImPlotContext* ctx);
ImPlotPlot* GetPlot(const char* title);
ImPlotPlot* GetCurrentPlot();
void BustPlotCache();

ImVec2 GetLocationPos(
    const ImRect& outer_rect,
    const ImVec2& inner_size,
    ImPlotLocation loc,
    const ImVec2& pad
    );

ImVec2 CalcLegendSize(
    ImPlotItemGroup& items,
    const ImVec2& pad,
    const ImVec2& spacing,
    bool vertical
    );

bool ClampLegendRect(
    ImRect& legend_rect,
    const ImRect& outer_rect,
    const ImVec2& pad
    );

int LegendSortingComp(
    const void* _a,
    const void* _b
    );

bool ShowLegendEntries(
    ImPlotItemGroup& items,
    const ImRect& legend_bb,
    bool hovered,
    const ImVec2& pad,
    const ImVec2& spacing,
    bool vertical,
    ImDrawList& DrawList
    );

void Locator_Default(
    ImPlotTicker& ticker,
    const ImPlotRange& range,
    float pixels,
    bool vertical,
    ImPlotFormatter formatter,
    void* formatter_data
    );

bool CalcLogarithmicExponents(
    const ImPlotRange& range,
    float pix,
    bool vertical,
    int& exp_min,
    int& exp_max,
    int& exp_step
    );

void AddTicksLogarithmic(
    const ImPlotRange& range,
    int exp_min,
    int exp_max,
    int exp_step,
    ImPlotTicker& ticker,
    ImPlotFormatter formatter,
    void* data
    );

void Locator_Log10(
    ImPlotTicker& ticker,
    const ImPlotRange& range,
    float pixels,
    bool vertical,
    ImPlotFormatter formatter,
    void* formatter_data
    );

float CalcSymLogPixel(
    double plt,
    const ImPlotRange& range,
    float pixels
    );

void Locator_SymLog(
    ImPlotTicker& ticker,
    const ImPlotRange& range,
    float pixels,
    bool vertical,
    ImPlotFormatter formatter,
    void* formatter_data
    );

void AddTicksCustom(
    const double* values,
    const char*const labels [],
    int n,
    ImPlotTicker& ticker,
    ImPlotFormatter formatter,
    void* data
    );

ImPlotTimeUnit GetUnitForRange(double range);

int LowerBoundStep(
    int max_divs,
    const int* divs,
    const int* step,
    int size
    );

int GetTimeStep(
    int max_divs,
    ImPlotTimeUnit unit
    );

ImPlotTime MkGmtTime(struct tm* ptm);

tm* GetGmtTime(
    const ImPlotTime& t,
    tm* ptm
    );

ImPlotTime MkLocTime(struct tm* ptm);

tm* GetLocTime(
    const ImPlotTime& t,
    tm* ptm
    );

ImPlotTime MakeTime(
    int year,
    int month,
    int day,
    int hour,
    int min,
    int sec,
    int us
    );

int GetYear(const ImPlotTime& t);
int GetMonth(const ImPlotTime& t);

ImPlotTime AddTime(
    const ImPlotTime& t,
    ImPlotTimeUnit unit,
    int count
    );

ImPlotTime FloorTime(
    const ImPlotTime& t,
    ImPlotTimeUnit unit
    );

ImPlotTime CeilTime(
    const ImPlotTime& t,
    ImPlotTimeUnit unit
    );

ImPlotTime RoundTime(
    const ImPlotTime& t,
    ImPlotTimeUnit unit
    );

ImPlotTime CombineDateTime(
    const ImPlotTime& date_part,
    const ImPlotTime& tod_part
    );

int FormatTime(
    const ImPlotTime& t,
    char* buffer,
    int size,
    ImPlotTimeFmt fmt,
    bool use_24_hr_clk
    );

int FormatDate(
    const ImPlotTime& t,
    char* buffer,
    int size,
    ImPlotDateFmt fmt,
    bool use_iso_8601
    );

int FormatDateTime(
    const ImPlotTime& t,
    char* buffer,
    int size,
    ImPlotDateTimeSpec fmt
    );

float GetDateTimeWidth(ImPlotDateTimeSpec fmt);

bool TimeLabelSame(
    const char* l1,
    const char* l2
    );

ImPlotDateTimeSpec GetDateTimeFmt(
    const ImPlotDateTimeSpec* ctx,
    ImPlotTimeUnit idx
    );

void Locator_Time(
    ImPlotTicker& ticker,
    const ImPlotRange& range,
    float pixels,
    bool vertical,
    ImPlotFormatter formatter,
    void* formatter_data
    );

template <typename F>
bool DragFloat(
    const char*,
    F*,
    float,
    F,
    F
    );

bool DragFloat< double >(
    const char* label,
    double* v,
    float v_speed,
    double v_min,
    double v_max
    );

bool DragFloat< float >(
    const char* label,
    float* v,
    float v_speed,
    float v_min,
    float v_max
    );

void BeginDisabledControls(bool cond);
void EndDisabledControls(bool cond);

void ShowAxisContextMenu(
    ImPlotAxis& axis,
    ImPlotAxis* equal_axis,
    bool time_allowed
    );

bool ShowLegendContextMenu(
    ImPlotLegend& legend,
    bool visible
    );

void ShowSubplotsContextMenu(ImPlotSubplot& subplot);
void ShowPlotContextMenu(ImPlotPlot& plot);
static int AxisPrecision(const ImPlotAxis& axis);

static double RoundAxisValue(
    const ImPlotAxis& axis,
    double value
    );

void LabelAxisValue(
    const ImPlotAxis& axis,
    double value,
    char* buff,
    int size,
    bool round
    );

void UpdateAxisColors(ImPlotAxis& axis);

void PadAndDatumAxesX(
    ImPlotPlot& plot,
    float& pad_T,
    float& pad_B,
    ImPlotAlignmentData* align
    );

void PadAndDatumAxesY(
    ImPlotPlot& plot,
    float& pad_L,
    float& pad_R,
    ImPlotAlignmentData* align
    );

static void RenderGridLinesX(
    ImDrawList& DrawList,
    const ImPlotTicker& ticker,
    const ImRect& rect,
    ImU32 col_maj,
    ImU32 col_min,
    float size_maj,
    float size_min
    );

static void RenderGridLinesY(
    ImDrawList& DrawList,
    const ImPlotTicker& ticker,
    const ImRect& rect,
    ImU32 col_maj,
    ImU32 col_min,
    float size_maj,
    float size_min
    );

static void RenderSelectionRect(
    ImDrawList& DrawList,
    const ImVec2& p_min,
    const ImVec2& p_max,
    const ImVec4& col
    );

bool UpdateInput(ImPlotPlot& plot);
void ApplyNextPlotData(ImAxis idx);

void SetupAxis(
    ImAxis idx,
    const char* label,
    ImPlotAxisFlags flags
    );

void SetupAxisLimits(
    ImAxis idx,
    double min_lim,
    double max_lim,
    ImPlotCond cond
    );

void SetupAxisFormat(
    ImAxis idx,
    const char* fmt
    );

void SetupAxisLinks(
    ImAxis idx,
    double* min_lnk,
    double* max_lnk
    );

void SetupAxisFormat(
    ImAxis idx,
    ImPlotFormatter formatter,
    void* data
    );

void SetupAxisTicks(
    ImAxis idx,
    const double* values,
    int n_ticks,
    const char*const labels [],
    bool show_default
    );

void SetupAxisTicks(
    ImAxis idx,
    double v_min,
    double v_max,
    int n_ticks,
    const char*const labels [],
    bool show_default
    );

void SetupAxisScale(
    ImAxis idx,
    ImPlotScale scale
    );

void SetupAxisScale(
    ImAxis idx,
    ImPlotTransform fwd,
    ImPlotTransform inv,
    void* data
    );

void SetupAxisLimitsConstraints(
    ImAxis idx,
    double v_min,
    double v_max
    );

void SetupAxisZoomConstraints(
    ImAxis idx,
    double z_min,
    double z_max
    );

void SetupAxes(
    const char* x_label,
    const char* y_label,
    ImPlotAxisFlags x_flags,
    ImPlotAxisFlags y_flags
    );

void SetupAxesLimits(
    double x_min,
    double x_max,
    double y_min,
    double y_max,
    ImPlotCond cond
    );

void SetupLegend(
    ImPlotLocation location,
    ImPlotLegendFlags flags
    );

void SetupMouseText(
    ImPlotLocation location,
    ImPlotMouseTextFlags flags
    );

void SetNextAxisLimits(
    ImAxis axis,
    double v_min,
    double v_max,
    ImPlotCond cond
    );

void SetNextAxisLinks(
    ImAxis axis,
    double* link_min,
    double* link_max
    );

void SetNextAxisToFit(ImAxis axis);

void SetNextAxesLimits(
    double x_min,
    double x_max,
    double y_min,
    double y_max,
    ImPlotCond cond
    );

void SetNextAxesToFit();

bool BeginPlot(
    const char* title_id,
    const ImVec2& size,
    ImPlotFlags flags
    );

void SetupFinish();
void EndPlot();

void SubplotSetCell(
    int row,
    int col
    );

void SubplotSetCell(int idx);
void SubplotNextCell();

bool BeginSubplots(
    const char* title,
    int rows,
    int cols,
    const ImVec2& size,
    ImPlotSubplotFlags flags,
    float* row_sizes,
    float* col_sizes
    );

void EndSubplots();
void SetAxis(ImAxis axis);

void SetAxes(
    ImAxis x_idx,
    ImAxis y_idx
    );

ImPlotPoint PixelsToPlot(
    float x,
    float y,
    ImAxis x_idx,
    ImAxis y_idx
    );

ImPlotPoint PixelsToPlot(
    const ImVec2& pix,
    ImAxis x_idx,
    ImAxis y_idx
    );

ImVec2 PlotToPixels(
    double x,
    double y,
    ImAxis x_idx,
    ImAxis y_idx
    );

ImVec2 PlotToPixels(
    const ImPlotPoint& plt,
    ImAxis x_idx,
    ImAxis y_idx
    );

ImVec2 GetPlotPos();
ImVec2 GetPlotSize();

ImPlotPoint GetPlotMousePos(
    ImAxis x_idx,
    ImAxis y_idx
    );

ImPlotRect GetPlotLimits(
    ImAxis x_idx,
    ImAxis y_idx
    );

bool IsPlotHovered();
bool IsAxisHovered(ImAxis axis);
bool IsSubplotsHovered();
bool IsPlotSelected();

ImPlotRect GetPlotSelection(
    ImAxis x_idx,
    ImAxis y_idx
    );

void CancelPlotSelection();

void HideNextItem(
    bool hidden,
    ImPlotCond cond
    );

void Annotation(
    double x,
    double y,
    const ImVec4& col,
    const ImVec2& offset,
    bool clamp,
    bool round
    );

void AnnotationV(
    double x,
    double y,
    const ImVec4& col,
    const ImVec2& offset,
    bool clamp,
    const char* fmt,
    va_list args
    );

void Annotation(
    double x,
    double y,
    const ImVec4& col,
    const ImVec2& offset,
    bool clamp,
    const char* fmt,
    ...
    );

void TagV(
    ImAxis axis,
    double v,
    const ImVec4& col,
    const char* fmt,
    va_list args
    );

void Tag(
    ImAxis axis,
    double v,
    const ImVec4& col,
    const char* fmt,
    ...
    );

void Tag(
    ImAxis axis,
    double v,
    const ImVec4& color,
    bool round
    );

IMPLOT_API void TagX(
    double x,
    const ImVec4& color,
    bool round
    );

IMPLOT_API void TagX(
    double x,
    const ImVec4& color,
    const char* fmt,
    ...
    );

IMPLOT_API void TagXV(
    double x,
    const ImVec4& color,
    const char* fmt,
    va_list args
    );

IMPLOT_API void TagY(
    double y,
    const ImVec4& color,
    bool round
    );

IMPLOT_API void TagY(
    double y,
    const ImVec4& color,
    const char* fmt,
    ...
    );

IMPLOT_API void TagYV(
    double y,
    const ImVec4& color,
    const char* fmt,
    va_list args
    );

bool DragPoint(
    int n_id,
    double* x,
    double* y,
    const ImVec4& col,
    float radius,
    ImPlotDragToolFlags flags,
    bool* out_clicked,
    bool* out_hovered,
    bool* out_held
    );

bool DragLineX(
    int n_id,
    double* value,
    const ImVec4& col,
    float thickness,
    ImPlotDragToolFlags flags,
    bool* out_clicked,
    bool* out_hovered,
    bool* out_held
    );

bool DragLineY(
    int n_id,
    double* value,
    const ImVec4& col,
    float thickness,
    ImPlotDragToolFlags flags,
    bool* out_clicked,
    bool* out_hovered,
    bool* out_held
    );

bool DragRect(
    int n_id,
    double* x_min,
    double* y_min,
    double* x_max,
    double* y_max,
    const ImVec4& col,
    ImPlotDragToolFlags flags,
    bool* out_clicked,
    bool* out_hovered,
    bool* out_held
    );

bool DragRect(
    int id,
    ImPlotRect* bounds,
    const ImVec4& col,
    ImPlotDragToolFlags flags,
    bool* out_clicked,
    bool* out_hovered,
    bool* out_held
    );

bool IsLegendEntryHovered(const char* label_id);

bool BeginLegendPopup(
    const char* label_id,
    ImGuiMouseButton mouse_button
    );

void EndLegendPopup();

void ShowAltLegend(
    const char* title_id,
    bool vertical,
    const ImVec2 size,
    bool interactable
    );

bool BeginDragDropTargetPlot();
bool BeginDragDropTargetAxis(ImAxis axis);
bool BeginDragDropTargetLegend();
void EndDragDropTarget();
bool BeginDragDropSourcePlot(ImGuiDragDropFlags flags);

bool BeginDragDropSourceAxis(
    ImAxis idx,
    ImGuiDragDropFlags flags
    );

bool BeginDragDropSourceItem(
    const char* label_id,
    ImGuiDragDropFlags flags
    );

void EndDragDropSource();

bool BeginAlignedPlots(
    const char* group_id,
    bool vertical
    );

void EndAlignedPlots();
ImPlotStyle& GetStyle();

void PushStyleColor(
    ImPlotCol idx,
    ImU32 col
    );

void PushStyleColor(
    ImPlotCol idx,
    const ImVec4& col
    );

void PopStyleColor(int count);

void PushStyleVar(
    ImPlotStyleVar idx,
    float val
    );

void PushStyleVar(
    ImPlotStyleVar idx,
    int val
    );

void PushStyleVar(
    ImPlotStyleVar idx,
    const ImVec2& val
    );

void PopStyleVar(int count);
ImPlotMarker NextMarker();

ImPlotColormap AddColormap(
    const char* name,
    const ImVec4* colormap,
    int size,
    bool qual
    );

ImPlotColormap AddColormap(
    const char* name,
    const ImU32* colormap,
    int size,
    bool qual
    );

int GetColormapCount();
const char* GetColormapName(ImPlotColormap colormap);
ImPlotColormap GetColormapIndex(const char* name);
void PushColormap(ImPlotColormap colormap);
void PushColormap(const char* name);
void PopColormap(int count);
ImU32 NextColormapColorU32();
ImVec4 NextColormapColor();
int GetColormapSize(ImPlotColormap cmap);

ImU32 GetColormapColorU32(
    int idx,
    ImPlotColormap cmap
    );

ImVec4 GetColormapColor(
    int idx,
    ImPlotColormap cmap
    );

ImU32 SampleColormapU32(
    float t,
    ImPlotColormap cmap
    );

ImVec4 SampleColormap(
    float t,
    ImPlotColormap cmap
    );

void RenderColorBar(
    const ImU32* colors,
    int size,
    ImDrawList& DrawList,
    const ImRect& bounds,
    bool vert,
    bool reversed,
    bool continuous
    );

void ColormapScale(
    const char* label,
    double scale_min,
    double scale_max,
    const ImVec2& size,
    const char* format,
    ImPlotColormapScaleFlags flags,
    ImPlotColormap cmap
    );

bool ColormapSlider(
    const char* label,
    float* t,
    ImVec4* out,
    const char* format,
    ImPlotColormap cmap
    );

bool ColormapButton(
    const char* label,
    const ImVec2& size_arg,
    ImPlotColormap cmap
    );

ImPlotInputMap& GetInputMap();
void MapInputDefault(ImPlotInputMap* dst);
void MapInputReverse(ImPlotInputMap* dst);
void ItemIcon(const ImVec4& col);
void ItemIcon(ImU32 col);
void ColormapIcon(ImPlotColormap cmap);
ImDrawList* GetPlotDrawList();
void PushPlotClipRect(float expand);
void PopPlotClipRect();
static void HelpMarker(const char* desc);
bool ShowStyleSelector(const char* label);
bool ShowColormapSelector(const char* label);
bool ShowInputMapSelector(const char* label);
void ShowStyleEditor(ImPlotStyle* ref);
void ShowUserGuide();
void ShowTicksMetrics(const ImPlotTicker& ticker);

void ShowAxisMetrics(
    const ImPlotPlot& plot,
    const ImPlotAxis& axis
    );

void ShowMetricsWindow(bool* p_popen);

bool ShowDatePicker(
    const char* id,
    int* level,
    ImPlotTime* t,
    const ImPlotTime* t1,
    const ImPlotTime* t2
    );

bool ShowTimePicker(
    const char* id,
    ImPlotTime* t
    );

void StyleColorsAuto(ImPlotStyle* dst);
void StyleColorsClassic(ImPlotStyle* dst);
void StyleColorsDark(ImPlotStyle* dst);
void StyleColorsLight(ImPlotStyle* dst);

IMPLOT_TMP void PlotLine(
    const char* label_id,
    const T* values,
    int count,
    double xscale = 1,
    double xstart = 0,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotLine(
    const char* label_id,
    const T* xs,
    const T* ys,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_API void PlotLineG(
    const char* label_id,
    ImPlotGetter getter,
    void* data,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotScatter(
    const char* label_id,
    const T* values,
    int count,
    double xscale = 1,
    double xstart = 0,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotScatter(
    const char* label_id,
    const T* xs,
    const T* ys,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_API void PlotScatterG(
    const char* label_id,
    ImPlotGetter getter,
    void* data,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotBubbles(
    const char* label_id,
    const T* values,
    const T* szs,
    int count,
    double xscale = 1,
    double xstart = 0,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotBubbles(
    const char* label_id,
    const T* xs,
    const T* ys,
    const T* szs,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotPolygon(
    const char* label_id,
    const T* xs,
    const T* ys,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotStairs(
    const char* label_id,
    const T* values,
    int count,
    double xscale = 1,
    double xstart = 0,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotStairs(
    const char* label_id,
    const T* xs,
    const T* ys,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_API void PlotStairsG(
    const char* label_id,
    ImPlotGetter getter,
    void* data,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotShaded(
    const char* label_id,
    const T* values,
    int count,
    double yref = 0,
    double xscale = 1,
    double xstart = 0,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotShaded(
    const char* label_id,
    const T* xs,
    const T* ys,
    int count,
    double yref = 0,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotShaded(
    const char* label_id,
    const T* xs,
    const T* ys1,
    const T* ys2,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_API void PlotShadedG(
    const char* label_id,
    ImPlotGetter getter1,
    void* data1,
    ImPlotGetter getter2,
    void* data2,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotBars(
    const char* label_id,
    const T* values,
    int count,
    double bar_size = 0.67,
    double shift = 0,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotBars(
    const char* label_id,
    const T* xs,
    const T* ys,
    int count,
    double bar_size,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_API void PlotBarsG(
    const char* label_id,
    ImPlotGetter getter,
    void* data,
    int count,
    double bar_size,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotBarGroups(
    const char*const label_ids [],
    const T* values,
    int item_count,
    int group_count,
    double group_size = 0.67,
    double shift = 0,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotErrorBars(
    const char* label_id,
    const T* xs,
    const T* ys,
    const T* err,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotErrorBars(
    const char* label_id,
    const T* xs,
    const T* ys,
    const T* neg,
    const T* pos,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotStems(
    const char* label_id,
    const T* values,
    int count,
    double ref = 0,
    double scale = 1,
    double start = 0,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotStems(
    const char* label_id,
    const T* xs,
    const T* ys,
    int count,
    double ref = 0,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotInfLines(
    const char* label_id,
    const T* values,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotPieChart(
    const char*const label_ids [],
    const T* values,
    int count,
    double x,
    double y,
    double radius,
    ImPlotFormatter fmt,
    void* fmt_data = nullptr,
    double angle0 = 90,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotPieChart(
    const char*const label_ids [],
    const T* values,
    int count,
    double x,
    double y,
    double radius,
    const char* label_fmt = "%.1f",
    double angle0 = 90,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotHeatmap(
    const char* label_id,
    const T* values,
    int rows,
    int cols,
    double scale_min = 0,
    double scale_max = 0,
    const char* label_fmt = "%.1f",
    const ImPlotPoint& bounds_min = ImPlotPoint(0, 0),
    const ImPlotPoint& bounds_max = ImPlotPoint(1, 1),
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP double PlotHistogram(
    const char* label_id,
    const T* values,
    int count,
    int bins = ImPlotBin_Sturges,
    double bar_scale = 1.0,
    ImPlotRange range = ImPlotRange(),
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP double PlotHistogram2D(
    const char* label_id,
    const T* xs,
    const T* ys,
    int count,
    int x_bins = ImPlotBin_Sturges,
    int y_bins = ImPlotBin_Sturges,
    ImPlotRect range = ImPlotRect(),
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_TMP void PlotDigital(
    const char* label_id,
    const T* xs,
    const T* ys,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_API void PlotDigitalG(
    const char* label_id,
    ImPlotGetter getter,
    void* data,
    int count,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_API void PlotImage(
    const char* label_id,
    ImTextureID tex_ref,
    const ImPlotPoint& bounds_min,
    const ImPlotPoint& bounds_max,
    const ImVec2& uv0 = ImVec2(0, 0),
    const ImVec2& uv1 = ImVec2(1, 1),
    const ImVec4& tint_col = ImVec4(1, 1, 1, 1),
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_API void PlotText(
    const char* text,
    double x,
    double y,
    const ImVec2& pix_offset = ImVec2(0, 0),
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_API void PlotDummy(
    const char* label_id,
    const ImPlotSpec& spec = ImPlotSpec()
    );

IMPLOT_API ImVec4 GetLastItemColor();
IMPLOT_API void BustColorCache(const char* plot_title_id = nullptr);
IMPLOT_API void ShowDemoWindow(bool* p_open = nullptr);

template <typename T>
T RandomRange(
    T min,
    T max
    );

ImVec4 RandomColor();
double RandomGauss();
void Demo_Help();

void ButtonSelector(
    const char* label,
    ImGuiMouseButton* b
    );

void ModSelector(
    const char* label,
    int* k
    );

void InputMapping(
    const char* label,
    ImGuiMouseButton* b,
    int* k
    );

void ShowInputMapping();
void Demo_Config();
void Demo_LinePlots();
void Demo_FilledLinePlots();
void Demo_ShadedPlots();
void Demo_ScatterPlots();
void Demo_BubblePlots();
void Demo_PolygonPlots();
void Demo_StairstepPlots();
void Demo_BarPlots();
void Demo_BarGroups();
void Demo_BarStacks();
void Demo_ErrorBars();
void Demo_StemPlots();
void Demo_InfiniteLines();
void Demo_PieCharts();
void Demo_Heatmaps();
void Demo_Histogram();
void Demo_Histogram2D();
void Demo_DigitalPlots();
void Demo_Images();
void Demo_RealtimePlots();
void Demo_MarkersAndText();
void Demo_NaNValues();
void Demo_PerIndexColors();
void Demo_LogScale();
void Demo_SymmetricLogScale();
void Demo_TimeScale();

static double TransformForward_Sqrt(
    double v,
    void*
    );

static double TransformInverse_Sqrt(
    double v,
    void*
    );

void Demo_CustomScale();
void Demo_MultipleAxes();
void Demo_LinkedAxes();
void Demo_AxisConstraints();
void Demo_EqualAxes();
void Demo_AutoFittingData();

ImPlotPoint SinewaveGetter(
    int i,
    void* data
    );

void Demo_SubplotsSizing();
void Demo_SubplotItemSharing();
void Demo_SubplotAxisLinking();
void Demo_LegendOptions();
void Demo_DragPoints();
void Demo_DragLines();
void Demo_DragRects();

ImPlotPoint FindCentroid(
    const ImVector<ImPlotPoint>& data,
    const ImPlotRect& bounds,
    int& cnt
    );

void Demo_Querying();
void Demo_Annotations();
void Demo_Tags();
void Demo_DragAndDrop();
void Demo_Tables();
void Demo_ItemStylingAndSpec();
void Demo_OffsetAndStride();
void Demo_CustomDataAndGetters();

int MetricFormatter(
    double value,
    char* buff,
    int size,
    void* data
    );

void Demo_TickLabels();
void Demo_CustomStyles();
void Demo_CustomRendering();
void Demo_LegendPopups();
void Demo_ColormapWidgets();
void Demo_CustomPlottersAndTooltips();

void DemoHeader(
    const char* label,
    void(*)() demo
    );

static void SetupLock();

IMPLOT_API bool BeginItem(
    const char* label_id,
    const ImPlotSpec& spec = ImPlotSpec(),
    const ImVec4& item_col = IMPLOT_AUTO_COL,
    ImPlotMarker item_mkr = ImPlotMarker_Invalid
    );

template <typename _Fitter>
bool BeginItemEx(
    const char* label_id,
    const _Fitter& fitter,
    const ImPlotSpec& spec,
    const ImVec4& item_col = IMPLOT_AUTO_COL,
    ImPlotMarker item_mkr = ImPlotMarker_Invalid
    );

IMPLOT_API void EndItem();

IMPLOT_API ImPlotItem* RegisterOrGetItem(
    const char* label_id,
    ImPlotItemFlags flags,
    bool* just_created = nullptr
    );

IMPLOT_API ImPlotItem* GetItem(const char* label_id);
IMPLOT_API ImPlotItem* GetCurrentItem();
IMPLOT_API void BustItemCache();

static bool AnyAxesInputLocked(
    ImPlotAxis* axes,
    int count
    );

static bool AllAxesInputLocked(
    ImPlotAxis* axes,
    int count
    );

static bool AnyAxesHeld(
    ImPlotAxis* axes,
    int count
    );

static bool AnyAxesHovered(
    ImPlotAxis* axes,
    int count
    );

static bool FitThisFrame();
static void FitPointX(double x);
static void FitPointY(double y);
static void FitPoint(const ImPlotPoint& p);

static bool RangesOverlap(
    const ImPlotRange& r1,
    const ImPlotRange& r2
    );

static const ImPlotNextItemData& GetItemData();
static bool IsColorAuto(const ImVec4& col);
static bool IsColorAuto(ImPlotCol idx);
static ImVec4 GetStyleColorVec4(ImPlotCol idx);
static ImU32 GetStyleColorU32(ImPlotCol idx);
static ImVec2 CalcTextSizeVertical(const char* text);
static ImU32 CalcTextColor(const ImVec4& bg);
static ImU32 CalcTextColor(ImU32 bg);
static ImU32 CalcHoverColor(ImU32 col);

static ImVec2 ClampLabelPos(
    ImVec2 pos,
    const ImVec2& size,
    const ImVec2& Min,
    const ImVec2& Max
    );

static int OrderOfMagnitude(double val);
static int OrderToPrecision(int order);
static int Precision(double val);

static double RoundTo(
    double val,
    int prec
    );

static ImVec2 Intersection(
    const ImVec2& a1,
    const ImVec2& a2,
    const ImVec2& b1,
    const ImVec2& b2
    );

template <typename T>
void FillRange(
    ImVector<T>& buffer,
    int n,
    T vmin,
    T vmax
    );

template <typename TContainer>
static void CalculateBins(
    const TContainer& values,
    int count,
    ImPlotBin meth,
    const ImPlotRange& range,
    int& bins_out,
    double& width_out
    );

static bool IsLeapYear(int year);

static int GetDaysInMonth(
    int year,
    int month
    );

static ImPlotTime MkTime(struct tm* ptm);

static tm* GetTime(
    const ImPlotTime& t,
    tm* ptm
    );

static ImPlotTime Now();
static ImPlotTime Today();

static double TransformForward_Log10(
    double v,
    void*
    );

static double TransformInverse_Log10(
    double v,
    void*
    );

static double TransformForward_SymLog(
    double v,
    void*
    );

static double TransformInverse_SymLog(
    double v,
    void*
    );

static double TransformForward_Logit(
    double v,
    void*
    );

static double TransformInverse_Logit(
    double v,
    void*
    );

static int Formatter_Default(
    double value,
    char* buff,
    int size,
    void* data
    );

static int Formatter_Logit(
    double value,
    char* buff,
    int size,
    void*
    );

static int Formatter_Time(
    double,
    char* buff,
    int size,
    void* data
    );

template <typename T>
int Stride(const ImPlotSpec& spec);

template <typename Indexer, typename T>
static void ImMinMaxIndexer(
    const Indexer& values,
    int count,
    T* min_out,
    T* max_out
    );

template <typename TContainer>
static double ImMean(
    const TContainer& values,
    int count
    );

template <typename TContainer>
static double ImStdDev(
    const TContainer& values,
    int count
    );

IMPLOT_INLINE void GetLineRenderProps(
    const ImDrawList& draw_list,
    float& half_weight,
    ImVec2& tex_uv0,
    ImVec2& tex_uv1
    );

IMPLOT_INLINE void PrimLine(
    ImDrawList& draw_list,
    const ImVec2& P1,
    const ImVec2& P2,
    float half_weight,
    ImU32 col,
    const ImVec2& tex_uv0,
    const ImVec2 tex_uv1
    );

IMPLOT_INLINE void PrimRectFill(
    ImDrawList& draw_list,
    const ImVec2& Pmin,
    const ImVec2& Pmax,
    ImU32 col,
    const ImVec2& uv
    );

IMPLOT_INLINE void PrimRectLine(
    ImDrawList& draw_list,
    const ImVec2& Pmin,
    const ImVec2& Pmax,
    float weight,
    ImU32 col,
    const ImVec2& uv
    );

bool IsItemHidden(const char* label_id);

template <typename T>
IMPLOT_INLINE T IndexData(
    const T* data,
    int idx,
    int count,
    int offset,
    int stride
    );

template <class _Renderer>
void RenderPrimitivesEx(
    const _Renderer& renderer,
    ImDrawList& draw_list,
    const ImRect& cull_rect
    );

template <template<class> class _Renderer, class _Getter, typename ... Args>
void RenderPrimitives1(
    const _Getter& getter,
    Args... args
    );

template <
    template<class, class> class _Renderer,
    class _Getter1,
    class _Getter2,
    typename ... Args
    >
void RenderPrimitives2(
    const _Getter1& getter1,
    const _Getter2& getter2,
    Args... args
    );

template <
    template<class, class, class> class _Renderer,
    class _Getter1,
    class _Getter2,
    class _Getter3,
    typename ... Args
    >
void RenderPrimitives3(
    const _Getter1& getter1,
    const _Getter2& getter2,
    const _Getter3& getter3,
    Args... args
    );

template <
    typename _Getter,
    typename _GetterFillColor,
    typename _GetterLineColor,
    typename _GetterSize
    >
void RenderMarkers(
    const _Getter& getter,
    ImPlotMarker marker,
    bool rend_fill,
    const _GetterFillColor& col_fill_getter,
    bool rend_line,
    const _GetterLineColor& col_line_getter,
    const _GetterSize& size_getter,
    float weight
    );

template <typename _Getter>
void RenderColoredMarkers(
    const _Getter& getter,
    const ImPlotNextItemData& s
    );

template <typename _Getter>
void PlotLineEx(
    const char* label_id,
    const _Getter& getter,
    const ImPlotSpec& spec
    );

template <typename Getter>
void PlotScatterEx(
    const char* label_id,
    const Getter& getter,
    const ImPlotSpec& spec
    );

template <typename Getter>
void PlotBubblesEx(
    const char* label_id,
    const Getter& getter,
    const ImPlotSpec& spec
    );

template <typename Getter>
void PlotPolygonEx(
    const char* label_id,
    const Getter& getter,
    const ImPlotSpec& spec
    );

template <typename Getter>
void PlotStairsEx(
    const char* label_id,
    const Getter& getter,
    const ImPlotSpec& spec
    );

template <typename Getter1, typename Getter2>
void PlotShadedEx(
    const char* label_id,
    const Getter1& getter1,
    const Getter2& getter2,
    const ImPlotSpec& spec
    );

template <typename Getter1, typename Getter2>
void PlotBarsVEx(
    const char* label_id,
    const Getter1& getter1,
    const Getter2 getter2,
    double width,
    const ImPlotSpec& spec
    );

template <typename Getter1, typename Getter2>
void PlotBarsHEx(
    const char* label_id,
    const Getter1& getter1,
    const Getter2& getter2,
    double height,
    const ImPlotSpec& spec
    );

template <typename _GetterPos, typename _GetterNeg>
void PlotErrorBarsVEx(
    const char* label_id,
    const _GetterPos& getter_pos,
    const _GetterNeg& getter_neg,
    const ImPlotSpec& spec
    );

template <typename _GetterPos, typename _GetterNeg>
void PlotErrorBarsHEx(
    const char* label_id,
    const _GetterPos& getter_pos,
    const _GetterNeg& getter_neg,
    const ImPlotSpec& spec
    );

template <typename _GetterM, typename _GetterB>
void PlotStemsEx(
    const char* label_id,
    const _GetterM& getter_mark,
    const _GetterB& getter_base,
    const ImPlotSpec& spec
    );

IMPLOT_INLINE void PrimPieSliceFill(
    ImDrawList& draw_list,
    const ImVec2* points,
    int count,
    ImU32 col,
    const ImVec2& uv
    );

IMPLOT_INLINE void PrimPieSliceLine(
    ImDrawList& draw_list,
    const ImVec2* points,
    int count,
    ImU32 col,
    float half_weight,
    const ImVec2& tex_uv0,
    const ImVec2& tex_uv1
    );

IMPLOT_INLINE void RenderPieSliceFill(
    ImDrawList& draw_list,
    ImVec2* buffer,
    int count,
    ImU32 col
    );

IMPLOT_INLINE void RenderPieSliceLine(
    ImDrawList& draw_list,
    ImVec2* buffer,
    int count,
    ImU32 col
    );

IMPLOT_INLINE void RenderPieSlice(
    ImDrawList& draw_list,
    const ImPlotPoint& center,
    double radius,
    double a0,
    double a1,
    ImU32 col,
    ImPlotPieChartFlags flags,
    bool detached = false
    );

template <typename T>
double PieChartSum(
    IndexerIdx<T> indexer,
    bool ignore_hidden
    );

template <typename T>
void PlotPieChartEx(
    const char*const label_ids [],
    IndexerIdx<T> indexer,
    ImPlotPoint center,
    double radius,
    double angle0,
    const ImPlotSpec& spec
    );

int PieChartFormatter(
    double value,
    char* buff,
    int size,
    void* data
    );

template <typename T>
void RenderHeatmap(
    ImDrawList& draw_list,
    IndexerIdx<T> indexer,
    int rows,
    int cols,
    double scale_min,
    double scale_max,
    const char* fmt,
    const ImPlotPoint& bounds_min,
    const ImPlotPoint& bounds_max,
    bool reverse_y,
    bool col_maj
    );

template <typename Getter>
void PlotDigitalEx(
    const char* label_id,
    Getter getter,
    const ImPlotSpec& spec
    );

} // namespace ImPlot

Global Functions

template <class _Renderer>
void RenderPrimitivesEx(
    const _Renderer& renderer,
    ImDrawList& draw_list,
    const ImRect& cull_rect
    )

Renders primitive shapes in bulk as efficiently as possible.