Refactor mooring viz: eliminate duplicated colormap, fix stale naming

Author: dav-og

src/gui/vsg_gui_component.cpp

@@ -158,8 +158,8 @@ void HydroChronoGuiComponent::RenderMooringPanel() {
         }
 
         ImGui::TextDisabled("Range: %.3g .. %.3g N",
-                            mooring_viz_->ScalarMin(),
-                            mooring_viz_->ScalarMax());
+                            mooring_viz_->TensionMin(),
+                            mooring_viz_->TensionMax());
 
         ImGui::Unindent();
     }
@@ -185,31 +185,20 @@ void HydroChronoGuiComponent::RenderColorBar() {
     // Draw the gradient as a stack of thin horizontal strips.
     constexpr int kStrips = 64;
     const float strip_h = bar_h / kStrips;
+
+    auto turbo_to_im = [](float t) -> ImU32 {
+        const auto c = MooringLinesViz::TurboColormap(t);
+        return IM_COL32(static_cast<int>(c.r * 255),
+                        static_cast<int>(c.g * 255),
+                        static_cast<int>(c.b * 255), 255);
+    };
+
     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);
+        const ImU32 col_top = turbo_to_im(t_top);
+        const ImU32 col_bot = turbo_to_im(t_bot);
         dl->AddRectFilledMultiColor(
             ImVec2(x0, y0 + i * strip_h),
             ImVec2(x0 + bar_w, y0 + (i + 1) * strip_h),
@@ -222,11 +211,11 @@ void HydroChronoGuiComponent::RenderColorBar() {
 
     // Labels.
     char buf[64];
-    std::snprintf(buf, sizeof(buf), "%.3g N", mooring_viz_->ScalarMax());
+    std::snprintf(buf, sizeof(buf), "%.3g N", mooring_viz_->TensionMax());
     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());
+    std::snprintf(buf, sizeof(buf), "%.3g N", mooring_viz_->TensionMin());
     dl->AddText(ImVec2(x0 - label_gap - ImGui::CalcTextSize(buf).x,
                         y0 + bar_h - ImGui::GetTextLineHeight() + 2.0f),
                 IM_COL32(220, 220, 220, 255), buf);

src/gui/vsg_mooring_lines.cpp

@@ -10,6 +10,7 @@
 #include <chrono_vsg/utils/ChShapeBuilderVSG.h>
 
 #include <algorithm>
+#include <array>
 #include <cmath>
 #include <iostream>
 #include <limits>
@@ -116,9 +117,7 @@ static chrono::ChColor PointTypeColor(int point_type) {
     return {0.05f, 0.05f, 0.05f};  // intermediate node -- near black
 }
 
-/// Attempt to match the Google Turbo colour map (Mikhailov, 2019).
-/// Input @p t is clamped to [0, 1].  Returns an opaque RGBA colour.
-static vsg::vec4 TurboColormap(float t) {
+vsg::vec4 MooringLinesViz::TurboColormap(float t) {
     t = std::clamp(t, 0.0f, 1.0f);
 
     // Polynomial coefficients fitted to the 256-entry Turbo LUT.
@@ -174,44 +173,44 @@ void MooringLinesViz::Update(const std::vector<MooringLineVizData>& lines,
     if (!initialized_) return;
     const size_t count = std::min(lines.size(), line_meshes_.size());
 
-    // Adaptive range: min fixed at 0 (all fields are non-negative magnitudes),
+    // Adaptive range: min fixed at 0 (tension magnitude is non-negative),
     // max uses high-water-mark behaviour -- snaps to new peaks instantly but
     // decays very slowly so the colour scale stays stable.
     if (color_enabled && !range_locked) {
         float frame_max = 0.0f;
         for (size_t li = 0; li < count; ++li) {
-            for (double s : lines[li].node_tensions) {
-                frame_max = std::max(frame_max, static_cast<float>(s));
+            for (double t : lines[li].node_tensions) {
+                frame_max = std::max(frame_max, static_cast<float>(t));
             }
         }
 
         const float padded_max = frame_max * (1.0f + kRangePadding);
 
-        if (!adaptive_initialized_) {
-            adaptive_max_ = std::max(padded_max, 1.0f);
-            adaptive_initialized_ = true;
+        if (!range_initialized_) {
+            tension_max_ = std::max(padded_max, 1.0f);
+            range_initialized_ = true;
             hold_frames_remaining_ = kRangeHoldFrames;
-        } else if (padded_max > adaptive_max_) {
-            adaptive_max_ = padded_max;
+        } else if (padded_max > tension_max_) {
+            tension_max_ = padded_max;
             hold_frames_remaining_ = kRangeHoldFrames;
         } else if (hold_frames_remaining_ > 0) {
             --hold_frames_remaining_;
         } else {
-            adaptive_max_ += kRangeDecayAlpha * (padded_max - adaptive_max_);
+            tension_max_ += kRangeDecayAlpha * (padded_max - tension_max_);
         }
 
-        adaptive_min_ = 0.0f;
+        tension_min_ = 0.0f;
 
-        if (adaptive_max_ < 1e-6f) {
-            adaptive_max_ = 1.0f;
+        if (tension_max_ < 1e-6f) {
+            tension_max_ = 1.0f;
         }
     }
 
     for (size_t li = 0; li < count; ++li) {
         if (lines[li].node_positions.size() < 2) continue;
         if (!line_meshes_[li].vertices) continue;
         UpdateTubeMesh(lines[li], line_meshes_[li],
-                       color_enabled, adaptive_min_, adaptive_max_);
+                       color_enabled, tension_min_, tension_max_);
     }
 }
 
@@ -391,20 +390,26 @@ void MooringLinesViz::UpdateTubeMesh(const MooringLineVizData& line_data,
     const size_t ring_verts = num_nodes * static_cast<size_t>(kSides);
     if (lm.vertices->size() < ring_verts + 2) return;
 
-    const bool has_scalars =
+    const bool has_tensions =
         color_enabled && lm.colors &&
         line_data.node_tensions.size() == num_nodes;
     const float inv_range =
         (range_max - range_min > 1e-12f) ? 1.0f / (range_max - range_min)
                                          : 1.0f;
 
-    std::vector<double> cos_table(kSides);
-    std::vector<double> sin_table(kSides);
-    for (int s = 0; s < kSides; ++s) {
-        const double angle = 2.0 * M_PI * s / kSides;
-        cos_table[s] = std::cos(angle);
-        sin_table[s] = std::sin(angle);
-    }
+    // kSides is a compile-time constant, so the trig table never changes.
+    static const auto cos_table = [] {
+        std::array<double, kSides> t{};
+        for (int s = 0; s < kSides; ++s)
+            t[s] = std::cos(2.0 * M_PI * s / kSides);
+        return t;
+    }();
+    static const auto sin_table = [] {
+        std::array<double, kSides> t{};
+        for (int s = 0; s < kSides; ++s)
+            t[s] = std::sin(2.0 * M_PI * s / kSides);
+        return t;
+    }();
 
     for (size_t ni = 0; ni < num_nodes; ++ni) {
         const vsg::dvec3 tang = Tangent(pts, ni);
@@ -416,7 +421,7 @@ void MooringLinesViz::UpdateTubeMesh(const MooringLineVizData& line_data,
         const auto centre_z = static_cast<float>(pts[ni][2]);
 
         vsg::vec4 col = kDefaultCableColorVec4;
-        if (has_scalars) {
+        if (has_tensions) {
             const float t =
                 (static_cast<float>(line_data.node_tensions[ni]) - range_min)
                 * inv_range;
@@ -467,7 +472,7 @@ void MooringLinesViz::UpdateTubeMesh(const MooringLineVizData& line_data,
     if (lm.colors) {
         vsg::vec4 cap0_col = kDefaultCableColorVec4;
         vsg::vec4 capN_col = kDefaultCableColorVec4;
-        if (has_scalars) {
+        if (has_tensions) {
             cap0_col = TurboColormap(
                 (static_cast<float>(line_data.node_tensions.front()) - range_min)
                 * inv_range);

src/gui/vsg_mooring_lines.h

@@ -42,7 +42,7 @@ class MooringLinesViz {
                     const std::vector<MooringLineVizData>& initial_lines,
                     vsg::ref_ptr<vsg::Group> parent_group = {});
 
-    /// Reposition tube vertices and (optionally) recolour by scalar field.
+    /// Reposition tube vertices and (optionally) recolour by tension.
     /// @param color_enabled  When false, colours are reset to the default cable
     ///                       tan and the adaptive range is left untouched.
     /// @param range_locked   When true the adaptive min/max is frozen.
@@ -54,9 +54,14 @@ class MooringLinesViz {
         return initialized_ && bound_vis_ == vis;
     }
 
-    /// Current adaptive scalar range (for the GUI colour bar).
-    float ScalarMin() const { return adaptive_min_; }
-    float ScalarMax() const { return adaptive_max_; }
+    /// Current adaptive tension range [N] (for the GUI colour bar).
+    float TensionMin() const { return tension_min_; }
+    float TensionMax() const { return tension_max_; }
+
+    /// Evaluate the Turbo colour map at normalised parameter @p t in [0, 1].
+    /// Exposed as a public static so the GUI colour bar can reuse the same
+    /// polynomial without duplicating coefficients.
+    static vsg::vec4 TurboColormap(float t);
 
   private:
     static constexpr int kSides = 8;
@@ -104,9 +109,9 @@ class MooringLinesViz {
     chrono::vsg3d::ChVisualSystemVSG* bound_vis_ = nullptr;
     bool initialized_ = false;
 
-    float adaptive_min_ = 0.0f;
-    float adaptive_max_ = 1.0f;
-    bool adaptive_initialized_ = false;
+    float tension_min_ = 0.0f;
+    float tension_max_ = 1.0f;
+    bool range_initialized_ = false;
     int hold_frames_remaining_ = 0;
 };