Add dynamic tension colour mapping to mooring line visualization

Mooring lines now colour each tube segment by MoorDyn tension magnitude using a Turbo colormap, with an ImGui colour bar and real-time controls.

Author: dav-og

include/hydroc/gui/mooring_viz_data.h

@@ -28,12 +28,15 @@ inline constexpr int kIntermediateNode = -99;
 /// plus the MoorDyn point type at each endpoint.
 struct MooringLineVizData {
     std::vector<std::array<double, 3>> node_positions;
+    std::vector<double> node_tensions;      ///< Per-node tension magnitude [N].
+    double line_max_tension = 0.0;          ///< Max tension magnitude along line [N].
     MooringPointType start_point_type = MooringPointType::kFree;
     MooringPointType end_point_type   = MooringPointType::kFree;
 };
 
 /// Callback the GUI invokes each frame to fetch current line geometry.
-using MooringVizProvider = std::function<std::vector<MooringLineVizData>()>;
+using MooringVizProvider =
+    std::function<std::vector<MooringLineVizData>()>;
 
 }  // namespace gui
 }  // namespace hydroc

include/hydroc/hydro_system.h

@@ -457,11 +457,11 @@ class HydroSystem {
     }
 
     /**
-     * @brief Get current mooring line node positions for visualization.
+     * @brief Get current mooring line node positions and tension for visualization.
      *
      * Returns one entry per MoorDyn line, each containing the ordered node
-     * positions along the line.  Returns an empty vector when MoorDyn is
-     * not active or no lines exist.
+     * positions along the line plus per-node tension magnitudes.  Returns an
+     * empty vector when MoorDyn is not active or no lines exist.
      */
     std::vector<hydroc::gui::MooringLineVizData> GetMooringLineStates() const;
 #endif

src/gui/guihelperVSG.cpp

@@ -95,8 +95,13 @@ void GUIImplVSG::Init(UI& ui, chrono::ChSystem* system, const char* title) {
         }
     }
 
-    pVis->AddGuiComponent(std::make_shared<HydroChronoGuiComponent>(pVis.get(), ui.simulationStarted,
-                                                                    viewer_settings_.get()));
+    // Create mooring viz early so the GUI component can read its adaptive range.
+    if (!mooring_viz_)
+        mooring_viz_ = std::make_unique<MooringLinesViz>();
+
+    pVis->AddGuiComponent(std::make_shared<HydroChronoGuiComponent>(
+        pVis.get(), ui.simulationStarted, viewer_settings_.get(),
+        mooring_viz_.get()));
 
     pVis->Initialize();
 
@@ -204,7 +209,10 @@ bool GUIImplVSG::IsRunning(double timestep) {
                 mooring_viz_ = std::make_unique<MooringLinesViz>();
             if (!mooring_viz_->IsInitializedFor(pVis.get()))
                 mooring_viz_->Initialize(pVis.get(), line_data, mooring_scene_group_);
-            mooring_viz_->Update(line_data);
+
+            const bool color_on  = viewer_settings_ && viewer_settings_->show_mooring_colors;
+            const bool range_lock = viewer_settings_ && viewer_settings_->mooring_range_locked;
+            mooring_viz_->Update(line_data, color_on, range_lock);
         }
     }
 

src/gui/vsg_gui_component.cpp

@@ -10,19 +10,25 @@
 #endif
 
 #include "vsg_gui_component.h"
+#include "vsg_mooring_lines.h"
 
 #include <vsgImGui/imgui.h>
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
+#include <algorithm>
+#include <cstdio>
+
 namespace hydroc {
 namespace gui {
 
 HydroChronoGuiComponent::HydroChronoGuiComponent(chrono::vsg3d::ChVisualSystemVSG* vsys, bool& button_pressed,
-                                                 ViewerSettings* settings)
-    : vsys_(vsys), pressed_(button_pressed), settings_(settings) {}
+                                                 ViewerSettings* settings,
+                                                 MooringLinesViz* mooring_viz)
+    : vsys_(vsys), pressed_(button_pressed), settings_(settings),
+      mooring_viz_(mooring_viz) {}
 
 void HydroChronoGuiComponent::render(vsg::CommandBuffer& /*cb*/) {
     // Play/Pause button (top center, no background).
@@ -60,83 +66,177 @@ void HydroChronoGuiComponent::render(vsg::CommandBuffer& /*cb*/) {
 
         ImGui::Begin("Viewer Settings", nullptr, settings_flags);
 
-        // Water visibility toggle.
-        ImGui::Checkbox("Show Water", &settings_->show_water);
+        // ---- Waves ----
+        if (ImGui::CollapsingHeader("Waves", ImGuiTreeNodeFlags_DefaultOpen)) {
+            ImGui::Checkbox("Show Water", &settings_->show_water);
 
-        // Wireframe overlay for better surface visibility.
-        ImGui::Checkbox("Show Wireframe", &settings_->show_water_grid);
-        if (ImGui::IsItemHovered()) {
-            ImGui::SetTooltip("Show mesh edges on water surface.\n"
-                              "Helps visualize wave motion and ripples.");
-        }
+            ImGui::Checkbox("Show Wireframe", &settings_->show_water_grid);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Show mesh edges on water surface.\n"
+                                  "Helps visualize wave motion and ripples.");
+            }
 
-        // Grid resolution combo box.
-        {
-            const char* resolution_labels[] = {"32x32", "64x64", "96x96", "128x128"};
-            int current_idx = 0;
-            for (int i = 0; i < ViewerSettings::kResolutionCount; ++i) {
-                if (ViewerSettings::kResolutionOptions[i] == settings_->grid_resolution) {
-                    current_idx = i;
-                    break;
+            {
+                const char* resolution_labels[] = {"32x32", "64x64", "96x96", "128x128"};
+                int current_idx = 0;
+                for (int i = 0; i < ViewerSettings::kResolutionCount; ++i) {
+                    if (ViewerSettings::kResolutionOptions[i] == settings_->grid_resolution) {
+                        current_idx = i;
+                        break;
+                    }
+                }
+                int prev_idx = current_idx;
+                if (ImGui::Combo("Grid Resolution", &current_idx, resolution_labels, ViewerSettings::kResolutionCount)) {
+                    if (current_idx != prev_idx) {
+                        settings_->grid_resolution = ViewerSettings::kResolutionOptions[current_idx];
+                        settings_->resolution_changed = true;
+                    }
                 }
             }
-            int prev_idx = current_idx;
-            if (ImGui::Combo("Grid Resolution", &current_idx, resolution_labels, ViewerSettings::kResolutionCount)) {
-                if (current_idx != prev_idx) {
-                    settings_->grid_resolution = ViewerSettings::kResolutionOptions[current_idx];
-                    settings_->resolution_changed = true;
+
+            ImGui::Checkbox("Radiation (approx.)", &settings_->show_radiation_viz);
+            if (ImGui::IsItemHovered()) {
+                ImGui::SetTooltip("Visual approximation of radiated waves.\n"
+                                  "Does NOT affect physics - for feedback only.");
+            }
+
+            if (settings_->show_radiation_viz) {
+                ImGui::Indent();
+                ImGui::SliderFloat("Visual Scale##rad", &settings_->radiation_visual_scale, 0.1f, 5.0f, "%.1fx");
+                if (ImGui::IsItemHovered()) {
+                    ImGui::SetTooltip("Visual amplification for inspection.\n"
+                                      "1.0x = baseline, increase to see small ripples.\n"
+                                      "Does NOT affect physics.");
                 }
+                ImGui::TextDisabled("Wavelength/speed derived from wave period");
+                ImGui::Unindent();
             }
         }
 
-        // Update rate slider.
-        ImGui::SliderInt("Update Hz", &settings_->update_hz, 10, 60, "%d Hz");
+        // ---- Mooring ----
+        RenderMooringPanel();
 
-        // Status line toggle.
-        ImGui::Checkbox("Show Status", &settings_->show_water_status);
+        // ---- Display ----
+        if (ImGui::CollapsingHeader("Display")) {
+            ImGui::SliderInt("Update Hz", &settings_->update_hz, 10, 60, "%d Hz");
 
-        // Optional status display.
-        if (settings_->show_water_status) {
-            ImGui::Separator();
-            ImGui::TextDisabled("Water: %s | Grid: %d | Hz: %d",
-                                settings_->show_water ? "ON" : "OFF",
-                                settings_->grid_resolution,
-                                settings_->update_hz);
+            ImGui::Checkbox("Show Status", &settings_->show_water_status);
+            if (settings_->show_water_status) {
+                ImGui::TextDisabled("Water: %s | Grid: %d | Hz: %d",
+                                    settings_->show_water ? "ON" : "OFF",
+                                    settings_->grid_resolution,
+                                    settings_->update_hz);
+            }
         }
 
-        ImGui::Separator();
+        ImGui::End();
+    }
 
-        // Radiation visualization controls (Tier 0 - approximate).
-        // Clear labeling that this is a visual approximation, not physics.
-        ImGui::Checkbox("Radiation (viz, approximate)", &settings_->show_radiation_viz);
-        if (ImGui::IsItemHovered()) {
-            ImGui::SetTooltip("Visual approximation of radiated waves.\n"
-                              "Does NOT affect physics - for feedback only.");
-        }
+    RenderColorBar();
+}
 
-        // Show Visual Scale slider when radiation is enabled.
-        // All other parameters are auto-derived from physics.
-        if (settings_->show_radiation_viz) {
-            ImGui::Indent();
+// ---------------------------------------------------------------------------
 
-            // Visual scale slider - clearly labeled as visualization-only.
-            ImGui::SliderFloat("Visual Scale##rad", &settings_->radiation_visual_scale, 0.1f, 5.0f, "%.1fx");
-            if (ImGui::IsItemHovered()) {
-                ImGui::SetTooltip("Visual amplification for inspection.\n"
-                                  "1.0x = baseline, increase to see small ripples.\n"
-                                  "Does NOT affect physics.");
-            }
+void HydroChronoGuiComponent::RenderMooringPanel() {
+    if (!settings_ || !mooring_viz_ || !mooring_viz_->IsInitialized()) return;
+
+    if (!ImGui::CollapsingHeader("Mooring", ImGuiTreeNodeFlags_DefaultOpen)) return;
+
+    ImGui::Checkbox("Colour by Tension", &settings_->show_mooring_colors);
+    if (ImGui::IsItemHovered()) {
+        ImGui::SetTooltip("Map tension magnitude to colour\n"
+                          "along each mooring line.");
+    }
 
-            // Info text about auto-derived parameters.
-            ImGui::TextDisabled("Wavelength/speed derived from wave period");
+    if (settings_->show_mooring_colors) {
+        ImGui::Indent();
 
-            ImGui::Unindent();
+        ImGui::Checkbox("Lock Range", &settings_->mooring_range_locked);
+        if (ImGui::IsItemHovered()) {
+            ImGui::SetTooltip("Freeze the colour range for stable comparison.\n"
+                              "Uncheck to auto-track.");
         }
 
-        ImGui::End();
+        ImGui::TextDisabled("Range: %.3g .. %.3g N",
+                            mooring_viz_->ScalarMin(),
+                            mooring_viz_->ScalarMax());
+
+        ImGui::Unindent();
     }
 }
 
+// ---------------------------------------------------------------------------
+
+void HydroChronoGuiComponent::RenderColorBar() {
+    if (!settings_ || !settings_->show_mooring_colors) return;
+    if (!mooring_viz_ || !mooring_viz_->IsInitialized()) return;
+
+    const ImGuiViewport* vp = ImGui::GetMainViewport();
+    const float bar_w = 20.0f;
+    const float bar_h = 200.0f;
+    const float margin = 30.0f;
+    const float label_gap = 6.0f;
+
+    const float x0 = vp->WorkPos.x + vp->WorkSize.x - margin - bar_w;
+    const float y0 = vp->WorkPos.y + vp->WorkSize.y * 0.5f - bar_h * 0.5f;
+
+    ImDrawList* dl = ImGui::GetForegroundDrawList();
+
+    // Draw the gradient as a stack of thin horizontal strips.
+    constexpr int kStrips = 64;
+    const float strip_h = bar_h / kStrips;
+    for (int i = 0; i < kStrips; ++i) {
+        const float t_top = 1.0f - static_cast<float>(i) / kStrips;
+        const float t_bot = 1.0f - static_cast<float>(i + 1) / kStrips;
+
+        auto to_im = [](float t) -> ImU32 {
+            t = std::clamp(t, 0.0f, 1.0f);
+            const float r = std::clamp(
+                0.13572138f + t * (4.61539260f + t * (-42.66032258f +
+                t * (132.13108234f + t * (-152.54895899f + t * 59.28637943f)))),
+                0.0f, 1.0f);
+            const float g = std::clamp(
+                0.09140261f + t * (2.26418794f + t * (4.11868525f +
+                t * (-44.58319668f + t * (70.41698018f - t * 33.26974748f)))),
+                0.0f, 1.0f);
+            const float b = std::clamp(
+                0.10667330f + t * (12.75191895f + t * (-60.25290628f +
+                t * (109.04872043f + t * (-89.38040853f + t * 27.13073700f)))),
+                0.0f, 1.0f);
+            return IM_COL32(static_cast<int>(r * 255),
+                            static_cast<int>(g * 255),
+                            static_cast<int>(b * 255), 255);
+        };
+
+        ImU32 col_top = to_im(t_top);
+        ImU32 col_bot = to_im(t_bot);
+        dl->AddRectFilledMultiColor(
+            ImVec2(x0, y0 + i * strip_h),
+            ImVec2(x0 + bar_w, y0 + (i + 1) * strip_h),
+            col_top, col_top, col_bot, col_bot);
+    }
+
+    // Outline.
+    dl->AddRect(ImVec2(x0, y0), ImVec2(x0 + bar_w, y0 + bar_h),
+                IM_COL32(200, 200, 200, 180));
+
+    // Labels.
+    char buf[64];
+    std::snprintf(buf, sizeof(buf), "%.3g N", mooring_viz_->ScalarMax());
+    dl->AddText(ImVec2(x0 - label_gap - ImGui::CalcTextSize(buf).x, y0 - 2.0f),
+                IM_COL32(220, 220, 220, 255), buf);
+
+    std::snprintf(buf, sizeof(buf), "%.3g N", mooring_viz_->ScalarMin());
+    dl->AddText(ImVec2(x0 - label_gap - ImGui::CalcTextSize(buf).x,
+                        y0 + bar_h - ImGui::GetTextLineHeight() + 2.0f),
+                IM_COL32(220, 220, 220, 255), buf);
+
+    const char* title = "Tension";
+    dl->AddText(ImVec2(x0 + bar_w * 0.5f - ImGui::CalcTextSize(title).x * 0.5f,
+                        y0 - ImGui::GetTextLineHeight() - 4.0f),
+                IM_COL32(220, 220, 220, 255), title);
+}
+
 }  // namespace gui
 }  // namespace hydroc
 

src/gui/vsg_gui_component.h

@@ -12,6 +12,8 @@
 namespace hydroc {
 namespace gui {
 
+class MooringLinesViz;  // forward declaration
+
 /// Runtime-adjustable water visualization settings.
 ///
 /// Allows tuning water appearance without recompiling. Owned by GUIImplVSG
@@ -47,6 +49,10 @@ struct ViewerSettings {
     // amplitude scales with body velocity and size.
     bool show_radiation_viz = false;       ///< Enable radiated wave visualization
     float radiation_visual_scale = 1.0f;   ///< Visual amplification [0.1x - 5x]
+
+    // --- Mooring Colour Mapping ---
+    bool show_mooring_colors = true;       ///< Colour lines by tension magnitude
+    bool mooring_range_locked = false;     ///< Freeze the adaptive min/max range
 };
 
 /// ImGui component for HydroChrono visualization overlay.
@@ -57,17 +63,24 @@ class HydroChronoGuiComponent : public chrono::vsg3d::ChGuiComponentVSG {
     /// @param vsys Pointer to the VSG visual system (for potential future use).
     /// @param button_pressed Reference to the simulation running state (toggled by button).
     /// @param settings Pointer to viewer settings (owned by GUIImplVSG).
+    /// @param mooring_viz Pointer to the mooring renderer (for reading the
+    ///                    adaptive scalar range for the colour bar).
     HydroChronoGuiComponent(chrono::vsg3d::ChVisualSystemVSG* vsys, bool& button_pressed,
-                            ViewerSettings* settings = nullptr);
+                            ViewerSettings* settings = nullptr,
+                            MooringLinesViz* mooring_viz = nullptr);
 
     /// Render the ImGui overlay.
     /// Called each frame by the VSG rendering loop.
     void render(vsg::CommandBuffer& cb) override;
 
   private:
+    void RenderMooringPanel();
+    void RenderColorBar();
+
     chrono::vsg3d::ChVisualSystemVSG* vsys_;
     bool& pressed_;
-    ViewerSettings* settings_;  ///< Viewer settings (may be null)
+    ViewerSettings* settings_;
+    MooringLinesViz* mooring_viz_;
 };
 
 }  // namespace gui