Skip to main content

ferric_alpha_render/backend/
svg.rs

1use std::path::Path;
2
3use ferric_alpha::{ReportTable, TearSheetData};
4use plotters::prelude::{IntoDrawingArea, SVGBackend};
5
6use crate::charts::common::TextAllocation;
7use crate::charts::events::render_event_panel_svg;
8use crate::charts::information::render_information_panel_svg;
9use crate::charts::returns::render_returns_panel_svg;
10use crate::charts::table::draw_table_panel;
11use crate::charts::turnover::render_turnover_panel_svg;
12use crate::{PanelKind, PanelPlan, RenderError, RenderOptions, RenderResult, Theme};
13use crate::{plan_report, theme_for};
14
15#[derive(Debug, Clone, PartialEq, Eq)]
16pub struct RenderedPanel {
17    pub svg: String,
18    pub text_allocations: Vec<TextAllocation>,
19}
20
21pub fn render_svg(report: &TearSheetData, options: &RenderOptions) -> RenderResult<String> {
22    let plan = plan_report(report, options)?;
23    let theme = theme_for(options.theme);
24    let mut out = String::new();
25    out.push_str(&format!(
26        r#"<svg xmlns="http://www.w3.org/2000/svg" width="{}" height="{}" viewBox="0 0 {} {}">"#,
27        plan.width, plan.height, plan.width, plan.height
28    ));
29    out.push_str(&format!(
30        r#"<rect x="0" y="0" width="{}" height="{}" fill="{}"/>"#,
31        plan.width,
32        plan.height,
33        theme.background.hex()
34    ));
35
36    for panel in &plan.panels {
37        let panel_width = panel_width(plan.width, panel);
38        let rendered = render_panel_svg(report, panel, panel_width, theme)?;
39        out.push_str(&format!(
40            r#"<g transform="translate({}, {})">{}</g>"#,
41            panel_x(plan.width, panel),
42            panel_y(&plan.panels, panel),
43            rendered.svg
44        ));
45    }
46    out.push_str("</svg>");
47    Ok(out)
48}
49
50pub fn write_svg(
51    report: &TearSheetData,
52    options: &RenderOptions,
53    path: impl AsRef<Path>,
54) -> RenderResult<()> {
55    let path = path.as_ref();
56    let svg = render_svg(report, options)?;
57    std::fs::write(path, svg).map_err(|source| RenderError::Io {
58        path: path.to_path_buf(),
59        source,
60    })
61}
62
63pub fn render_panel_svg(
64    report: &TearSheetData,
65    panel: &PanelPlan,
66    width: u32,
67    theme: Theme,
68) -> RenderResult<RenderedPanel> {
69    match panel.kind {
70        PanelKind::Table => render_table_panel_svg(report, panel, width, theme),
71        PanelKind::QuantileReturnsBar { .. }
72        | PanelKind::QuantileReturnsDistribution { .. }
73        | PanelKind::CumulativeReturns { .. }
74        | PanelKind::MeanSpread => {
75            let (svg, text_allocations) = render_returns_panel_svg(report, panel, width, theme)?;
76            Ok(RenderedPanel {
77                svg,
78                text_allocations,
79            })
80        }
81        PanelKind::IcTimeSeries
82        | PanelKind::IcHistogram { .. }
83        | PanelKind::IcQq
84        | PanelKind::IcMonthlyHeatmap
85        | PanelKind::IcByGroup => {
86            let (svg, text_allocations) =
87                render_information_panel_svg(report, panel, width, theme)?;
88            Ok(RenderedPanel {
89                svg,
90                text_allocations,
91            })
92        }
93        PanelKind::QuantileTurnover { .. } | PanelKind::RankAutocorrelation { .. } => {
94            let (svg, text_allocations) = render_turnover_panel_svg(report, panel, width, theme)?;
95            Ok(RenderedPanel {
96                svg,
97                text_allocations,
98            })
99        }
100        PanelKind::EventDistribution | PanelKind::EventAverageCumulative { .. } => {
101            let (svg, text_allocations) = render_event_panel_svg(report, panel, width, theme)?;
102            Ok(RenderedPanel {
103                svg,
104                text_allocations,
105            })
106        }
107    }
108}
109
110pub fn render_table_panel_svg(
111    report: &TearSheetData,
112    panel: &PanelPlan,
113    width: u32,
114    theme: Theme,
115) -> RenderResult<RenderedPanel> {
116    let tables = panel
117        .table_ids
118        .iter()
119        .map(|id| {
120            report
121                .table(id)
122                .ok_or_else(|| RenderError::MissingTable { id: id.to_string() })
123        })
124        .collect::<RenderResult<Vec<_>>>()?;
125    render_table_svg(&panel.id, &panel.title, &tables, width, panel.height, theme)
126}
127
128pub fn render_table_svg(
129    panel_id: &str,
130    title: &str,
131    tables: &[&ReportTable],
132    width: u32,
133    height: u32,
134    theme: Theme,
135) -> RenderResult<RenderedPanel> {
136    let mut svg = String::new();
137    {
138        let backend = SVGBackend::with_string(&mut svg, (width, height));
139        let area = backend.into_drawing_area();
140        let mut manifest = Vec::new();
141        draw_table_panel(&area, panel_id, title, tables, &theme, &mut manifest)?;
142        area.present().map_err(|error| RenderError::Backend {
143            format: "SVG",
144            message: error.to_string(),
145        })?;
146        drop(area);
147        Ok(RenderedPanel {
148            svg: inject_panel_id(svg, panel_id),
149            text_allocations: manifest,
150        })
151    }
152}
153
154fn inject_panel_id(svg: String, panel_id: &str) -> String {
155    svg.replacen("<svg ", &format!(r#"<svg id="{panel_id}" "#), 1)
156}
157
158fn panel_x(plan_width: u32, panel: &PanelPlan) -> u32 {
159    let margin = 24;
160    let content_width = plan_width - 48;
161    if panel.column == 0 {
162        margin
163    } else {
164        margin + content_width / 2 + 8
165    }
166}
167
168fn panel_width(plan_width: u32, panel: &PanelPlan) -> u32 {
169    let content = plan_width - 48;
170    if panel.column_span == 12 {
171        content
172    } else {
173        (content - 16) / 2
174    }
175}
176
177fn panel_y(panels: &[PanelPlan], panel: &PanelPlan) -> u32 {
178    let mut y = 24 + 56 + 24;
179    for row in 0..panel.row {
180        let height = panels
181            .iter()
182            .find(|candidate| candidate.row == row)
183            .map_or(0, |candidate| candidate.height);
184        y += height + 24;
185    }
186    y
187}