[spectro] use more colors in the spectro view

tstack · tstack · commit a7109a2aa796 · 2025-11-23T06:21:06.000-08:00
Related to #1593
diff --git a/NEWS.md b/NEWS.md
@@ -185,6 +185,8 @@ Interface changes:
   row in-between gaps in time.  The spacer row shows
   bullet points on a log scale to represent the amount
   of time in the gap.
+* The SPECTRO view now shows the year in timestamps
+  and uses additional colors to show the value range.
 * If there are background tasks, like the processing done
   by `:add-source-path`, a panel with progress bars for
   each operation will be shown just above the bottom
diff --git a/src/base/color_spaces.cc b/src/base/color_spaces.cc
@@ -285,6 +285,16 @@ lab_color::sufficient_contrast(const lab_color& other) const
             || std::signbit(this->lc_b) != std::signbit(other.lc_b));
 }
 
+lab_color
+lab_color::avg(const lab_color& other) const
+{
+    return lab_color{
+        (this->lc_l + other.lc_l) / 2.0,
+        (this->lc_a + other.lc_a) / 2.0,
+        (this->lc_b + other.lc_b) / 2.0,
+    };
+}
+
 namespace styling {
 
 constexpr color_unit color_unit::EMPTY = color_unit{transparent{}};
diff --git a/src/base/color_spaces.hh b/src/base/color_spaces.hh
@@ -30,6 +30,7 @@
 #ifndef color_spaces_hh
 #define color_spaces_hh
 
+#include <optional>
 #include <string>
 #include <variant>
 
@@ -90,7 +91,10 @@ struct rgb_color {
 };
 
 struct lab_color {
-    constexpr lab_color() : lc_l(0), lc_a(0), lc_b(0) {}
+    explicit constexpr lab_color(double l = 0.0, double a = 0.0, double b = 0.0)
+        : lc_l(l), lc_a(a), lc_b(b)
+    {
+    }
 
     explicit lab_color(const rgb_color& rgb);
 
@@ -100,6 +104,8 @@ struct lab_color {
 
     bool sufficient_contrast(const lab_color& other) const;
 
+    lab_color avg(const lab_color& other) const;
+
     lab_color& operator=(const lab_color& other)
     {
         this->lc_l = other.lc_l;
diff --git a/src/base/lnav.console.cc b/src/base/lnav.console.cc
@@ -455,12 +455,19 @@ role_to_style(const role_t role,
             default_bg_style = fmt::bg(fmt::terminal_color::black);
             break;
         case role_t::VCR_LOW_THRESHOLD:
+        case role_t::VCR_SPECTRO_THRESHOLD0:
+        case role_t::VCR_SPECTRO_THRESHOLD1:
             line_style |= fmt::bg(fmt::terminal_color::green);
             break;
         case role_t::VCR_MED_THRESHOLD:
+        case role_t::VCR_SPECTRO_THRESHOLD2:
+        case role_t::VCR_SPECTRO_THRESHOLD3:
+        case role_t::VCR_SPECTRO_THRESHOLD4:
             line_style |= fmt::bg(fmt::terminal_color::yellow);
             break;
         case role_t::VCR_HIGH_THRESHOLD:
+        case role_t::VCR_SPECTRO_THRESHOLD5:
+        case role_t::VCR_SPECTRO_THRESHOLD6:
             line_style |= fmt::bg(fmt::terminal_color::red);
             break;
         default:
diff --git a/src/base/string_attr_type.hh b/src/base/string_attr_type.hh
@@ -174,6 +174,14 @@ enum class role_t : int32_t {
 
     VCR_OBJECT_KEY,
 
+    VCR_SPECTRO_THRESHOLD0,
+    VCR_SPECTRO_THRESHOLD1,
+    VCR_SPECTRO_THRESHOLD2,
+    VCR_SPECTRO_THRESHOLD3,
+    VCR_SPECTRO_THRESHOLD4,
+    VCR_SPECTRO_THRESHOLD5,
+    VCR_SPECTRO_THRESHOLD6,
+
     VCR__MAX
 };
 
diff --git a/src/lnav.cc b/src/lnav.cc
@@ -1624,6 +1624,9 @@ VALUES ('org.lnav.mouse-support', -1, DATETIME('now', '+1 minute'),
         ld_view.tc_on_click = click_handler;
         ld_view.tc_interactive = true;
     }
+    lnav_data.ld_views[LNV_SPECTRO].tc_cursor_role = std::nullopt;
+    lnav_data.ld_views[LNV_SPECTRO].tc_disabled_cursor_role = std::nullopt;
+
     lnav_data.ld_views[LNV_DB].set_supports_marks(true);
     lnav_data.ld_views[LNV_HELP].set_supports_marks(true);
     lnav_data.ld_views[LNV_HISTOGRAM].set_supports_marks(true);
diff --git a/src/lnav.prompt.cc b/src/lnav.prompt.cc
@@ -1145,33 +1145,27 @@ prompt::get_cmd_parameter_completion(textview_curses& tc,
                 std::unordered_set<std::string> field_names;
                 auto* tss = tc.get_sub_source();
                 auto* dls = dynamic_cast<db_label_source*>(tss);
+                auto* lss = dynamic_cast<logfile_sub_source*>(tss);
+                auto sel_opt = tc.get_selection();
                 if (dls != nullptr) {
                     for (const auto& hdr : dls->dls_headers) {
                         if (!hdr.is_graphable()) {
                             continue;
                         }
                         field_names.emplace(hdr.hm_name);
                     }
-                } else {
-                    tc.map_top_row([&field_names](const auto& al) {
-                        auto attr_opt = get_string_attr(al.al_attrs, SA_FORMAT);
-                        if (attr_opt) {
-                            auto format_name = attr_opt->get();
-                            auto format = log_format::find_root_format(
-                                format_name.c_str());
-                            if (format) {
-                                for (const auto& lvm :
-                                     format->get_value_metadata())
-                                {
-                                    if (lvm.is_numeric()) {
-                                        field_names.emplace(
-                                            lvm.lvm_name.to_string());
-                                    }
-                                }
+                } else if (lss != nullptr && sel_opt) {
+                    auto win = lss->window_at(sel_opt.value());
+                    for (const auto& log_msg : *win) {
+                        for (const auto& lvm : log_msg.get_file_ptr()
+                                                   ->get_format()
+                                                   ->get_value_metadata())
+                        {
+                            if (lvm.is_numeric()) {
+                                field_names.emplace(lvm.lvm_name.to_string());
                             }
                         }
-                        return std::nullopt;
-                    });
+                    }
                 }
 
                 if (field_names.empty()) {
diff --git a/src/log_format_impls.cc b/src/log_format_impls.cc
@@ -608,6 +608,16 @@ class bro_log_format : public log_format {
         this->blf_field_defs.clear();
     }
 
+    std::vector<logline_value_meta> get_value_metadata() const override
+    {
+        std::vector<logline_value_meta> retval;
+
+        for (const auto& fd : this->blf_field_defs) {
+            retval.emplace_back(fd.fd_meta);
+        }
+        return retval;
+    }
+
     scan_result_t scan_int(std::vector<logline>& dst,
                            const line_info& li,
                            shared_buffer_ref& sbr,
@@ -1404,6 +1414,16 @@ class w3c_log_format : public log_format {
         this->wlf_field_defs.clear();
     }
 
+    std::vector<logline_value_meta> get_value_metadata() const override
+    {
+        std::vector<logline_value_meta> retval;
+
+        for (const auto& fd : this->wlf_field_defs) {
+            retval.emplace_back(fd.fd_meta);
+        }
+        return retval;
+    }
+
     scan_result_t scan_int(std::vector<logline>& dst,
                            const line_info& li,
                            shared_buffer_ref& sbr,
diff --git a/src/spectro_source.cc b/src/spectro_source.cc
@@ -241,8 +241,6 @@ spectrogram_source::list_value_for_overlay(const listview_curses& lv,
         auto mark_offset = TIME_COLUMN_WIDTH + this->ss_cursor_column.value();
         auto mark_is_before = true;
 
-        retval.al_attrs.emplace_back(line_range{0, -1},
-                                     VC_ROLE.value(role_t::VCR_STATUS_INFO));
         if (desc.length() + 8 > (ssize_t) width) {
             desc.clear();
         }
@@ -259,6 +257,7 @@ spectrogram_source::list_value_for_overlay(const listview_curses& lv,
         if (!mark_is_before) {
             retval.append("\u25b2 ");
         }
+        retval.with_attr_for_all(VC_ROLE.value(role_t::VCR_CURSOR_LINE));
 
         if (this->ss_details_view != nullptr) {
             if (s_row.sr_details_source_provider) {
@@ -411,18 +410,16 @@ spectrogram_source::chart_attrs_for_line(textview_curses& tc,
             continue;
         }
 
-        role_t role;
-
-        if (col_value < st.st_green_threshold) {
-            role = role_t::VCR_LOW_THRESHOLD;
-        } else if (col_value < st.st_yellow_threshold) {
-            role = role_t::VCR_MED_THRESHOLD;
-        } else {
-            role = role_t::VCR_HIGH_THRESHOLD;
-        }
+        auto role = lnav::enums::to_underlying(role_t::VCR_SPECTRO_THRESHOLD0);
+        auto t_iter = std::lower_bound(std::begin(st.st_thresholds),
+                                       std::end(st.st_thresholds),
+                                       col_value);
+        auto dist = std::distance(std::begin(st.st_thresholds), t_iter);
+        role += dist;
+        ensure(role < (int) role_t::VCR__MAX);
         auto lr
             = line_range{TIME_COLUMN_WIDTH + lpc, TIME_COLUMN_WIDTH + lpc + 1};
-        value_out.emplace_back(lr, VC_ROLE.value(role));
+        value_out.emplace_back(lr, VC_ROLE.value(role_t{role}));
     }
 }
 
@@ -545,6 +542,8 @@ spectrogram_source::cache_bounds()
         return;
     }
 
+    auto [height, width] = this->tss_view->get_dimensions();
+    width -= UNUSABLE_WIDTH;
     auto grain_begin_time = rounddown(sb.sb_begin_time, this->ss_granularity);
     auto grain_end_time = roundup_size(sb.sb_end_time, this->ss_granularity);
 
@@ -555,19 +554,21 @@ spectrogram_source::cache_bounds()
     int64_t samples_per_row = sb.sb_count / this->ss_cached_line_count;
     auto& st = this->ss_cached_thresholds;
 
-    st.st_yellow_threshold = samples_per_row / 4;
-    st.st_green_threshold = st.st_yellow_threshold / 2;
-
-    if (st.st_green_threshold <= 1) {
-        st.st_green_threshold = 2;
-    }
-    if (st.st_yellow_threshold <= st.st_green_threshold) {
-        st.st_yellow_threshold = st.st_green_threshold + 1;
+    st.st_thresholds[0] = samples_per_row / width;
+    st.st_thresholds[1] = samples_per_row / (width / 2);
+    st.st_thresholds[2] = samples_per_row / (width / 4);
+    st.st_thresholds[3] = samples_per_row / (width / 5);
+    st.st_thresholds[4] = samples_per_row / (width / 6);
+    st.st_thresholds[5] = samples_per_row / (width / 8);
+    st.st_thresholds[6] = std::numeric_limits<int>::max();
+    for (size_t lpc = 0; lpc < 6; lpc++) {
+        if (st.st_thresholds[lpc] < lpc + 1) {
+            st.st_thresholds[lpc] = lpc + 1;
+        }
     }
 
     auto& bm = this->tss_view->get_bookmarks()[&textview_curses::BM_USER];
     bm.clear();
-    auto [height, width] = this->tss_view->get_dimensions();
     for (auto row = 0_vl; row < this->ss_cached_line_count; row += 1_vl) {
         spectrogram_request sr(sb);
 
@@ -699,12 +700,12 @@ spectrogram_source::list_static_overlay(const listview_curses& lv,
              ANSI_ROLE("  ") " 1-%'d " ANSI_ROLE("  ") " %'d-%'d " ANSI_ROLE(
                  "  ") " %'d+",
              lnav::enums::to_underlying(role_t::VCR_LOW_THRESHOLD),
-             st.st_green_threshold - 1,
+             st.st_thresholds[0],
              lnav::enums::to_underlying(role_t::VCR_MED_THRESHOLD),
-             st.st_green_threshold,
-             st.st_yellow_threshold - 1,
+             st.st_thresholds[0],
+             st.st_thresholds[3],
              lnav::enums::to_underlying(role_t::VCR_HIGH_THRESHOLD),
-             st.st_yellow_threshold);
+             st.st_thresholds[5]);
     auto buflen = strlen(buf);
     if (line.length() + buflen + 20 < width) {
         line.append(width / 2 - buflen / 3 - line.length(), ' ');
diff --git a/src/spectro_source.hh b/src/spectro_source.hh
@@ -56,8 +56,7 @@ struct spectrogram_bounds {
 };
 
 struct spectrogram_thresholds {
-    int st_green_threshold{0};
-    int st_yellow_threshold{0};
+    int st_thresholds[7]{};
 };
 
 struct spectrogram_request {
diff --git a/src/styling.cc b/src/styling.cc
@@ -267,6 +267,30 @@ term_color_palette::match_color(const lab_color& to_match) const
     return lowest_id;
 }
 
+std::optional<lab_color>
+term_color_palette::to_lab_color(const styling::color_unit& color) const
+{
+    return std::visit(
+        styling::overload{
+            [](styling::transparent) -> std::optional<lab_color> {
+                return std::nullopt;
+            },
+            [](styling::semantic) -> std::optional<lab_color> {
+                return std::nullopt;
+            },
+            [this](const palette_color& pc) -> std::optional<lab_color> {
+                if (pc < this->tc_palette.size()) {
+                    return this->tc_palette[pc].xc_lab_color;
+                }
+                return std::nullopt;
+            },
+            [](const rgb_color& rc) -> std::optional<lab_color> {
+                return lab_color{rc};
+            },
+        },
+        color.cu_value);
+}
+
 namespace styling {
 
 Result<color_unit, std::string>
diff --git a/src/styling.hh b/src/styling.hh
@@ -55,6 +55,9 @@ struct term_color_palette {
 
     uint8_t match_color(const lab_color& to_match) const;
 
+    std::optional<lab_color> to_lab_color(
+        const styling::color_unit& color) const;
+
     std::vector<term_color> tc_palette;
 };
 
diff --git a/src/view_curses.cc b/src/view_curses.cc
@@ -1436,6 +1436,39 @@ view_colors::init_roles(const lnav_theme& lt,
     this->get_role_attrs(role_t::VCR_HIGH_THRESHOLD)
         = this->to_attrs(lt, lt.lt_style_high_threshold, reporter);
 
+    {
+        auto t0_attrs = this->to_attrs(lt, lt.lt_style_low_threshold, reporter);
+        auto t3_attrs = this->to_attrs(lt, lt.lt_style_med_threshold, reporter);
+        auto t6_attrs
+            = this->to_attrs(lt, lt.lt_style_high_threshold, reporter);
+
+        auto t0_color = this->vc_active_palette->to_lab_color(
+            t0_attrs.ra_normal.ta_bg_color);
+        auto t1_attrs = t0_attrs;
+        auto t2_attrs = t3_attrs;
+        auto t3_color = this->vc_active_palette->to_lab_color(
+            t3_attrs.ra_normal.ta_bg_color);
+        auto t4_attrs = t3_attrs;
+        auto t5_attrs = t6_attrs;
+        auto t6_color = this->vc_active_palette->to_lab_color(
+            t6_attrs.ra_normal.ta_bg_color);
+        if (t0_color && t3_color && t6_color) {
+            auto low_mid = t0_color->avg(t3_color.value());
+            auto mid_high = t3_color->avg(t6_color.value());
+            t1_attrs.ra_normal.ta_bg_color = t0_color->avg(low_mid).to_rgb();
+            t2_attrs.ra_normal.ta_bg_color = t3_color->avg(low_mid).to_rgb();
+            t4_attrs.ra_normal.ta_bg_color = t3_color->avg(mid_high).to_rgb();
+            t5_attrs.ra_normal.ta_bg_color = t6_color->avg(mid_high).to_rgb();
+        }
+        this->get_role_attrs(role_t::VCR_SPECTRO_THRESHOLD0) = t0_attrs;
+        this->get_role_attrs(role_t::VCR_SPECTRO_THRESHOLD1) = t1_attrs;
+        this->get_role_attrs(role_t::VCR_SPECTRO_THRESHOLD2) = t2_attrs;
+        this->get_role_attrs(role_t::VCR_SPECTRO_THRESHOLD3) = t3_attrs;
+        this->get_role_attrs(role_t::VCR_SPECTRO_THRESHOLD4) = t4_attrs;
+        this->get_role_attrs(role_t::VCR_SPECTRO_THRESHOLD5) = t5_attrs;
+        this->get_role_attrs(role_t::VCR_SPECTRO_THRESHOLD6) = t6_attrs;
+    }
+
     for (auto level = static_cast<log_level_t>(LEVEL_UNKNOWN + 1);
          level < LEVEL__MAX;
          level = static_cast<log_level_t>(level + 1))
diff --git a/test/expected/test_spectro.sh_4b04dd7663f94be7cf711daaf4674e9a0c729e24.out b/test/expected/test_spectro.sh_4b04dd7663f94be7cf711daaf4674e9a0c729e24.out
@@ -1,3 +1,3 @@
-[4m                          Min: 134 [0m[4m[42m  [0m[4m 1-1 [0m[4m[43m  [0m[4m 2-2 [0m[4m[41m  [0m[4m 3+[0m[4m            Max: 78929[0m
+[4m                          Min: 134 [0m[4m[42m  [0m[4m 1-1 [0m[4m[43m  [0m[4m 1-4 [0m[4m[41m  [0m[4m 6+[0m[4m            Max: 78929[0m
  Mon Jul 20 22:55:00 2009 [42mx[0m                            [42m [0m                     [42m [0m
                           ▲ [1m1[0m value in the range [1m134[0m-[1m1679[0m 
diff --git a/test/expected/test_sql.sh_859af4cc5f57345be8dcece599419d58f332841a.out b/test/expected/test_sql.sh_859af4cc5f57345be8dcece599419d58f332841a.out
@@ -1,4 +1,4 @@
-[4m                          Min: 0 [0m[4m[42m  [0m[4m 1-11 [0m[4m[43m  [0m[4m 12-23 [0m[4m[41m  [0m[4m 24+[0m[4m         Max: 291690[0m
+[4m                          Min: 0 [0m[4m[42m  [0m[4m 1-1 [0m[4m[43m  [0m[4m 1-9 [0m[4m[41m  [0m[4m 16+[0m[4m            Max: 291690[0m
  Thu Nov 03 00:15:00 2011 [41m [0m[43m [0m[42m [0m[42m [0m[42m [0m[42m [0m[42m [0m[42m [0m[42m [0m[42m [0m[42m [0m[42m [0m [42m [0m [42m [0m[42m [0m[42m [0m [42m [0m          [42m [0m               [42m [0m    [42m [0m
                           ▲ [1m84[0m values in the range [1m0[0m-[1m5719[0m 
- Thu Nov 03 00:20:00 2011 [41m [0m[43m [0m[42m [0m[42m [0m[42m [0m[42m [0m  [42m [0m [42m [0m                                         
+ Thu Nov 03 00:20:00 2011 [41m [0m[41m [0m[43m [0m[42m [0m[42m [0m[42m [0m  [42m [0m [42m [0m                                         
