ferric_alpha_render/backend/
svg.rs1use 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}