diff --git a/include/plot/plot.hpp b/include/plot/plot.hpp index 9e3c823..b076c70 100644 --- a/include/plot/plot.hpp +++ b/include/plot/plot.hpp @@ -50,6 +50,7 @@ #include #include #include +#include #include #include #include diff --git a/include/plot/plot/legend.hpp b/include/plot/plot/legend.hpp new file mode 100644 index 0000000..222677d --- /dev/null +++ b/include/plot/plot/legend.hpp @@ -0,0 +1,107 @@ +#pragma once +#include + +#include +#include + +namespace plot { + +/// Which corner of `axes` the legend panel is anchored to. +/// +/// There is no "outside the plot" placement: the strips around `axes` are the tick +/// labels' and the axis titles', and a legend that reserved space would resize the +/// plot the moment a caller named a trace. The panel is drawn inside the data area, +/// over the traces, which is why it spends `Legend::margin` keeping off the axes' +/// edges. +enum class LegendPlace { TopLeft, TopRight, BottomLeft, BottomRight }; + +/// The legend's configuration, read by `Plot::layout()` every time it runs. +/// +/// All of it is deliberately coarse: the size, the row heights and the panel's +/// extent come from the text backend's metrics and the names themselves, never from +/// a caller's arithmetic, so a legend can only be *placed* and never mis-measured. +struct Legend { + /// Draw the legend at all. This is on by default and costs nothing to leave on: + /// a legend with no entries -- no trace named, or no backend to measure a name + /// with -- draws nothing and lays out nothing, so the feature is free for a + /// caller who never names a trace. + bool visible = true; + LegendPlace place = LegendPlace::TopRight; + /// Paint the panel: the frame's own `Style::background` at a partial alpha, with a + /// one-pixel border. Off, the entries float on the data with nothing between them + /// and a dense trace. + bool frame = true; + /// Inset from the panel's edge to its first row, and the gutter between a row's + /// swatch and its name. One knob for both, so the panel's interior spacing is one + /// number rather than two. + f32 pad = 6.0f; + /// The swatch's width, and the height it is drawn at whatever the text line's is: + /// `max(swatch_h, line height)` is the row's height, so a small swatch is centred + /// in the line rather than stretching it. + f32 swatch_w = 14.0f; + f32 swatch_h = 8.0f; + /// Blank space between two rows. + f32 row_gap = 3.0f; + /// How far the panel is held back from the `axes` edge. It is the anchor's inset + /// *and* the budget the panel has to fit in, which is what makes "never crosses + /// `axes`" a property of one number instead of two that can disagree: a panel that + /// does not fit inside `axes` inset by this drops entries rather than overhanging + /// the plot (see `LegendLayout`). + f32 margin = 8.0f; +}; + +/// One legend entry: which trace it names, and the two boxes it is drawn in. +/// +/// The boxes are the *layout's* output, not a renderer's input to be re-derived: +/// `Plot::layout()` places the swatch and the name's pen, and the renderer stages +/// exactly those pixels. A renderer that computed either from the panel rect would +/// be a second, independent copy of the placement rule -- which is the bug the +/// measured layout exists to prevent -- so nothing here needs arithmetic after the +/// fact. +struct LegendRow { + /// Index of the trace this row names: `Plot::trace(trace)` is what the row's + /// swatch is coloured by. The filter that chose the row (visible, named) is not + /// repeated by the renderer. Not meaningful on the truncation row. + u32 trace = 0; + /// This row is the truncation marker rather than a trace: entries did not fit and + /// the panel ends with `kLegendEllipsis` in place of the ones it dropped. Always + /// the last row, and its `swatch` is empty -- there is no trace to colour. + bool ellipsis = false; + /// The swatch's box, `Legend::swatch_w` x `Legend::swatch_h`, centred in the row. + /// Empty on the truncation row; the row's name box starts where the other rows' + /// names do either way, so the marker lines up with the names above it. + Rect swatch; + /// The name's line box: its top-left is the pen the run is staged at and its + /// height is one text line, so the box *is* the placement. Its width is what the + /// backend measured for this row's own string (the truncation row measures + /// `kLegendEllipsis`). + Rect name; +}; + +/// The measured legend: the panel to paint and the rows to draw in it, in the same +/// pixel space as `PlotLayout`, which `Plot::layout()` fills alongside its own +/// rects. +/// +/// It is a member of `PlotLayout` rather than a second call so the numbers a test +/// asserts and the numbers the renderer draws are one set: a panel rect, and one +/// entry per row with the trace and both boxes. Everything is zero/empty when there +/// is nothing to draw -- no backend, no named visible trace, or no room for even one +/// entry and the truncation marker -- and an empty legend is what makes a plot that +/// never names a trace lay out byte-for-byte as it did before legends existed. +struct LegendLayout { + /// The panel, always inside `PlotLayout::axes`. Zero-sized when there is nothing + /// to draw. + Rect panel; + /// The rows to draw, in trace order, truncated from the end when they did not fit. + std::vector rows; + + bool empty() const noexcept { return rows.empty(); } +}; + +/// The last row of a truncated legend. ASCII, and one constant for both sides of the +/// feature, because the embedded atlas has no U+2026: the three-dot form is the one +/// that draws, and the layout measures this string while the renderer stages it, so +/// the two cannot disagree about how wide the row is. +inline constexpr const char* kLegendEllipsis = "..."; + +} // namespace plot diff --git a/include/plot/plot/plot.hpp b/include/plot/plot/plot.hpp index 10f595b..5276f6b 100644 --- a/include/plot/plot/plot.hpp +++ b/include/plot/plot/plot.hpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -50,6 +51,12 @@ struct PlotLayout { /// no text backend there is no title to lay out at all and both stay 0.0f. f32 y_title_width = 0.0f; f32 x_title_height = 0.0f; + /// The measured legend: inside `axes`, never reserving any part of it, and empty + /// when there is nothing to draw. It is measured with the same text backend the + /// strips above are, and against the same `axes` rect the caller reads back, so + /// the panel a test asserts and the panel the renderer paints are one set of + /// numbers rather than two derivations of one rule (see LegendLayout). + LegendLayout legend; }; /// The public façade: axes, traces, cursors, annotations and their layout. @@ -221,6 +228,17 @@ class Plot { /// Grid segments for the primary axis pair (x axis 0, y axis 0), in data space. const Grid& grid() const noexcept { return grid_; } + // --- legend ----------------------------------------------------------- + + /// The legend's configuration. A legend is on unless a caller turns it off and + /// costs nothing until a trace is named: with no named visible trace -- or no text + /// backend to measure a name with -- `layout()` produces an empty layout and + /// nothing is drawn. + const Legend& legend() const noexcept { return legend_; } + /// Replaces the configuration. The next `layout()` measures the panel with it, so + /// a caller can move the legend -- or switch it off -- between frames. + void set_legend(const Legend& legend) noexcept { legend_ = legend; } + private: /// One measure plus its cache. The dirty flag is what keeps measurement() from /// re-evaluating every frame; `last_series`, `last_size` and `last_x0` catch a @@ -263,10 +281,17 @@ class Plot { /// sides: the column the rotated y title is drawn in, one column per titled /// axis. Zero with no backend or no titled y axis. f32 y_title_strip_width() const; + /// Measures the legend into `layout_.legend`: which traces have an entry, how wide + /// the panel has to be, where it is anchored, and one row per entry it can fit. + /// Zeroes the layout and returns when there is nothing to measure with or nothing + /// to list -- an empty legend is what keeps the feature free for a caller who + /// never names a trace. + void build_legend(); Rect viewport_{}; render::Style style_{}; const render::TextBackend* text_ = nullptr; + Legend legend_{}; std::vector x_axes_; std::vector y_axes_; @@ -274,6 +299,12 @@ class Plot { std::vector cursors_; std::vector measures_; std::vector annotations_; + /// Scratch for build_legend(): the name width of every trace that has an entry, in + /// trace order and prefix-maxed in place, so the fit loop reads the width a given + /// number of kept entries needs in O(1) instead of re-measuring the names it is + /// about to drop. A member rather than a local, so a steady-state frame's legend + /// build allocates nothing. + std::vector legend_name_px_; PlotLayout layout_{}; Grid grid_; diff --git a/include/plot/plot/trace.hpp b/include/plot/plot/trace.hpp index 67ba4a7..cdc6305 100644 --- a/include/plot/plot/trace.hpp +++ b/include/plot/plot/trace.hpp @@ -2,6 +2,7 @@ #include #include #include +#include namespace plot { @@ -12,6 +13,13 @@ struct TraceDesc { Color color = Color::hex(0x4FA3FF); f32 width = 1.5f; u32 axis_x = 0, axis_y = 0; + /// What the trace is called, for the legend. Empty means "do not list it", which + /// is the whole cost of a legend for a caller that never names one: the trailing + /// default is what keeps the five-field aggregate initialisation every existing + /// caller writes -- `{&series, colour, width, axis_x, axis_y}` -- working + /// unchanged, exactly as `AxisDesc`'s trailing format does (and, in a build with + /// `-Wextra`, warning-clean). + std::string name{}; }; /// A series bound to a colour, width and axis pair. The series pointer may be @@ -22,6 +30,10 @@ struct Trace { Color color = Color::hex(0x4FA3FF); f32 width = 1.5f; u32 axis_x = 0, axis_y = 0; + /// The legend's entry for this trace, empty when it has none. A name does not + /// make a trace drawable: the legend lists a trace only when it is visible, so a + /// null series is skipped there exactly as it is by every other consumer. + std::string name{}; /// True when the trace has a series with at least one sample to draw. bool visible() const noexcept { return series != nullptr && series->size() > 0; } diff --git a/include/plot/render/renderer.hpp b/include/plot/render/renderer.hpp index f62e4b9..bb6168a 100644 --- a/include/plot/render/renderer.hpp +++ b/include/plot/render/renderer.hpp @@ -101,6 +101,13 @@ class Renderer { /// `Plot::layout()` is computed exactly once, here, and handed to every helper: /// it runs the auto scale, the strip fixed-point loop and the grid build, so /// re-deriving it per helper would rebuild the ticks and the grid per helper. + /// + /// A legend the plot has is part of the frame: the panel and its swatches are + /// line geometry staged with everything else, the names are glyphs on the text + /// path, and both read the boxes `PlotLayout::legend` measured. It is the last + /// line batch, so the legend cannot be drawn under a trace, and it leaves no GL + /// state of its own -- the frame's blend and its neighbours' scissor already say + /// everything a fill and a hairline border need (see end_frame's residue list). void draw(Plot& plot); /// Ends the frame, draining `glGetError()` in a loop so a stale error cannot be @@ -254,6 +261,14 @@ class Renderer { /// is texture-bound, so this runs once per frame, after all line geometry. void flush_text() noexcept; + /// Fills `rect` -- in framebuffer pixels, like `Rect` -- with `color`, in one + /// instance: a horizontal stroke whose width is the rect's height *is* the rect, + /// because a stroke's quad is its perpendicular width and the fragment shader + /// ramps on that perpendicular alone -- the ends are not capped (see + /// `fill_pixels()` in the implementation for why a per-column fill, the way the + /// measurement band fills, is the wrong primitive here). A rect with no width or + /// no height stages nothing. + void fill_pixels(const Rect& rect, Color color); /// Stages one data-space segment, taking the two axes' log flags into account. void stage_segment(f64 x0, f64 y0, f64 x1, f64 y1, bool log_x, bool log_y); /// Stages `n` interleaved `x,y` data-space points (a gathered window). @@ -290,6 +305,11 @@ class Renderer { void draw_cursors(const Plot& plot, const PlotLayout& layout); void draw_measures(const Plot& plot, const PlotLayout& layout); void draw_annotations(const Plot& plot); + /// The legend: the panel and its swatches as line geometry, the names on the text + /// path. It reads the boxes `Plot::layout()` measured rather than deriving any of + /// them again, so the panel a test asserts and the panel this draws are the same + /// numbers. + void draw_legend(const Plot& plot, const PlotLayout& layout); /// The built-in backend the renderer owns. Every use of it goes through the /// `TextBackend` interface -- `self`-typed nowhere -- so swapping it for diff --git a/src/plot/plot.cpp b/src/plot/plot.cpp index 2f950c1..d5cfb36 100644 --- a/src/plot/plot.cpp +++ b/src/plot/plot.cpp @@ -106,6 +106,7 @@ u32 Plot::add_trace(const TraceDesc& desc) { trace.width = desc.width; trace.axis_x = desc.axis_x; trace.axis_y = desc.axis_y; + trace.name = desc.name; traces_.push_back(trace); mark_measures_dirty(); return static_cast(traces_.size() - 1); @@ -388,6 +389,10 @@ const PlotLayout& Plot::layout() { } build_grid(); + // The legend is measured last, from the finished `axes`: it lives inside the data + // area and reserves nothing, so it can neither move the strips above nor depend on + // anything but the rect they settled on. + build_legend(); return layout_; } @@ -461,4 +466,97 @@ f32 Plot::y_label_width() const { return widest + 2.0f * style_.grid_label_pad; } +void Plot::build_legend() { + LegendLayout& legend = layout_.legend; + legend.rows.clear(); + legend.panel = Rect{}; + // Nothing to measure with, or nothing asked for: an empty layout, and with it a + // plot that lays out exactly as it did before legends existed. + if (text_ == nullptr || !legend_.visible) return; + + const f32 pad = legend_.pad; + const f32 line_h = text_->height(); + const f32 row_h = std::max(legend_.swatch_h, line_h); + // Entry widths, prefix-maxed: dropping from the end then costs no re-measure, and + // the panel's width after a drop is the width of an entry that is still listed. + legend_name_px_.clear(); + for (const Trace& trace : traces_) { + // A trace with no series, no samples, or no name is not an entry -- the same + // "visible" test every other consumer of a trace makes, plus the name. + if (!trace.visible() || trace.name.empty()) continue; + const f32 width = text_->measure(trace.name.c_str()); + legend_name_px_.push_back(legend_name_px_.empty() ? width + : std::max(legend_name_px_.back(), width)); + } + const u32 entries = static_cast(legend_name_px_.size()); + if (entries == 0u) return; + + const f32 ellipsis_w = text_->measure(kLegendEllipsis); + const f32 room_w = layout_.axes.w - 2.0f * legend_.margin; + const f32 room_h = layout_.axes.h - 2.0f * legend_.margin; + + // Fit, from every entry down: the panel is a row per entry with `row_gap` between, + // and, once an entry has been dropped, one more row for the marker that says so. + // The marker is part of the panel, so it is part of what has to fit -- a legend + // that dropped entries and then overhung the axes would be the defect the drop + // exists to avoid. When even one entry plus the marker has no room, there is no + // panel at all: a plot's data area is not a place to draw a legend that does not + // fit it. + u32 keep = entries; + f32 panel_w = 0.0f; + f32 panel_h = 0.0f; + for (;;) { + const bool truncated = keep < entries; + const f32 widest = truncated ? std::max(legend_name_px_[keep - 1u], ellipsis_w) + : legend_name_px_[keep - 1u]; + const f32 rows = static_cast(keep + (truncated ? 1u : 0u)); + panel_w = 2.0f * pad + legend_.swatch_w + pad + widest; + panel_h = 2.0f * pad + rows * row_h + (rows - 1.0f) * legend_.row_gap; + if (panel_w <= room_w && panel_h <= room_h) break; + if (--keep == 0u) return; // not even one entry and its marker fit + } + + // Anchored in the corner `place` names and held `margin` off both edges, which is + // the inset the fit above was measured against -- so the panel is inside `axes` by + // construction and can never cross it, whatever corner it was put in. + f32 x = layout_.axes.x + legend_.margin; + f32 y = layout_.axes.y + legend_.margin; + if (legend_.place == LegendPlace::TopRight || legend_.place == LegendPlace::BottomRight) { + x = layout_.axes.right() - legend_.margin - panel_w; + } + if (legend_.place == LegendPlace::BottomLeft || legend_.place == LegendPlace::BottomRight) { + y = layout_.axes.bottom() - legend_.margin - panel_h; + } + legend.panel = Rect{x, y, panel_w, panel_h}; + + // The rows themselves: the swatch and the name's line box, both placed here rather + // than left to a renderer to re-derive (one placement rule, one place to read it). + // The name box starts one swatch and one gutter in -- exactly what the panel's + // width allowed for -- and both boxes are centred in the row's height, so a swatch + // shorter than the text line is centred on it instead of sitting on its baseline. + const f32 name_x = x + pad + legend_.swatch_w + pad; + f32 row_y = y + pad; + for (u32 i = 0; i < traces_.size() && legend.rows.size() < keep; ++i) { + const Trace& trace = traces_[i]; + if (!trace.visible() || trace.name.empty()) continue; + LegendRow row; + row.trace = i; + row.swatch = Rect{x + pad, row_y + 0.5f * (row_h - legend_.swatch_h), legend_.swatch_w, + legend_.swatch_h}; + row.name = Rect{name_x, row_y + 0.5f * (row_h - line_h), + text_->measure(trace.name.c_str()), line_h}; + legend.rows.push_back(row); + row_y += row_h + legend_.row_gap; + } + if (keep < entries) { + // Entries were dropped; the marker takes the row after the last kept one, with no + // swatch -- there is no trace to colour -- and the name column's own x, so it + // lines up with the names above it. + LegendRow marker; + marker.ellipsis = true; + marker.name = Rect{name_x, row_y + 0.5f * (row_h - line_h), ellipsis_w, line_h}; + legend.rows.push_back(marker); + } +} + } // namespace plot diff --git a/src/render/renderer.cpp b/src/render/renderer.cpp index 2958e4d..2782cb1 100644 --- a/src/render/renderer.cpp +++ b/src/render/renderer.cpp @@ -59,6 +59,14 @@ constexpr usize kReadoutChars = 160; constexpr Vec2 kTextRight{1.0f, 0.0f}; constexpr Vec2 kTextUp{0.0f, -1.0f}; +/// How much of its alpha the legend's panel keeps. The panel is the frame's own +/// background, so at 1.0 it would be a hole in the plot with the traces cut off at +/// its edge; at this share the data underneath stays faintly visible and the panel +/// reads as something laid *over* the plot -- which is what the border is for. A +/// host whose background is already translucent gets a proportionally fainter +/// panel, which is the same statement about its own theme. +constexpr f32 kLegendPanelAlpha = 0.85f; + /// Walks the longest prefix of `utf8` that fits `budget_px` along `axis`, calling /// `emit(pen, glyph)` for every glyph it keeps -- `pen` in viewport pixels, /// `glyph` the backend's own entry for that codepoint -- and returning the length @@ -324,8 +332,12 @@ void Renderer::draw(Plot& plot) { // below reads the strips, the axes rect and the transforms it pins. const PlotLayout& layout = plot.layout(); - // Draw order: chrome, then data, then the annotations over it, and the text - // last (it is texture-bound, so it is one draw call after every line batch). + // Draw order: chrome, then data, then the overlays over it, and the text last (it + // is texture-bound, so it is one draw call after every line batch). The legend + // closes the line batches: its panel is a backplate, so it is drawn over + // everything geometric -- a legend under a trace is a legend nobody can read -- + // while its names join the frame's single text flush with every other label, which + // is what keeps the two-pipeline order the whole frame is built on. draw_grid(plot); draw_axis_lines(plot); draw_tick_labels(plot, layout); @@ -334,6 +346,7 @@ void Renderer::draw(Plot& plot) { draw_cursors(plot, layout); draw_measures(plot, layout); draw_annotations(plot); + draw_legend(plot, layout); flush_text(); } @@ -463,6 +476,25 @@ Vec2 Renderer::to_viewport(Vec2 px) const noexcept { return Vec2{px.x - viewport_.x, px.y - viewport_.y}; } +void Renderer::fill_pixels(const Rect& rect, Color color) { + if (!(rect.w > 0.0f) || !(rect.h > 0.0f)) return; + // The line pipeline has no filled primitive and does not need one: a stroke's + // quad is its perpendicular width, and the fragment shader ramps on that + // perpendicular alone -- a stroke is not capped at its ends -- so a *horizontal* + // stroke `rect.h` wide from the rect's left edge to its right edge is the rect + // itself, opaque everywhere but the half pixel at each horizontal edge where the + // ramp lives. + // + // A fill per pixel column, the way the measurement band fills its interval, is the + // other way to read this, and it is the wrong one here: a legend panel is + // *measured*, so its edges never land on the pixel grid, and a column fill of a + // rect that is half a pixel off lights every one of its columns at 0.8 -- a swatch + // that is a washed-out version of the trace it is supposed to stand for. One + // instance instead of one per column is the same answer for the cost. + lines_.add_segment({rect.x, rect.y + 0.5f * rect.h}, {rect.right(), rect.y + 0.5f * rect.h}); + flush_lines(pixel_mapping(), color, rect.h); +} + void Renderer::stage_segment(f64 x0, f64 y0, f64 x1, f64 y1, bool log_x, bool log_y) { lines_.add_segment(pre_affine(x0, y0, log_x, log_y), pre_affine(x1, y1, log_x, log_y)); } @@ -802,6 +834,52 @@ void Renderer::draw_annotations(const Plot& plot) { } } +void Renderer::draw_legend(const Plot& plot, const PlotLayout& layout) { + const LegendLayout& legend = layout.legend; + if (legend.rows.empty()) return; + + const Rect& panel = legend.panel; + if (plot.legend().frame) { + // The panel first, so every entry is on top of it: the frame's own background + // at a partial alpha, which dims whatever it covers instead of erasing it. + Color background = style_.background; + background.a *= kLegendPanelAlpha; + fill_pixels(panel, background); + // The border frames the pixels the fill covers, not the measured rect's own + // fractional edges: those are wherever the names happened to measure to, and a + // hairline drawn on one is lit half-heartedly -- a frame bright on three sides and + // dim on the fourth reads as a mistake. These are the outermost lit columns and + // rows the fill's span rounds out to (the same rounding the fill itself does), so + // every side of the frame is one crisp hairline. + const f32 left = std::ceil(panel.x - 0.5f) + 0.5f; + const f32 right = std::ceil(panel.right() - 0.5f) - 0.5f; + const f32 top = std::ceil(panel.y - 0.5f) + 0.5f; + const f32 bottom = std::ceil(panel.bottom() - 0.5f) - 0.5f; + lines_.add_segment({left, top}, {right, top}); + lines_.add_segment({left, bottom}, {right, bottom}); + lines_.add_segment({left, top}, {left, bottom}); + lines_.add_segment({right, top}, {right, bottom}); + flush_lines(pixel_mapping(), style_.axis_line, 1.0f); + } + + for (const LegendRow& row : legend.rows) { + // The truncation row names no trace: it has no swatch to colour and its text is + // the marker itself, so both branches read their string from one place -- the + // layout measured it, this stages it. + if (row.ellipsis) { + stage_text({row.name.x, row.name.y}, kLegendEllipsis); + continue; + } + // Opaque whatever the trace's own alpha is: a swatch drawn at a trace's 15% would + // be the least legible thing in the frame, and the swatch is the one element that + // says which colour a legend entry *is*. + Color swatch = plot.trace(row.trace).color; + swatch.a = 1.0f; + fill_pixels(row.swatch, swatch); + stage_text({row.name.x, row.name.y}, plot.trace(row.trace).name.c_str()); + } +} + // -------------------------------------------------------------------- dump bool Renderer::dump_frame_ppm(const char* path, Status* st) const { diff --git a/tests/test_plot.cpp b/tests/test_plot.cpp index e604d37..e89af23 100644 --- a/tests/test_plot.cpp +++ b/tests/test_plot.cpp @@ -563,3 +563,279 @@ PLOT_TEST(grid_lines_are_tick_aligned_data_space_segments) { for (const plot::GridLine& l : g.lines()) minor += l.major ? 0u : 1u; PLOT_CHECK(minor > 0); // minor grid is generated too } + +// ------------------------------------------------------------------- legend + +namespace { + +/// The scene the legend cases measure: three named traces on one axis pair, a text +/// backend to measure the names with, and a viewport with room to spare. The names +/// are deliberately of different widths -- a panel sized to the *widest* one is what +/// the first case below checks, and names of one width could not tell that from a +/// panel sized to the first or the last. +struct LegendScene { + plot::render::EmbeddedMonoFont font; + plot::data::ArraySeries series; + plot::Plot plot; + + LegendScene() : series(ramp(64), 0.0, 1.0) { + plot.set_text_backend(&font); + plot.set_viewport({0.0f, 0.0f, 800.0f, 400.0f}); + const u32 ax = plot.add_x_axis({"t", {0.0, 63.0}, false, plot::AxisPlace::Bottom, false}); + const u32 ay = plot.add_y_axis({"v", {0.0, 63.0}, false, plot::AxisPlace::Left, false}); + plot.add_trace({&series, plot::Color::hex(0x40C0FF), 1.5f, ax, ay, "sine"}); + plot.add_trace({&series, plot::Color::hex(0xFFB020), 1.5f, ax, ay, "noise floor"}); + plot.add_trace({&series, plot::Color::hex(0x00E070), 1.5f, ax, ay, "ramp"}); + } +}; + +/// One row's height is the taller of the swatch and a text line: the number every +/// other assertion here is written against, derived from the config the layout reads. +f32 legend_row_height(const plot::Legend& cfg, const plot::render::TextBackend& font) { + return std::max(cfg.swatch_h, font.height()); +} + +} // namespace + +PLOT_TEST(legend_panel_wraps_the_entries) { + LegendScene scene; + const plot::PlotLayout& l = scene.plot.layout(); + const plot::LegendLayout& legend = l.legend; + const plot::Legend& cfg = scene.plot.legend(); + + PLOT_CHECK(legend.rows.size() == 3u); + const f32 pad = cfg.pad; + const f32 row_h = legend_row_height(cfg, scene.font); + const f32 row_gap = cfg.row_gap; + const f32 widest = std::max({scene.font.measure("sine"), scene.font.measure("noise floor"), + scene.font.measure("ramp")}); + + // Anchored in the corner `place` names (top right by default), one `margin` in + // from the two edges that corner is near... + PLOT_CHECK_NEAR(legend.panel.right(), l.axes.right() - cfg.margin, 1e-4); + PLOT_CHECK_NEAR(legend.panel.y, l.axes.y + cfg.margin, 1e-4); + // ... and measured, not guessed: a padding, the swatch, a gutter and the widest + // name across; a padding, the rows and the gaps between them down. + PLOT_CHECK_NEAR(legend.panel.w, 2.0f * pad + cfg.swatch_w + pad + widest, 1e-4); + PLOT_CHECK_NEAR(legend.panel.h, 2.0f * pad + 3.0f * row_h + 2.0f * row_gap, 1e-4); + + // Every row in trace order, one row gap below the last, with the boxes the + // renderer stages from already placed -- no arithmetic left for a caller. + const f32 name_x = legend.panel.x + pad + cfg.swatch_w + pad; + f32 row_y = legend.panel.y + pad; + for (u32 i = 0; i < legend.rows.size(); ++i) { + const plot::LegendRow& row = legend.rows[i]; + PLOT_CHECK(row.trace == i); + PLOT_CHECK(!row.ellipsis); + PLOT_CHECK_NEAR(row.swatch.x, legend.panel.x + pad, 1e-4); + PLOT_CHECK_NEAR(row.swatch.y, row_y + 0.5f * (row_h - cfg.swatch_h), 1e-4); + PLOT_CHECK_NEAR(row.swatch.w, cfg.swatch_w, 1e-4); + PLOT_CHECK_NEAR(row.swatch.h, cfg.swatch_h, 1e-4); + PLOT_CHECK_NEAR(row.name.x, name_x, 1e-4); + PLOT_CHECK_NEAR(row.name.y, row_y + 0.5f * (row_h - scene.font.height()), 1e-4); + PLOT_CHECK_NEAR(row.name.h, scene.font.height(), 1e-4); + // Both boxes are inside the panel, swatch to panel edge and name to the padding + // the panel reserved for it. + PLOT_CHECK(row.swatch.x >= legend.panel.x); + PLOT_CHECK(row.swatch.right() <= legend.panel.right()); + PLOT_CHECK(row.name.right() <= legend.panel.right() - pad + 1e-4f); + row_y += row_h + row_gap; + } + + // The wrapper property, stated as the number it is: the widest row's name ends + // exactly one padding short of the panel's edge, which is what "the panel is + // sized to the widest name" means. A panel sized to another row's name would fail + // this by that row's difference in width. + PLOT_CHECK_NEAR(legend.rows[1].name.w, widest, 1e-4); + PLOT_CHECK_NEAR(legend.rows[1].name.right() + pad, legend.panel.right(), 1e-4); +} + +/// A legend is inside `axes` in every corner, held off the two edges its corner is +/// near by `margin` and off the other two by its own measured size. The clamp is +/// what stops a legend from being drawn over the tick labels or the data the plot +/// reserved no room for -- it is inside the data area by construction, since the fit +/// above is measured against exactly this inset. +PLOT_TEST(legend_is_clamped_inside_the_axes) { + LegendScene scene; + const plot::LegendPlace places[4] = {plot::LegendPlace::TopLeft, plot::LegendPlace::TopRight, + plot::LegendPlace::BottomLeft, + plot::LegendPlace::BottomRight}; + for (const plot::LegendPlace place : places) { + plot::Legend cfg = scene.plot.legend(); + cfg.place = place; + scene.plot.set_legend(cfg); + const plot::PlotLayout& l = scene.plot.layout(); + const plot::Rect& panel = l.legend.panel; + PLOT_CHECK(!l.legend.empty()); + + // Inside the data area: half-open containment, so the far edges compare directly. + PLOT_CHECK(panel.x >= l.axes.x); + PLOT_CHECK(panel.y >= l.axes.y); + PLOT_CHECK(panel.right() <= l.axes.right()); + PLOT_CHECK(panel.bottom() <= l.axes.bottom()); + + const bool near_right = place == plot::LegendPlace::TopRight || + place == plot::LegendPlace::BottomRight; + const bool near_bottom = place == plot::LegendPlace::BottomLeft || + place == plot::LegendPlace::BottomRight; + PLOT_CHECK_NEAR(near_right ? panel.right() : panel.x, + near_right ? l.axes.right() - cfg.margin : l.axes.x + cfg.margin, 1e-4); + PLOT_CHECK_NEAR(near_bottom ? panel.bottom() : panel.y, + near_bottom ? l.axes.bottom() - cfg.margin : l.axes.y + cfg.margin, 1e-4); + } +} + +/// Entries that do not fit are dropped from the end and the panel says so with a +/// final marker row; a plot with no room for even one entry and its marker gets no +/// legend at all rather than a panel over the axes. Both halves are the same rule +/// read in opposite directions, so they are asserted together. +PLOT_TEST(legend_drops_overflowing_entries) { + plot::render::EmbeddedMonoFont font; + plot::data::ArraySeries series(ramp(64), 0.0, 1.0); + plot::Plot p; + p.set_text_backend(&font); + p.set_viewport({0.0f, 0.0f, 400.0f, 260.0f}); + const u32 ax = p.add_x_axis({"t", {0.0, 63.0}, false, plot::AxisPlace::Bottom, false}); + const u32 ay = p.add_y_axis({"v", {0.0, 63.0}, false, plot::AxisPlace::Left, false}); + constexpr u32 kNamed = 20; + for (u32 i = 0; i < kNamed; ++i) p.add_trace({&series, plot::Color::hex(0x40C0FF), 1.5f, ax, ay, + "trace " + std::to_string(i)}); + + const plot::PlotLayout& l = p.layout(); + const plot::LegendLayout& legend = l.legend; + const plot::Legend& cfg = p.legend(); + const f32 pad = cfg.pad; + const f32 row_h = legend_row_height(cfg, font); + + // Re-derive the rule rather than assert a coincidence: the largest number of kept + // entries whose panel -- with the marker row it needs once anything was dropped -- + // still fits the inset box. `k + 1` rows is the truncated case, `k` the untruncated + // one; both are tried from the top down, exactly as the layout does. + const f32 room_h = l.axes.h - 2.0f * cfg.margin; + u32 expected = 0; + for (u32 k = kNamed; k > 0u; --k) { + const bool truncated = k < kNamed; + const f32 rows = static_cast(k + (truncated ? 1u : 0u)); + if (2.0f * pad + rows * row_h + (rows - 1.0f) * cfg.row_gap <= room_h) { + expected = k; + break; + } + } + // The scene has to be one where the rule actually bites, or the case proves + // nothing about dropping entries. + PLOT_CHECK(expected != 0u); + PLOT_CHECK(expected < kNamed); + PLOT_CHECK(legend.rows.size() == expected + 1u); + + // The kept entries are the first `expected` ones, in trace order: entries are + // dropped from the end, never from the middle. + for (u32 i = 0; i < expected; ++i) { + PLOT_CHECK(!legend.rows[i].ellipsis); + PLOT_CHECK(legend.rows[i].trace == i); + } + const plot::LegendRow& marker = legend.rows.back(); + PLOT_CHECK(marker.ellipsis); + PLOT_CHECK(marker.name.x == legend.rows[0].name.x); // the marker lines up with the names + PLOT_CHECK_NEAR(marker.name.w, font.measure(plot::kLegendEllipsis), 1e-4); + PLOT_CHECK(marker.swatch.w == 0.0f && marker.swatch.h == 0.0f); // no trace, no swatch + + // The panel with the marker is inside `axes`, which is the property the drop + // exists to keep: a panel that overhung the plot would be worse than a short list. + PLOT_CHECK(legend.panel.x >= l.axes.x && legend.panel.right() <= l.axes.right()); + PLOT_CHECK(legend.panel.y >= l.axes.y && legend.panel.bottom() <= l.axes.bottom()); + + // Not even one entry plus the marker fits: no legend at all, and nothing drawn. + plot::Plot tiny; + tiny.set_text_backend(&font); + tiny.set_viewport({0.0f, 0.0f, 120.0f, 60.0f}); + const u32 tax = tiny.add_x_axis({"t", {0.0, 63.0}, false, plot::AxisPlace::Bottom, false}); + const u32 tay = tiny.add_y_axis({"v", {0.0, 63.0}, false, plot::AxisPlace::Left, false}); + tiny.add_trace({&series, plot::Color::hex(0x40C0FF), 1.5f, tax, tay, "sine"}); + const plot::PlotLayout& tl = tiny.layout(); + PLOT_CHECK(tl.legend.empty()); + PLOT_CHECK_NEAR(tl.legend.panel.w, 0.0f, 1e-6); + PLOT_CHECK_NEAR(tl.legend.panel.h, 0.0f, 1e-6); +} + +/// A trace with no name is not an entry, and neither is a trace with no series to +/// draw -- the same "visible" test every other consumer of a trace makes. This is +/// the whole cost of the feature for a caller that never names a trace: nothing. +PLOT_TEST(unnamed_traces_produce_no_legend) { + plot::render::EmbeddedMonoFont font; + plot::data::ArraySeries series(ramp(64), 0.0, 1.0); + plot::Plot p; + p.set_text_backend(&font); + p.set_viewport({0.0f, 0.0f, 800.0f, 400.0f}); + const u32 ax = p.add_x_axis({"t", {0.0, 63.0}, false, plot::AxisPlace::Bottom, false}); + const u32 ay = p.add_y_axis({"v", {0.0, 63.0}, false, plot::AxisPlace::Left, false}); + p.add_trace({&series, plot::Color::hex(0x40C0FF), 1.5f, ax, ay}); // no name + p.add_trace({nullptr, plot::Color::hex(0xFFB020), 1.5f, ax, ay, "ghost"}); // named, no series + p.add_trace({&series, plot::Color::hex(0x00E070), 1.5f, ax, ay, "sig"}); + + const plot::PlotLayout& l = p.layout(); + PLOT_CHECK(l.legend.rows.size() == 1u); + PLOT_CHECK(l.legend.rows[0].trace == 2u); // the named, drawable one, by its own id + PLOT_CHECK(!l.legend.rows[0].ellipsis); + + // Without the one name, the layout is empty and zero-sized: no panel, no rows. + plot::Plot unnamed; + unnamed.set_text_backend(&font); + unnamed.set_viewport({0.0f, 0.0f, 800.0f, 400.0f}); + const u32 uax = unnamed.add_x_axis({"t", {0.0, 63.0}, false, plot::AxisPlace::Bottom, false}); + const u32 uay = unnamed.add_y_axis({"v", {0.0, 63.0}, false, plot::AxisPlace::Left, false}); + unnamed.add_trace({&series, plot::Color::hex(0x40C0FF), 1.5f, uax, uay}); + unnamed.add_trace({&series, plot::Color::hex(0xFFB020), 1.5f, uax, uay}); + const plot::LegendLayout& none = unnamed.layout().legend; + PLOT_CHECK(none.empty()); + PLOT_CHECK_NEAR(none.panel.w, 0.0f, 1e-6); + PLOT_CHECK_NEAR(none.panel.h, 0.0f, 1e-6); +} + +/// A plot has no font of its own, so a legend with nothing to measure a name with is +/// no legend: the plot keeps the defaults it laid out with before legends existed. +PLOT_TEST(no_text_backend_produces_no_legend) { + plot::data::ArraySeries series(ramp(64), 0.0, 1.0); + plot::Plot p; + p.set_viewport({0.0f, 0.0f, 800.0f, 400.0f}); + const u32 ax = p.add_x_axis({"t", {0.0, 63.0}, false, plot::AxisPlace::Bottom, false}); + const u32 ay = p.add_y_axis({"v", {0.0, 63.0}, false, plot::AxisPlace::Left, false}); + p.add_trace({&series, plot::Color::hex(0x40C0FF), 1.5f, ax, ay, "sine"}); + + const plot::PlotLayout& l = p.layout(); + PLOT_CHECK(p.text_backend() == nullptr); + PLOT_CHECK(l.legend.empty()); + PLOT_CHECK_NEAR(l.legend.panel.w, 0.0f, 1e-6); + PLOT_CHECK_NEAR(l.legend.panel.h, 0.0f, 1e-6); + // Nothing else moved either: the strips are the no-backend defaults, not metrics a + // legend could not measure. + PLOT_CHECK_NEAR(l.y_axis_width, 56.0f, 1e-6); + PLOT_CHECK_NEAR(l.x_axis_height, 22.0f, 1e-6); +} + +/// Switching the legend off is not the same as the plot having nothing to list: the +/// entries exist, the layout is empty, and -- the reason it matters -- the axes rect +/// is *identical*, because a legend is drawn inside the data area and reserves none +/// of it. A legend that changed `axes` would rescale every plot the moment a trace +/// was named. +PLOT_TEST(legend_hidden_by_visible_false_draws_nothing) { + LegendScene scene; + const plot::Rect shown_axes = scene.plot.layout().axes; + PLOT_CHECK(!scene.plot.layout().legend.empty()); + + plot::Legend cfg = scene.plot.legend(); + cfg.visible = false; + scene.plot.set_legend(cfg); + const plot::PlotLayout& l = scene.plot.layout(); + PLOT_CHECK(l.legend.empty()); + PLOT_CHECK_NEAR(l.legend.panel.w, 0.0f, 1e-6); + PLOT_CHECK_NEAR(l.legend.panel.h, 0.0f, 1e-6); + PLOT_CHECK_NEAR(l.axes.x, shown_axes.x, 1e-6); + PLOT_CHECK_NEAR(l.axes.y, shown_axes.y, 1e-6); + PLOT_CHECK_NEAR(l.axes.w, shown_axes.w, 1e-6); + PLOT_CHECK_NEAR(l.axes.h, shown_axes.h, 1e-6); + + // ... and switching it back on lists the same three entries again. + cfg.visible = true; + scene.plot.set_legend(cfg); + PLOT_CHECK(scene.plot.layout().legend.rows.size() == 3u); +} diff --git a/tests/test_render_smoke.cpp b/tests/test_render_smoke.cpp index 73348d9..89464c8 100644 --- a/tests/test_render_smoke.cpp +++ b/tests/test_render_smoke.cpp @@ -2188,3 +2188,228 @@ PLOT_TEST(text_atlas_reports_a_status_when_the_entry_points_are_missing) { PLOT_CHECK(plot::gl::glGetError() == plot::gl::GL_NO_ERROR); ctx.destroy(); } + +/// The legend's two cases need a count, not a presence: "the swatch colour appears" +/// is satisfied by the trace that carries the same colour, and "some ink is in the +/// panel" is satisfied by any label the frame happens to put there. Counting the +/// pixels of an area that are exactly `c` (see `pixel_is`) is what turns both into +/// statements about the swatch. +plot::u32 exact_pixels(const std::vector& frame, plot::u32 fb_w, const plot::Rect& area, + plot::Color c) { + plot::u32 count = 0; + for (plot::u32 y = static_cast(area.y); + y < static_cast(area.bottom()); ++y) { + for (plot::u32 x = static_cast(area.x); + x < static_cast(area.right()); ++x) { + if (pixel_is(&frame[(plot::usize(y) * fb_w + x) * 4u], c)) ++count; + } + } + return count; +} + +/// The whole framebuffer as a Rect, for the counts that ask "and nowhere else". +const plot::Rect kFrameRect{0.0f, 0.0f, static_cast(kW), static_cast(kH)}; + +/// The legend's entries are drawn where `Plot::layout()` measured them: a filled +/// swatch per trace in that trace's own colour, and the name's ink inside the panel +/// and nowhere else in the data area -- and the panel's presence changes nothing +/// outside itself. +/// +/// The swatch colour is what makes the count a test. Both traces here are translucent +/// (alpha 0.25), while the swatch is drawn opaque, so the exact colour of a trace is +/// one that only a swatch can produce: the trace blended over the background -- or +/// over a grid line, which is brighter -- never reaches it, and neither do the grid, +/// the axis line or the text. Two colours are used so each entry's swatch has to be +/// its own trace's, not whichever colour the legend drew for everything. +PLOT_TEST(legend_swatch_and_label_are_drawn) { + plottest::HeadlessContext ctx(kW, kH); + plot::Status st; + PLOT_CHECK(ctx.create(&st)); + PLOT_CHECK(plot::gl::load(nullptr)); + plot::Renderer r; + PLOT_CHECK(r.init(&st)); + + plot::data::ArraySeries s(sine_samples(), 0.0, 1.0); + // The second trace is a series of its own, well clear of the first: two + // translucent strokes stacked over a grid line reach a brightness the `axis_text` + // ink predicate below cannot tell from a label, and the "no name ink in the data + // area" half of this case has to be about the legend's ink only. + plot::data::ArraySeries flat(std::vector(64u, 0.75f), 0.0, 1.0); + plot::Plot p; + p.set_viewport({0, 0, static_cast(kW), static_cast(kH)}); + const plot::u32 ax = p.add_x_axis({"t", s.x_bounds(), true, plot::AxisPlace::Bottom, false}); + const plot::u32 ay = p.add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false}); + const plot::Color green = plot::Color::hex(0x00E070, 0.25f); + const plot::Color pink = plot::Color::hex(0xFF3CC8, 0.25f); + PLOT_CHECK(p.add_trace({&s, green, 1.5f, ax, ay, "signal"}) == 0u); + PLOT_CHECK(p.add_trace({&flat, pink, 1.5f, ax, ay, "noise"}) == 1u); + p.set_x_range(ax, {0.0, 640.0}); // one sample per pixel: a flat, cheap frame + + r.begin_frame(kW, kH, {0, 0, static_cast(kW), static_cast(kH)}); + r.draw(p); + r.end_frame(); + PLOT_CHECK(!r.last_frame_had_gl_error()); + dump_if_requested(r, "legend.ppm"); + + // A copy: the second draw below clears the rows this layout holds. + const plot::PlotLayout layout = p.layout(); + const plot::LegendLayout legend = layout.legend; + PLOT_CHECK(legend.rows.size() == 2u); + const plot::Legend& cfg = p.legend(); + const plot::u32 swatch_area = static_cast(cfg.swatch_w) * + static_cast(cfg.swatch_h); + + const std::vector frame = read_frame(ctx); + + // Each swatch: its own row's swatch box holds the pixels, and every pixel of that + // colour in the whole frame is one of them. The lower bound is the box's area + // minus the fringe a 1 px stroke column cannot promise -- a row and a column at + // each edge -- and the upper bound lets the outermost columns and rows count + // where the fill's edge lands a hair inside them. + const plot::Color opaque[2] = {plot::Color{green.r, green.g, green.b, 1.0f}, + plot::Color{pink.r, pink.g, pink.b, 1.0f}}; + for (plot::u32 i = 0; i < legend.rows.size(); ++i) { + const plot::Rect& box = legend.rows[i].swatch; + PLOT_CHECK(box.w > 0.0f && box.h > 0.0f); + PLOT_CHECK(box.x >= legend.panel.x && box.right() <= legend.panel.right()); + PLOT_CHECK(box.y >= legend.panel.y && box.bottom() <= legend.panel.bottom()); + // The row names its own trace, so the colour under the predicate is that + // trace's -- which is what `LegendRow::trace` is for. + PLOT_CHECK_NEAR(p.trace(legend.rows[i].trace).color.r, opaque[i].r, 1e-6); + const plot::u32 inside = exact_pixels(frame, kW, box, opaque[i]); + const plot::u32 anywhere = exact_pixels(frame, kW, kFrameRect, opaque[i]); + const plot::u32 in_panel = exact_pixels(frame, kW, legend.panel, opaque[i]); + // The swatch's colour fills the swatch's box -- within the row and column an + // edge's coverage ramp can reach past it -- and appears nowhere else in the + // frame: not over the trace that carries the same colour at 25%, not in the + // grid, and not outside the panel, which is where this ink's whole budget is. + PLOT_CHECK(inside >= swatch_area - 2u * static_cast(cfg.swatch_w) - + 2u * static_cast(cfg.swatch_h)); + PLOT_CHECK(anywhere <= swatch_area + 2u * static_cast(cfg.swatch_w) + + 2u * static_cast(cfg.swatch_h)); + PLOT_CHECK(anywhere == in_panel); + // The numbers behind those assertions, so a run says what it measured rather than + // only that it passed. + std::printf("[legend] row %u trace %u swatch %.2f,%.2f %.2fx%.2f: %u pixels of its colour, " + "%u in the frame\n", + i, legend.rows[i].trace, box.x, box.y, box.w, box.h, inside, anywhere); + } + + // The names: real glyph ink inside the panel, and none in the data area outside it. + // This plot has no cursor, no measurement and no annotation, and every other + // `axis_text` run -- the tick labels, the titles -- is drawn in a strip outside + // `axes`, so the only ink in the data area is the legend's. + const plot::Color ink = r.style().axis_text; + const plot::u32 in_panel = scan_rect_ink(ctx, legend.panel, ink).pixels; + // The data area, inset past the axis lines: they run along the axes' edges and are + // brighter than a third of `axis_text` -- the trap `rect_has_exact` exists for -- so + // an un-inset scan would be counting the axis rather than a label. + const plot::Rect data{layout.axes.x + 2.0f, layout.axes.y + 2.0f, layout.axes.w - 4.0f, + layout.axes.h - 4.0f}; + const plot::u32 in_data = scan_rect_ink(ctx, data, ink).pixels; + PLOT_CHECK(in_panel >= 32u); // two names, not one stray anti-aliased pixel + PLOT_CHECK(in_data == in_panel); // and every bit of that ink is the legend's + // The numbers behind those assertions, so a run says what it measured rather than + // only that it passed. + std::printf("[legend] panel %.2f,%.2f %.2fx%.2f, %zu rows; name ink %u in the panel, %u in the " + "data area\n", + legend.panel.x, legend.panel.y, legend.panel.w, legend.panel.h, legend.rows.size(), + in_panel, in_data); + + // The panel changes nothing outside itself: the same plot drawn with the legend + // switched off -- same traces, same axes rect, same transforms, since a legend + // reserves none of the plot -- must come out pixel-identical everywhere except + // inside the panel. One pixel of slack on each side, because a fill's stroke + // column lets its fringe reach a pixel past the panel's edge. + plot::Legend off = cfg; + off.visible = false; + p.set_legend(off); + r.begin_frame(kW, kH, {0, 0, static_cast(kW), static_cast(kH)}); + r.draw(p); + r.end_frame(); + PLOT_CHECK(!r.last_frame_had_gl_error()); + const std::vector bare = read_frame(ctx); + const plot::Rect changed{legend.panel.x - 1.0f, legend.panel.y - 1.0f, legend.panel.w + 2.0f, + legend.panel.h + 2.0f}; + PLOT_CHECK(changed.x >= layout.axes.x && changed.right() <= layout.axes.right()); + PLOT_CHECK(changed.bottom() <= layout.axes.bottom()); // so "inside changed" is inside axes + plot::u32 differing = 0; + for (plot::u32 y = 0; y < ctx.height; ++y) { + for (plot::u32 x = 0; x < ctx.width; ++x) { + const plot::usize at = (plot::usize(y) * kW + x) * 4u; + if (frame[at] == bare[at] && frame[at + 1u] == bare[at + 1u] && + frame[at + 2u] == bare[at + 2u] && frame[at + 3u] == bare[at + 3u]) { + continue; + } + ++differing; + PLOT_CHECK(changed.contains(static_cast(x) + 0.5f, + static_cast(y) + 0.5f)); + } + } + // The comparison is only evidence if the legend was in the first frame at all. + PLOT_CHECK(differing > 0u); + ctx.destroy(); +} + +/// The bottom-left corner is the one a legend anchored from the axes' *opposite* +/// corner would miss: the panel has to be down there, inside `axes` and held off the +/// two edges that corner is near, with its swatch in the panel and nowhere else -- +/// including not in the strip below the axes, where the tick labels live. +PLOT_TEST(legend_does_not_cover_the_plot_when_placed_bottom_left) { + plottest::HeadlessContext ctx(kW, kH); + plot::Status st; + PLOT_CHECK(ctx.create(&st)); + PLOT_CHECK(plot::gl::load(nullptr)); + plot::Renderer r; + PLOT_CHECK(r.init(&st)); + + plot::data::ArraySeries s(sine_samples(), 0.0, 1.0); + plot::Plot p; + p.set_viewport({0, 0, static_cast(kW), static_cast(kH)}); + const plot::u32 ax = p.add_x_axis({"t", s.x_bounds(), true, plot::AxisPlace::Bottom, false}); + const plot::u32 ay = p.add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false}); + // Translucent, as in the case above: the swatch is drawn opaque, so this colour is + // the swatch's alone. + const plot::Color teal = plot::Color::hex(0x00E070, 0.25f); + p.add_trace({&s, teal, 1.5f, ax, ay, "signal"}); + p.set_x_range(ax, {0.0, 640.0}); + plot::Legend cfg = p.legend(); + cfg.place = plot::LegendPlace::BottomLeft; + p.set_legend(cfg); + + r.begin_frame(kW, kH, {0, 0, static_cast(kW), static_cast(kH)}); + r.draw(p); + r.end_frame(); + PLOT_CHECK(!r.last_frame_had_gl_error()); + dump_if_requested(r, "legend_bottom_left.ppm"); + + const plot::PlotLayout layout = p.layout(); + const plot::LegendLayout& legend = layout.legend; + PLOT_CHECK(legend.rows.size() == 1u); + const plot::Rect& panel = legend.panel; + PLOT_CHECK_NEAR(panel.x, layout.axes.x + cfg.margin, 1e-4); + PLOT_CHECK_NEAR(panel.bottom(), layout.axes.bottom() - cfg.margin, 1e-4); + PLOT_CHECK(panel.right() <= layout.axes.right()); + PLOT_CHECK(panel.bottom() <= layout.axes.bottom()); + + const std::vector frame = read_frame(ctx); + const plot::Color opaque{teal.r, teal.g, teal.b, 1.0f}; + const plot::u32 in_panel = exact_pixels(frame, kW, panel, opaque); + PLOT_CHECK(in_panel >= static_cast(cfg.swatch_w - 2.0f) * + static_cast(cfg.swatch_h - 2.0f)); + // Every pixel of the swatch colour is inside the panel: none in the x label strip + // below the axes, none in the y strip, none anywhere else in the frame. + PLOT_CHECK(exact_pixels(frame, kW, kFrameRect, opaque) == in_panel); + const plot::Rect below{0.0f, layout.axes.bottom(), static_cast(kW), + static_cast(kH) - layout.axes.bottom()}; + PLOT_CHECK(exact_pixels(frame, kW, below, opaque) == 0u); + // ... with the name drawn beside it. + const plot::u32 name_ink = scan_rect_ink(ctx, panel, r.style().axis_text).pixels; + PLOT_CHECK(name_ink >= 16u); + std::printf("[legend] bottom-left panel %.2f,%.2f %.2fx%.2f; swatch %u pixels in the panel, %u " + "in the frame, %u below the axes; name ink %u\n", + panel.x, panel.y, panel.w, panel.h, in_panel, + exact_pixels(frame, kW, kFrameRect, opaque), exact_pixels(frame, kW, below, opaque), + name_ink); + ctx.destroy(); +}