imgui_plot.h

Go to the documentation of this file.

#pragma once
//#include <cstdint> //once we move up to c++11 we can use this header.
#include <stdint.h>
#include <imgui.h>

namespace ImGui {
// Use this structure to pass the plot data and settings into the Plot function
struct PlotConfig {

   PlotConfig()
      : values()
      , scale()
      , tooltip()
      , grid_x()
      , grid_y()
      , selection()
      , v_lines()
      , frame_size(0.f, 0.f)
      , line_thickness(1.f)
      , skip_small_lines(true)
      , overlay_text(NULL)
   {

   }

    struct Values {
       Values()
          : xs(NULL)
          , ys(NULL)
          , count(0)
          , offset(0)
          , color(0)
          , ys_list(NULL)
          , ys_count(NULL)
          , colors(NULL)
       {

       }
        // if necessary, you can provide x-axis values
        const float *xs /*= NULL*/;
        // array of y values. If null, use ys_list (below)
        const float *ys /*= NULL*/;
        // the number of values in each array
        int count;
        // at which offset to start plotting.
        // Warning: count+offset must be <= length of array!
        int offset /*= 0*/;
        // Plot color. If 0, use ImGuiCol_PlotLines.
        ImU32 color /*= 0*/;

        // in case you need to draw multiple plots at once, use this instead of ys
        const float **ys_list /*= NULL*/;
        // the number of plots to draw
        int ys_count /*= 0*/;
        // colors for each plot
        const ImU32* colors /*= NULL*/;
    } values;
    struct Scale {
       Scale()
          : min(0)
          , max(0)
          , type(Linear)
       {

       }
        // Minimum plot value
        float min;
        // Maximum plot value
        float max;
        enum Type {
            Linear,
            Log10,
        };
        // How to scale the x-axis
        Type type /*= Linear*/;
    } scale;
    struct Tooltip {
       Tooltip()
          : show(false)
          , format("%g: %8.4g")
       {

       }
        bool show /*= false*/;
        const char* format /*= "%g: %8.4g"*/;
    } tooltip;
    struct Grid {
       Grid()
          : show(false)
          , size(100)
          , subticks(10)
       {

       }
        bool show /*= false*/;
        float size /*= 100*/; // at which intervals to draw the grid
        int subticks /*= 10*/; // how many subticks in each tick
    } grid_x, grid_y;
    struct Selection {
       Selection()
          : show(false)
          , start(NULL)
          , length(NULL)
          , sanitize_fn(NULL)
       {

       }
        bool show /*= false*/;
        uint32_t* start /*= NULL*/;
        uint32_t* length /*= NULL*/;
        // "Sanitize" function. Give it selection length, and it will return
        // the "allowed" length. Useful for FFT, where selection must be
        // of power of two
        uint32_t(*sanitize_fn)(uint32_t) /*= NULL*/;
    } selection;
    struct VerticalLines {
       VerticalLines()
          : show(false)
          , indices(NULL)
          , count(0)
       {

       }
        bool show /*= false*/;
        const size_t* indices /*= NULL*/; // at which indices to draw the lines
        size_t count /*= 0*/;
    } v_lines;
    ImVec2 frame_size /*= ImVec2(0.f, 0.f)*/;
    float line_thickness /*= 1.f*/;
    bool skip_small_lines /*= true*/;
    const char* overlay_text /*= NULL*/;


};
// C++11
//enum class PlotStatus {
enum PlotStatus {
   nothing,
    selection_updated,
};

IMGUI_API PlotStatus Plot(const char* label, const PlotConfig& conf);
}