Quiver Plot (Vector Field) Functionality.

implot.h

@@ -92,6 +92,7 @@ typedef int ImPlotColormapScaleFlags; // -> ImPlotColormapScaleFlags_
 typedef int ImPlotItemFlags;          // -> ImPlotItemFlags_
 typedef int ImPlotLineFlags;          // -> ImPlotLineFlags_
 typedef int ImPlotScatterFlags;       // -> ImPlotScatterFlags
+typedef int ImPlotQuiverFlags;        // -> ImPlotQuiverFlags_
 typedef int ImPlotStairsFlags;        // -> ImPlotStairsFlags_
 typedef int ImPlotShadedFlags;        // -> ImPlotShadedFlags_
 typedef int ImPlotBarsFlags;          // -> ImPlotBarsFlags_
@@ -246,6 +247,14 @@ enum ImPlotScatterFlags_ {
     ImPlotScatterFlags_NoClip = 1 << 10, // markers on the edge of a plot will not be clipped
 };
 
+// Flgs for PlotQuiver
+enum ImPlotQuiverFlags_ {
+    ImPlotQuiverFlags_None       = 0,         // default
+    ImPlotQuiverFlags_NoClip     = 1 << 10,   // arrows on the edge of a plot will not be clipped
+    ImPlotQuiverFlags_Normalize  = 1 << 11,   // all arrows will be normalized to the same length
+    ImPlotQuiverFlags_Colored    = 1 << 12    // arrow colors will be mapped to their magnitudes
+};
+
 // Flags for PlotStairs
 enum ImPlotStairsFlags_ {
     ImPlotStairsFlags_None     = 0,       // default
@@ -350,6 +359,7 @@ enum ImPlotCol_ {
     ImPlotCol_MarkerOutline, // marker outline color (defaults to the current line color)
     ImPlotCol_MarkerFill,    // marker fill color (defaults to the current line color)
     ImPlotCol_ErrorBar,      // error bar color (defaults to ImGuiCol_Text)
+    ImPlotCol_QuiverFill,
     // plot styling colors
     ImPlotCol_FrameBg,       // plot frame background color (defaults to ImGuiCol_FrameBg)
     ImPlotCol_PlotBg,        // plot area background color (defaults to ImGuiCol_WindowBg)
@@ -485,6 +495,26 @@ struct ImPlotPoint {
 };
 IM_MSVC_RUNTIME_CHECKS_RESTORE
 
+IM_MSVC_RUNTIME_CHECKS_OFF
+// Implementation of a 2D plot vector with double precision.
+struct ImPlotQuiver {
+    double x, y;
+    double u, v;
+    double mag2;
+    IMPLOT_API constexpr ImPlotQuiver()                     : x(0.0), y(0.0), u(0.0), v(0.0), mag2(0.0) { }
+    IMPLOT_API constexpr ImPlotQuiver(double _x, double _y, double _u, double _v) : x(_x), y(_y), u(_u), v(_v), mag2((_u*_u + _v*_v)) { }
+    IMPLOT_API constexpr ImPlotQuiver(double _x, double _y, double _u, double _v, double _mag2) : x(_x), y(_y), u(_u), v(_v), mag2(_mag2) { }  // ADD THIS
+    IMPLOT_API constexpr ImPlotQuiver(const ImVec2& p, const ImVec2& q)      : x((double)p.x), y((double)p.y), u((double)q.x), v((double)q.y), mag2((q.x*q.x + q.y*q.y)) { }
+    IMPLOT_API constexpr ImPlotQuiver(const ImVec4& r)      : x((double)r.x), y((double)r.y), u((double)r.z), v((double)r.w), mag2((r.z*r.z + r.w*r.w)) { }
+    IMPLOT_API double& operator[] (size_t idx)             { IM_ASSERT(idx == 0 || idx == 1 || idx == 2 || idx == 3 || idx == 4); return ((double*)(void*)(char*)this)[idx]; }
+    IMPLOT_API double  operator[] (size_t idx) const       { IM_ASSERT(idx == 0 || idx == 1 || idx == 2 || idx == 3 || idx == 4); return ((const double*)(const void*)(const char*)this)[idx]; }
+#ifdef IMPLOT_POINT_CLASS_EXTRA
+    IMPLOT_POINT_CLASS_EXTRA     
+
+#endif
+};
+IM_MSVC_RUNTIME_CHECKS_RESTORE
+
 // Range defined by a min/max value.
 struct ImPlotRange {
     double Min, Max;
@@ -868,6 +898,9 @@ IMPLOT_TMP void PlotScatter(const char* label_id, const T* values, int count, do
 IMPLOT_TMP void PlotScatter(const char* label_id, const T* xs, const T* ys, int count, ImPlotScatterFlags flags=0, int offset=0, int stride=sizeof(T));
 IMPLOT_API void PlotScatterG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotScatterFlags flags=0);
 
+// Plots a standard 2D Vector Field arrow plot. It has a direction and magnitude.
+IMPLOT_TMP void PlotQuiver(const char* label_id, const T* xs, const T* ys,const T* us, const T* vs, int count,const T scaleMin, const T scaleMax, ImPlotQuiverFlags flags = 0, int offset= 0, int stride=sizeof(T));
+
 // Plots a a stairstep graph. The y value is continued constantly to the right from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i]
 IMPLOT_TMP void PlotStairs(const char* label_id, const T* values, int count, double xscale=1, double xstart=0, ImPlotStairsFlags flags=0, int offset=0, int stride=sizeof(T));
 IMPLOT_TMP void PlotStairs(const char* label_id, const T* xs, const T* ys, int count, ImPlotStairsFlags flags=0, int offset=0, int stride=sizeof(T));
@@ -1130,6 +1163,8 @@ IMPLOT_API void SetNextLineStyle(const ImVec4& col = IMPLOT_AUTO_COL, float weig
 IMPLOT_API void SetNextFillStyle(const ImVec4& col = IMPLOT_AUTO_COL, float alpha_mod = IMPLOT_AUTO);
 // Set the marker style for the next item only.
 IMPLOT_API void SetNextMarkerStyle(ImPlotMarker marker = IMPLOT_AUTO, float size = IMPLOT_AUTO, const ImVec4& fill = IMPLOT_AUTO_COL, float weight = IMPLOT_AUTO, const ImVec4& outline = IMPLOT_AUTO_COL);
+// Set the quiver style for the next item only.
+IMPLOT_API void SetNextQuiverStyle(float size, const ImVec4& col = IMPLOT_AUTO_COL);
 // Set the error bar style for the next item only.
 IMPLOT_API void SetNextErrorBarStyle(const ImVec4& col = IMPLOT_AUTO_COL, float size = IMPLOT_AUTO, float weight = IMPLOT_AUTO);
 

implot_demo.cpp

@@ -415,6 +415,84 @@ void Demo_ScatterPlots() {
         ImPlot::EndPlot();
     }
 }
+//-----------------------------------------------------------------------------
+
+void Demo_QuiverPlots(){
+    static float xs[100], ys[100], us[100], vs[100];
+    static bool animate = false;
+    static float animation_speed = 1.0f;
+
+    float time = animate ? ImGui::GetTime() * animation_speed : 0.0f;
+
+    for (int i = 0; i < 10; ++i) {
+        for(int j = 0; j < 10; ++j){
+            int idx = i*10 + j;
+            xs[idx] = ((float)j * 0.1f) - 0.5;
+            ys[idx] = ((float)i * 0.1f) - 0.5;
+
+            if (animate) {
+                float k = 2.0f * 3.14159f;  
+                float decay = expf(-0.1f * time);  
+                us[idx] = decay * (sinf(k * xs[idx]) * cosf(k * ys[idx]) * cosf(time) 
+                                 - cosf(k * xs[idx]) * sinf(k * ys[idx]) * sinf(time));
+                vs[idx] = decay * (-cosf(k * xs[idx]) * sinf(k * ys[idx]) * cosf(time) 
+                                  - sinf(k * xs[idx]) * cosf(k * ys[idx]) * sinf(time));
+            } else {
+                // Taylor-Green vortex
+                float k = 2.0f * 3.14159f;
+                us[idx] = sinf(k * xs[idx]) * cosf(k * ys[idx]);
+                vs[idx] = -cosf(k * xs[idx]) * sinf(k * ys[idx]);
+            }
+        }
+    }
+
+    static float scale_min = 0.00f;
+    static float scale_max = 1.0f;
+    static float baseSize = 12.0f;
+    static ImPlotColormap map = ImPlotColormap_Viridis;
+
+    if (ImPlot::ColormapButton(ImPlot::GetColormapName(map),ImVec2(225,0),map)) {
+        map = (map + 1) % ImPlot::GetColormapCount();
+        BustColorCache("##Heatmap1");
+        BustColorCache("##Heatmap2");
+    }
+    ImGui::SameLine();
+    ImGui::LabelText("##Colormap Index", "%s", "Change Colormap");
+
+    ImGui::SetNextItemWidth(225);
+    ImGui::DragFloatRange2("Min / Max",&scale_min, &scale_max, 0.01f, -20, 20,nullptr,nullptr,ImGuiSliderFlags_AlwaysClamp);
+    if (scale_max <= scale_min + 0.01f) {
+        scale_max = scale_min + 0.01f;
+    }
+
+    ImGui::SetNextItemWidth(225);
+    ImGui::DragFloat("Base Size",&baseSize,0.1f,0,100);
+
+    // Animation controls
+    ImGui::Checkbox("Time Dependant Function", &animate);
+    if (animate) {
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth(150);
+        ImGui::DragFloat("Speed", &animation_speed, 0.1f, 0.1f, 10.0f);
+    }
+
+    static ImPlotQuiverFlags qv_flags = ImPlotQuiverFlags_Colored;
+    ImGui::CheckboxFlags("Normalized", (unsigned int*)&qv_flags, ImPlotQuiverFlags_Normalize);
+    ImGui::CheckboxFlags("Color Coded", (unsigned int*)&qv_flags, ImPlotQuiverFlags_Colored);
+
+    ImPlot::PushColormap(map);
+    if (ImPlot::BeginPlot("Quiver Plot", ImVec2(ImGui::GetTextLineHeight()*28, ImGui::GetTextLineHeight()*28))) {
+        ImPlot::SetupAxisTicks(ImAxis_X1,-0.5, 0.5, 11);
+        ImPlot::SetupAxisTicks(ImAxis_Y1,-0.5, 0.5, 11);
+        ImPlot::SetNextQuiverStyle(baseSize,ImPlot::GetColormapColor(1)); 
+        ImPlot::SetupAxes("x","y");
+        ImPlot::PlotQuiver("Magnitude", xs, ys,us,vs,100,scale_min,scale_max, qv_flags);
+        ImPlot::EndPlot();
+    }
+    ImGui::SameLine();
+    ImPlot::ColormapScale("##Magnitude Scale", scale_min, scale_max);
+    ImPlot::PopColormap();
+}
 
 //-----------------------------------------------------------------------------
 
@@ -2248,6 +2326,7 @@ void ShowDemoWindow(bool* p_open) {
             DemoHeader("Filled Line Plots", Demo_FilledLinePlots);
             DemoHeader("Shaded Plots##", Demo_ShadedPlots);
             DemoHeader("Scatter Plots", Demo_ScatterPlots);
+            DemoHeader("Quiver Plots", Demo_QuiverPlots);
             DemoHeader("Realtime Plots", Demo_RealtimePlots);
             DemoHeader("Stairstep Plots", Demo_StairstepPlots);
             DemoHeader("Bar Plots", Demo_BarPlots);

implot_internal.h

@@ -1199,6 +1199,7 @@ struct ImPlotNextItemData {
     ImPlotMarker    Marker;
     float           MarkerSize;
     float           MarkerWeight;
+    float           QuiverSize;
     float           FillAlpha;
     float           ErrorBarSize;
     float           ErrorBarWeight;
@@ -1218,6 +1219,7 @@ struct ImPlotNextItemData {
         LineWeight    = MarkerSize = MarkerWeight = FillAlpha = ErrorBarSize = ErrorBarWeight = DigitalBitHeight = DigitalBitGap = IMPLOT_AUTO;
         Marker        = IMPLOT_AUTO;
         HasHidden     = Hidden = false;
+
     }
 };