661 lines
26 KiB
Zig
661 lines
26 KiB
Zig
//! Projection chart renderer using z2d.
|
|
//! Renders percentile bands (p10-p90, p25-p75) with a median line to raw RGB
|
|
//! pixel data suitable for Kitty graphics protocol transmission.
|
|
//!
|
|
//! Visual layers (bottom to top):
|
|
//! - Background
|
|
//! - Horizontal grid lines
|
|
//! - "Today" vertical reference line (when overlay is active)
|
|
//! - p10-p90 band fill (faint)
|
|
//! - p25-p75 band fill (medium)
|
|
//! - p10/p90 boundary lines
|
|
//! - Median (p50) line (solid)
|
|
//! - Zero line (if visible)
|
|
//! - Actuals overlay line (when present)
|
|
//! - Panel border
|
|
|
|
const std = @import("std");
|
|
const z2d = @import("z2d");
|
|
const theme = @import("theme.zig");
|
|
const projections = @import("../analytics/projections.zig");
|
|
|
|
const Surface = z2d.Surface;
|
|
const Context = z2d.Context;
|
|
const Pixel = z2d.Pixel;
|
|
|
|
/// Margins in pixels.
|
|
const margin_left: f64 = 4;
|
|
const margin_right: f64 = 4;
|
|
const margin_top: f64 = 4;
|
|
const margin_bottom: f64 = 4;
|
|
|
|
/// Single (year-offset, liquid-value) point on the actuals overlay.
|
|
/// Mirrors `views/projections.ActualsPoint` but kept duplicated here
|
|
/// so the chart module doesn't depend on the views layer.
|
|
pub const ActualsPoint = struct {
|
|
years_from_as_of: f64,
|
|
liquid: f64,
|
|
};
|
|
|
|
/// Optional actuals-overlay input. When non-null, the chart draws:
|
|
/// - A thin vertical "today" reference line at `today_years`.
|
|
/// - A connected line through `points` (cyan), wider than 1px so
|
|
/// it reads against the bands.
|
|
/// Y-range is expanded to include any actuals values that exceed
|
|
/// the band envelope, so the line never clips off-chart.
|
|
pub const ActualsOverlay = struct {
|
|
points: []const ActualsPoint,
|
|
today_years: f64,
|
|
};
|
|
|
|
/// Projection chart render result.
|
|
pub const ProjectionChartResult = struct {
|
|
/// Raw RGB pixel data (3 bytes per pixel, row-major).
|
|
rgb_data: []const u8,
|
|
width: u16,
|
|
height: u16,
|
|
/// Value range for external label rendering.
|
|
value_min: f64,
|
|
value_max: f64,
|
|
};
|
|
|
|
/// Owned by the caller — call `result.deinit(alloc)` after using it.
|
|
/// Used as the shared mid-stage between RGB extraction (kitty) and
|
|
/// PNG export (`--export-chart`). See `renderToSurface`.
|
|
pub const RenderedProjection = struct {
|
|
surface: Surface,
|
|
width: u16,
|
|
height: u16,
|
|
value_min: f64,
|
|
value_max: f64,
|
|
|
|
pub fn deinit(self: *RenderedProjection, alloc: std.mem.Allocator) void {
|
|
self.surface.deinit(alloc);
|
|
self.* = undefined;
|
|
}
|
|
|
|
/// Extract a flat []u8 of R,G,B triplets from the surface buffer.
|
|
/// Caller owns the returned slice. The surface is left intact.
|
|
pub fn extractRgb(self: *const RenderedProjection, alloc: std.mem.Allocator) ![]u8 {
|
|
const rgb_buf = switch (self.surface) {
|
|
.image_surface_rgb => |s| s.buf,
|
|
else => unreachable,
|
|
};
|
|
const raw = try alloc.alloc(u8, rgb_buf.len * 3);
|
|
for (rgb_buf, 0..) |px, i| {
|
|
raw[i * 3 + 0] = px.r;
|
|
raw[i * 3 + 1] = px.g;
|
|
raw[i * 3 + 2] = px.b;
|
|
}
|
|
return raw;
|
|
}
|
|
};
|
|
|
|
/// Render a projection percentile band chart into a `Surface` and
|
|
/// return both. Caller owns the result and must call `deinit`.
|
|
///
|
|
/// Two consumers today:
|
|
/// - `renderProjectionChart` wraps this for the TUI's kitty
|
|
/// graphics path (extracts RGB, frees surface).
|
|
/// - `--export-chart` (CLI) wraps this for PNG export via
|
|
/// `z2d.png_exporter.writeToPNGFile`.
|
|
pub fn renderToSurface(
|
|
io: std.Io,
|
|
alloc: std.mem.Allocator,
|
|
bands: []const projections.YearPercentiles,
|
|
width_px: u32,
|
|
height_px: u32,
|
|
th: theme.Theme,
|
|
actuals: ?ActualsOverlay,
|
|
) !RenderedProjection {
|
|
if (bands.len < 2) return error.InsufficientData;
|
|
|
|
const w: i32 = @intCast(width_px);
|
|
const h: i32 = @intCast(height_px);
|
|
var sfc = try Surface.init(.image_surface_rgb, alloc, w, h);
|
|
errdefer sfc.deinit(alloc);
|
|
|
|
var ctx = Context.init(io, alloc, &sfc);
|
|
defer ctx.deinit();
|
|
|
|
ctx.setAntiAliasingMode(.none);
|
|
ctx.setOperator(.src);
|
|
|
|
const bg = th.bg;
|
|
const fwidth: f64 = @floatFromInt(width_px);
|
|
const fheight: f64 = @floatFromInt(height_px);
|
|
|
|
// Background
|
|
ctx.setSourceToPixel(opaqueColor(bg));
|
|
ctx.resetPath();
|
|
try ctx.moveTo(0, 0);
|
|
try ctx.lineTo(fwidth, 0);
|
|
try ctx.lineTo(fwidth, fheight);
|
|
try ctx.lineTo(0, fheight);
|
|
try ctx.closePath();
|
|
try ctx.fill();
|
|
|
|
// Chart area
|
|
const chart_left = margin_left;
|
|
const chart_right = fwidth - margin_right;
|
|
const chart_w = chart_right - chart_left;
|
|
const chart_top = margin_top;
|
|
const chart_bottom = fheight - margin_bottom;
|
|
|
|
// Compute value range from all bands
|
|
var value_min: f64 = bands[0].p10;
|
|
var value_max: f64 = bands[0].p90;
|
|
for (bands) |bp| {
|
|
if (bp.p10 < value_min) value_min = bp.p10;
|
|
if (bp.p90 > value_max) value_max = bp.p90;
|
|
}
|
|
// Expand to include any actuals that punch through the band
|
|
// envelope. Without this, a portfolio that out- or under-performed
|
|
// the model would clip off-chart.
|
|
if (actuals) |ov| {
|
|
for (ov.points) |p| {
|
|
if (p.liquid < value_min) value_min = p.liquid;
|
|
if (p.liquid > value_max) value_max = p.liquid;
|
|
}
|
|
}
|
|
// Add 5% padding
|
|
const pad = (value_max - value_min) * 0.05;
|
|
value_min -= pad;
|
|
value_max += pad;
|
|
if (value_min < 0) value_min = 0;
|
|
|
|
// X step (one point per year)
|
|
const x_step = chart_w / @as(f64, @floatFromInt(bands.len - 1));
|
|
|
|
// ── Grid lines ───────────────────────────────────────────────
|
|
const grid_color = blendColor(th.text_muted, 40, bg);
|
|
try drawHorizontalGridLines(&ctx, chart_left, chart_right, chart_top, chart_bottom, 5, grid_color);
|
|
|
|
// ── "Today" vertical reference line (overlay only) ───────────
|
|
//
|
|
// When the actuals overlay is active, draw a thin vertical line
|
|
// at `today_years` along the x-axis. This visually separates the
|
|
// realized past (left of the line) from the projected future
|
|
// (right of the line). Drawn before bands so it sits behind the
|
|
// data — a quiet reference, not a focal point.
|
|
if (actuals) |ov| {
|
|
const horizon_years: f64 = @floatFromInt(bands.len - 1);
|
|
if (horizon_years > 0 and ov.today_years >= 0 and ov.today_years <= horizon_years) {
|
|
const today_x = chart_left + (ov.today_years / horizon_years) * chart_w;
|
|
const today_color = blendColor(th.text_muted, 100, bg);
|
|
try drawVLine(&ctx, today_x, chart_top, chart_bottom, today_color, 1.0);
|
|
}
|
|
}
|
|
|
|
// ── p10-p90 outer band fill ──────────────────────────────────
|
|
{
|
|
const band_color = blendColor(th.accent, 20, bg);
|
|
ctx.setSourceToPixel(band_color);
|
|
ctx.resetPath();
|
|
|
|
// Forward along p90 (upper)
|
|
for (bands, 0..) |bp, i| {
|
|
const x = chart_left + @as(f64, @floatFromInt(i)) * x_step;
|
|
const y = mapY(bp.p90, value_min, value_max, chart_top, chart_bottom);
|
|
if (i == 0) try ctx.moveTo(x, y) else try ctx.lineTo(x, y);
|
|
}
|
|
// Backward along p10 (lower)
|
|
var i: usize = bands.len;
|
|
while (i > 0) {
|
|
i -= 1;
|
|
const x = chart_left + @as(f64, @floatFromInt(i)) * x_step;
|
|
const y = mapY(bands[i].p10, value_min, value_max, chart_top, chart_bottom);
|
|
try ctx.lineTo(x, y);
|
|
}
|
|
try ctx.closePath();
|
|
try ctx.fill();
|
|
}
|
|
|
|
// ── p25-p75 inner band fill ──────────────────────────────────
|
|
{
|
|
const band_color = blendColor(th.accent, 40, bg);
|
|
ctx.setSourceToPixel(band_color);
|
|
ctx.resetPath();
|
|
|
|
// Forward along p75 (upper)
|
|
for (bands, 0..) |bp, i| {
|
|
const x = chart_left + @as(f64, @floatFromInt(i)) * x_step;
|
|
const y = mapY(bp.p75, value_min, value_max, chart_top, chart_bottom);
|
|
if (i == 0) try ctx.moveTo(x, y) else try ctx.lineTo(x, y);
|
|
}
|
|
// Backward along p25 (lower)
|
|
var i: usize = bands.len;
|
|
while (i > 0) {
|
|
i -= 1;
|
|
const x = chart_left + @as(f64, @floatFromInt(i)) * x_step;
|
|
const y = mapY(bands[i].p25, value_min, value_max, chart_top, chart_bottom);
|
|
try ctx.lineTo(x, y);
|
|
}
|
|
try ctx.closePath();
|
|
try ctx.fill();
|
|
}
|
|
|
|
// ── Median (p50) line ────────────────────────────────────────
|
|
{
|
|
const line_color = opaqueColor(th.accent);
|
|
ctx.setSourceToPixel(line_color);
|
|
ctx.setLineWidth(2.0);
|
|
ctx.resetPath();
|
|
for (bands, 0..) |bp, i| {
|
|
const x = chart_left + @as(f64, @floatFromInt(i)) * x_step;
|
|
const y = mapY(bp.p50, value_min, value_max, chart_top, chart_bottom);
|
|
if (i == 0) try ctx.moveTo(x, y) else try ctx.lineTo(x, y);
|
|
}
|
|
try ctx.stroke();
|
|
}
|
|
|
|
// ── p10 and p90 boundary lines (thin, muted) ─────────────────
|
|
{
|
|
const line_color = blendColor(th.text_muted, 80, bg);
|
|
ctx.setSourceToPixel(line_color);
|
|
ctx.setLineWidth(1.0);
|
|
ctx.resetPath();
|
|
for (bands, 0..) |bp, i| {
|
|
const x = chart_left + @as(f64, @floatFromInt(i)) * x_step;
|
|
const y = mapY(bp.p90, value_min, value_max, chart_top, chart_bottom);
|
|
if (i == 0) try ctx.moveTo(x, y) else try ctx.lineTo(x, y);
|
|
}
|
|
try ctx.stroke();
|
|
|
|
ctx.resetPath();
|
|
for (bands, 0..) |bp, i| {
|
|
const x = chart_left + @as(f64, @floatFromInt(i)) * x_step;
|
|
const y = mapY(bp.p10, value_min, value_max, chart_top, chart_bottom);
|
|
if (i == 0) try ctx.moveTo(x, y) else try ctx.lineTo(x, y);
|
|
}
|
|
try ctx.stroke();
|
|
}
|
|
|
|
// ── Zero line (if visible) ───────────────────────────────────
|
|
if (value_min <= 0 and value_max > 0) {
|
|
const zero_y = mapY(0, value_min, value_max, chart_top, chart_bottom);
|
|
const zero_color = blendColor(th.negative, 120, bg);
|
|
try drawHLine(&ctx, chart_left, chart_right, zero_y, zero_color, 1.0);
|
|
}
|
|
|
|
// ── Actuals overlay line ─────────────────────────────────────
|
|
//
|
|
// Drawn after all band-related layers (and the zero line) so the
|
|
// realized trajectory sits on top of the projection envelope.
|
|
// Cyan (`th.info`) keeps it visually distinct from the purple
|
|
// band/median palette. Slightly thinner than the median (1.5 vs
|
|
// 2.0) so the median stays the anchor of the projection.
|
|
if (actuals) |ov| {
|
|
if (ov.points.len >= 2) {
|
|
const horizon_years: f64 = @floatFromInt(bands.len - 1);
|
|
const line_color = opaqueColor(th.info);
|
|
ctx.setSourceToPixel(line_color);
|
|
ctx.setLineWidth(1.5);
|
|
ctx.resetPath();
|
|
for (ov.points, 0..) |p, i| {
|
|
// Clamp to chart bounds — overlay points should
|
|
// always be in [0, today_years] which is <= horizon,
|
|
// but defending against bad input is cheap.
|
|
const yr = if (horizon_years > 0)
|
|
@max(0.0, @min(p.years_from_as_of, horizon_years))
|
|
else
|
|
0.0;
|
|
const x = chart_left + if (horizon_years > 0)
|
|
(yr / horizon_years) * chart_w
|
|
else
|
|
0.0;
|
|
const y = mapY(p.liquid, value_min, value_max, chart_top, chart_bottom);
|
|
if (i == 0) try ctx.moveTo(x, y) else try ctx.lineTo(x, y);
|
|
}
|
|
try ctx.stroke();
|
|
}
|
|
}
|
|
|
|
// ── Panel border ─────────────────────────────────────────────
|
|
{
|
|
const border_color = blendColor(th.border, 80, bg);
|
|
try drawRect(&ctx, chart_left, chart_top, chart_right, chart_bottom, border_color, 1.0);
|
|
}
|
|
|
|
return .{
|
|
.surface = sfc,
|
|
.width = @intCast(width_px),
|
|
.height = @intCast(height_px),
|
|
.value_min = value_min,
|
|
.value_max = value_max,
|
|
};
|
|
}
|
|
|
|
/// Render a projection percentile band chart to raw RGB pixel data.
|
|
/// Draws p10-p90 outer band, p25-p75 inner band, and p50 median line.
|
|
///
|
|
/// `bands` is the array of YearPercentiles (year 0 through horizon).
|
|
/// `actuals` is an optional realized-trajectory overlay.
|
|
/// The returned rgb_data is allocated with `alloc` and must be freed by caller.
|
|
pub fn renderProjectionChart(
|
|
io: std.Io,
|
|
alloc: std.mem.Allocator,
|
|
bands: []const projections.YearPercentiles,
|
|
width_px: u32,
|
|
height_px: u32,
|
|
th: theme.Theme,
|
|
actuals: ?ActualsOverlay,
|
|
) !ProjectionChartResult {
|
|
var rendered = try renderToSurface(io, alloc, bands, width_px, height_px, th, actuals);
|
|
defer rendered.deinit(alloc);
|
|
const raw = try rendered.extractRgb(alloc);
|
|
return .{
|
|
.rgb_data = raw,
|
|
.width = rendered.width,
|
|
.height = rendered.height,
|
|
.value_min = rendered.value_min,
|
|
.value_max = rendered.value_max,
|
|
};
|
|
}
|
|
|
|
// ── Drawing helpers ───────────────────────────────────────────────────
|
|
|
|
fn mapY(value: f64, min_val: f64, max_val: f64, top_px: f64, bottom_px: f64) f64 {
|
|
if (max_val == min_val) return (top_px + bottom_px) / 2;
|
|
const norm = (value - min_val) / (max_val - min_val);
|
|
return bottom_px - norm * (bottom_px - top_px);
|
|
}
|
|
|
|
fn blendColor(fg: [3]u8, alpha: u8, bg_color: [3]u8) Pixel {
|
|
const a = @as(f64, @floatFromInt(alpha)) / 255.0;
|
|
const inv_a = 1.0 - a;
|
|
return .{ .rgb = .{
|
|
.r = @intFromFloat(@as(f64, @floatFromInt(fg[0])) * a + @as(f64, @floatFromInt(bg_color[0])) * inv_a),
|
|
.g = @intFromFloat(@as(f64, @floatFromInt(fg[1])) * a + @as(f64, @floatFromInt(bg_color[1])) * inv_a),
|
|
.b = @intFromFloat(@as(f64, @floatFromInt(fg[2])) * a + @as(f64, @floatFromInt(bg_color[2])) * inv_a),
|
|
} };
|
|
}
|
|
|
|
fn opaqueColor(c: [3]u8) Pixel {
|
|
return .{ .rgb = .{ .r = c[0], .g = c[1], .b = c[2] } };
|
|
}
|
|
|
|
fn drawHorizontalGridLines(
|
|
ctx: *Context,
|
|
left: f64,
|
|
right: f64,
|
|
top: f64,
|
|
bottom: f64,
|
|
n_lines: usize,
|
|
col: Pixel,
|
|
) !void {
|
|
ctx.setSourceToPixel(col);
|
|
ctx.setLineWidth(0.5);
|
|
for (1..n_lines) |i| {
|
|
const frac = @as(f64, @floatFromInt(i)) / @as(f64, @floatFromInt(n_lines));
|
|
const y = top + frac * (bottom - top);
|
|
ctx.resetPath();
|
|
try ctx.moveTo(left, y);
|
|
try ctx.lineTo(right, y);
|
|
try ctx.stroke();
|
|
}
|
|
ctx.setLineWidth(2.0);
|
|
}
|
|
|
|
fn drawHLine(ctx: *Context, x1: f64, x2: f64, y: f64, col: Pixel, line_w: f64) !void {
|
|
ctx.setSourceToPixel(col);
|
|
ctx.setLineWidth(line_w);
|
|
ctx.resetPath();
|
|
try ctx.moveTo(x1, y);
|
|
try ctx.lineTo(x2, y);
|
|
try ctx.stroke();
|
|
ctx.setLineWidth(2.0);
|
|
}
|
|
|
|
fn drawVLine(ctx: *Context, x: f64, y1: f64, y2: f64, col: Pixel, line_w: f64) !void {
|
|
ctx.setSourceToPixel(col);
|
|
ctx.setLineWidth(line_w);
|
|
ctx.resetPath();
|
|
try ctx.moveTo(x, y1);
|
|
try ctx.lineTo(x, y2);
|
|
try ctx.stroke();
|
|
ctx.setLineWidth(2.0);
|
|
}
|
|
|
|
fn drawRect(ctx: *Context, x1: f64, y1: f64, x2: f64, y2: f64, col: Pixel, line_w: f64) !void {
|
|
ctx.setSourceToPixel(col);
|
|
ctx.setLineWidth(line_w);
|
|
ctx.resetPath();
|
|
try ctx.moveTo(x1, y1);
|
|
try ctx.lineTo(x2, y1);
|
|
try ctx.lineTo(x2, y2);
|
|
try ctx.lineTo(x1, y2);
|
|
try ctx.closePath();
|
|
try ctx.stroke();
|
|
ctx.setLineWidth(2.0);
|
|
}
|
|
|
|
// ── Tests ─────────────────────────────────────────────────────────────
|
|
|
|
test "mapY maps value to pixel coordinate" {
|
|
try std.testing.expectEqual(@as(f64, 500.0), mapY(0, 0, 100, 100, 500));
|
|
try std.testing.expectEqual(@as(f64, 100.0), mapY(100, 0, 100, 100, 500));
|
|
try std.testing.expectEqual(@as(f64, 300.0), mapY(50, 0, 100, 100, 500));
|
|
try std.testing.expectEqual(@as(f64, 300.0), mapY(42, 42, 42, 100, 500));
|
|
}
|
|
|
|
test "blendColor alpha blending" {
|
|
const white = [3]u8{ 255, 255, 255 };
|
|
const black = [3]u8{ 0, 0, 0 };
|
|
|
|
const full = blendColor(white, 255, black);
|
|
try std.testing.expectEqual(@as(u8, 255), full.rgb.r);
|
|
|
|
const zero = blendColor(white, 0, black);
|
|
try std.testing.expectEqual(@as(u8, 0), zero.rgb.r);
|
|
|
|
const half = blendColor(white, 128, black);
|
|
try std.testing.expect(half.rgb.r >= 127 and half.rgb.r <= 129);
|
|
}
|
|
|
|
test "renderProjectionChart produces valid output" {
|
|
const alloc = std.testing.allocator;
|
|
const bands = [_]projections.YearPercentiles{
|
|
.{ .year = 0, .p10 = 8000000, .p25 = 8000000, .p50 = 8000000, .p75 = 8000000, .p90 = 8000000 },
|
|
.{ .year = 10, .p10 = 5000000, .p25 = 8000000, .p50 = 12000000, .p75 = 18000000, .p90 = 25000000 },
|
|
.{ .year = 20, .p10 = 3000000, .p25 = 9000000, .p50 = 18000000, .p75 = 30000000, .p90 = 50000000 },
|
|
};
|
|
|
|
const th = @import("theme.zig").default_theme;
|
|
const result = try renderProjectionChart(std.testing.io, alloc, &bands, 200, 100, th, null);
|
|
defer alloc.free(result.rgb_data);
|
|
|
|
try std.testing.expectEqual(@as(u16, 200), result.width);
|
|
try std.testing.expectEqual(@as(u16, 100), result.height);
|
|
try std.testing.expectEqual(@as(usize, 200 * 100 * 3), result.rgb_data.len);
|
|
try std.testing.expect(result.value_max > result.value_min);
|
|
}
|
|
|
|
test "renderProjectionChart insufficient data" {
|
|
const alloc = std.testing.allocator;
|
|
const bands = [_]projections.YearPercentiles{
|
|
.{ .year = 0, .p10 = 8000000, .p25 = 8000000, .p50 = 8000000, .p75 = 8000000, .p90 = 8000000 },
|
|
};
|
|
|
|
const th = @import("theme.zig").default_theme;
|
|
const result = renderProjectionChart(std.testing.io, alloc, &bands, 200, 100, th, null);
|
|
try std.testing.expectError(error.InsufficientData, result);
|
|
}
|
|
|
|
test "renderProjectionChart with overlay produces valid output" {
|
|
const alloc = std.testing.allocator;
|
|
const bands = [_]projections.YearPercentiles{
|
|
.{ .year = 0, .p10 = 8000000, .p25 = 8000000, .p50 = 8000000, .p75 = 8000000, .p90 = 8000000 },
|
|
.{ .year = 10, .p10 = 5000000, .p25 = 8000000, .p50 = 12000000, .p75 = 18000000, .p90 = 25000000 },
|
|
.{ .year = 20, .p10 = 3000000, .p25 = 9000000, .p50 = 18000000, .p75 = 30000000, .p90 = 50000000 },
|
|
};
|
|
const points = [_]ActualsPoint{
|
|
.{ .years_from_as_of = 0.0, .liquid = 8000000 },
|
|
.{ .years_from_as_of = 0.5, .liquid = 8500000 },
|
|
.{ .years_from_as_of = 1.0, .liquid = 9200000 },
|
|
};
|
|
const overlay: ActualsOverlay = .{ .points = &points, .today_years = 1.0 };
|
|
|
|
const th = @import("theme.zig").default_theme;
|
|
const result = try renderProjectionChart(std.testing.io, alloc, &bands, 200, 100, th, overlay);
|
|
defer alloc.free(result.rgb_data);
|
|
|
|
try std.testing.expectEqual(@as(u16, 200), result.width);
|
|
try std.testing.expectEqual(@as(u16, 100), result.height);
|
|
try std.testing.expect(result.value_max > result.value_min);
|
|
}
|
|
|
|
test "renderProjectionChart overlay expands y-range when actuals exceed bands" {
|
|
const alloc = std.testing.allocator;
|
|
// Bands top out at 25M
|
|
const bands = [_]projections.YearPercentiles{
|
|
.{ .year = 0, .p10 = 8000000, .p25 = 8000000, .p50 = 8000000, .p75 = 8000000, .p90 = 8000000 },
|
|
.{ .year = 10, .p10 = 5000000, .p25 = 8000000, .p50 = 12000000, .p75 = 18000000, .p90 = 25000000 },
|
|
};
|
|
// Actuals punch through the top band at 50M
|
|
const points = [_]ActualsPoint{
|
|
.{ .years_from_as_of = 0.0, .liquid = 8000000 },
|
|
.{ .years_from_as_of = 1.0, .liquid = 50000000 },
|
|
};
|
|
const overlay: ActualsOverlay = .{ .points = &points, .today_years = 1.0 };
|
|
|
|
const th = @import("theme.zig").default_theme;
|
|
const result = try renderProjectionChart(std.testing.io, alloc, &bands, 200, 100, th, overlay);
|
|
defer alloc.free(result.rgb_data);
|
|
|
|
// Without expansion, value_max would be ~25M (band p90 + 5%).
|
|
// With expansion to include actuals, it must be >= 50M.
|
|
try std.testing.expect(result.value_max >= 50_000_000);
|
|
}
|
|
|
|
test "renderProjectionChart overlay with no points renders without crash" {
|
|
const alloc = std.testing.allocator;
|
|
const bands = [_]projections.YearPercentiles{
|
|
.{ .year = 0, .p10 = 8000000, .p25 = 8000000, .p50 = 8000000, .p75 = 8000000, .p90 = 8000000 },
|
|
.{ .year = 10, .p10 = 5000000, .p25 = 8000000, .p50 = 12000000, .p75 = 18000000, .p90 = 25000000 },
|
|
};
|
|
const overlay: ActualsOverlay = .{ .points = &.{}, .today_years = 0.5 };
|
|
|
|
const th = @import("theme.zig").default_theme;
|
|
const result = try renderProjectionChart(std.testing.io, alloc, &bands, 200, 100, th, overlay);
|
|
defer alloc.free(result.rgb_data);
|
|
try std.testing.expect(result.rgb_data.len > 0);
|
|
}
|
|
|
|
// ── renderToSurface direct tests ──────────────────────────────────────
|
|
//
|
|
// Exercise the surface-builder seam introduced for --export-chart.
|
|
// Verifies the surface is the right type/dimensions and that
|
|
// extractRgb round-trips correctly.
|
|
|
|
test "renderToSurface returns a populated RGB surface at requested dimensions" {
|
|
const alloc = std.testing.allocator;
|
|
const bands = [_]projections.YearPercentiles{
|
|
.{ .year = 0, .p10 = 1, .p25 = 2, .p50 = 3, .p75 = 4, .p90 = 5 },
|
|
.{ .year = 1, .p10 = 2, .p25 = 3, .p50 = 4, .p75 = 5, .p90 = 6 },
|
|
};
|
|
const th = @import("theme.zig").default_theme;
|
|
var rendered = try renderToSurface(std.testing.io, alloc, &bands, 150, 80, th, null);
|
|
defer rendered.deinit(alloc);
|
|
|
|
try std.testing.expectEqual(@as(u16, 150), rendered.width);
|
|
try std.testing.expectEqual(@as(u16, 80), rendered.height);
|
|
switch (rendered.surface) {
|
|
.image_surface_rgb => {},
|
|
else => try std.testing.expect(false),
|
|
}
|
|
}
|
|
|
|
test "renderToSurface fills background with theme bg" {
|
|
const alloc = std.testing.allocator;
|
|
const bands = [_]projections.YearPercentiles{
|
|
.{ .year = 0, .p10 = 100, .p25 = 110, .p50 = 120, .p75 = 130, .p90 = 140 },
|
|
.{ .year = 1, .p10 = 100, .p25 = 110, .p50 = 120, .p75 = 130, .p90 = 140 },
|
|
};
|
|
var th = @import("theme.zig").default_theme;
|
|
th.bg = .{ 0xab, 0xcd, 0xef };
|
|
|
|
var rendered = try renderToSurface(std.testing.io, alloc, &bands, 100, 50, th, null);
|
|
defer rendered.deinit(alloc);
|
|
|
|
const buf = switch (rendered.surface) {
|
|
.image_surface_rgb => |s| s.buf,
|
|
else => unreachable,
|
|
};
|
|
try std.testing.expectEqual(@as(u8, 0xab), buf[0].r);
|
|
try std.testing.expectEqual(@as(u8, 0xcd), buf[0].g);
|
|
try std.testing.expectEqual(@as(u8, 0xef), buf[0].b);
|
|
}
|
|
|
|
test "renderToSurface is deterministic across calls with same input" {
|
|
const alloc = std.testing.allocator;
|
|
const bands = [_]projections.YearPercentiles{
|
|
.{ .year = 0, .p10 = 100, .p25 = 110, .p50 = 120, .p75 = 130, .p90 = 140 },
|
|
.{ .year = 5, .p10 = 90, .p25 = 110, .p50 = 130, .p75 = 160, .p90 = 200 },
|
|
.{ .year = 10, .p10 = 80, .p25 = 120, .p50 = 160, .p75 = 220, .p90 = 300 },
|
|
};
|
|
const th = @import("theme.zig").default_theme;
|
|
|
|
var a = try renderToSurface(std.testing.io, alloc, &bands, 100, 60, th, null);
|
|
defer a.deinit(alloc);
|
|
var b = try renderToSurface(std.testing.io, alloc, &bands, 100, 60, th, null);
|
|
defer b.deinit(alloc);
|
|
|
|
const buf_a = switch (a.surface) {
|
|
.image_surface_rgb => |s| s.buf,
|
|
else => unreachable,
|
|
};
|
|
const buf_b = switch (b.surface) {
|
|
.image_surface_rgb => |s| s.buf,
|
|
else => unreachable,
|
|
};
|
|
try std.testing.expectEqual(buf_a.len, buf_b.len);
|
|
var i: usize = 0;
|
|
while (i < buf_a.len) : (i += 50) {
|
|
try std.testing.expectEqual(buf_a[i].r, buf_b[i].r);
|
|
try std.testing.expectEqual(buf_a[i].g, buf_b[i].g);
|
|
try std.testing.expectEqual(buf_a[i].b, buf_b[i].b);
|
|
}
|
|
}
|
|
|
|
test "RenderedProjection.extractRgb produces 3 bytes per pixel" {
|
|
const alloc = std.testing.allocator;
|
|
const bands = [_]projections.YearPercentiles{
|
|
.{ .year = 0, .p10 = 1, .p25 = 2, .p50 = 3, .p75 = 4, .p90 = 5 },
|
|
.{ .year = 1, .p10 = 2, .p25 = 3, .p50 = 4, .p75 = 5, .p90 = 6 },
|
|
};
|
|
const th = @import("theme.zig").default_theme;
|
|
var rendered = try renderToSurface(std.testing.io, alloc, &bands, 50, 40, th, null);
|
|
defer rendered.deinit(alloc);
|
|
|
|
const raw = try rendered.extractRgb(alloc);
|
|
defer alloc.free(raw);
|
|
|
|
const buf = switch (rendered.surface) {
|
|
.image_surface_rgb => |s| s.buf,
|
|
else => unreachable,
|
|
};
|
|
try std.testing.expectEqual(buf.len * 3, raw.len);
|
|
try std.testing.expectEqual(buf[0].r, raw[0]);
|
|
try std.testing.expectEqual(buf[0].g, raw[1]);
|
|
try std.testing.expectEqual(buf[0].b, raw[2]);
|
|
}
|
|
|
|
test "renderToSurface clamps value_min to zero when bands include negatives" {
|
|
const alloc = std.testing.allocator;
|
|
// p10 dipping below zero with no padding clamping would make
|
|
// the chart's negative region uselessly large.
|
|
const bands = [_]projections.YearPercentiles{
|
|
.{ .year = 0, .p10 = -100, .p25 = -50, .p50 = 0, .p75 = 50, .p90 = 100 },
|
|
.{ .year = 1, .p10 = -200, .p25 = -100, .p50 = 0, .p75 = 100, .p90 = 200 },
|
|
};
|
|
const th = @import("theme.zig").default_theme;
|
|
var rendered = try renderToSurface(std.testing.io, alloc, &bands, 100, 60, th, null);
|
|
defer rendered.deinit(alloc);
|
|
|
|
// After 5% padding and the `if (value_min < 0) value_min = 0`
|
|
// clamp inside renderToSurface, the recorded min should be 0
|
|
// even though the raw band min is negative.
|
|
try std.testing.expectEqual(@as(f64, 0), rendered.value_min);
|
|
try std.testing.expect(rendered.value_max > 0);
|
|
}
|