//! The module `graphs` is responsible for exporting graphs based on CSV data //! //! # Usage //! //! - [`make_graphs`]: The main action dispatcher for graph generation and removal. use charts_rs::{Box, Color, RadarChart, RadarIndicator, Series, get_or_try_init_fonts}; use cli_parser::Config; use config::graph::{GraphConfig, GraphTargetType}; use glob::glob; use serde::{Deserialize, Serialize}; use std::{ fs::File, io::{Read, Write}, iter, process::Command, }; use anyhow::{Context, Result}; /// Main action dispatch for the graph make pub fn make_graphs(args: &GraphConfig, _config: &Config) -> Result<()> { // Choose action to do match args.target { GraphTargetType::Generate => gen_graph(args), GraphTargetType::Remove => del_graphs(args), GraphTargetType::Init => init_graph_config(args), } } /// Initialize the config on the main directory fn init_graph_config(_args: &GraphConfig) -> Result<()> { let mut f = File::create("graph_config.ron")?; let theme = MiniTheme::new(); f.write_all( ron::ser::to_string_pretty(&theme, ron::ser::PrettyConfig::default()) .context("Converting to toml")? .as_bytes(), ) .context("Writing to file")?; Ok(()) } /// Load the config if given of the default config if none fn load_graph_config(args: &GraphConfig) -> Result { if let Some(c) = &args.config { println!("[INFO] Reading config {}", &c); let mut f = File::open(c).context("Opening config")?; let mut buf = String::new(); f.read_to_string(&mut buf).context("Reading the config")?; Ok(ron::from_str(buf.as_str()).context("Deserializing config")?) } else { println!("[INFO] Loading default config"); Ok(MiniTheme::new()) } } /// Delete the existing graphs fn del_graphs(args: &GraphConfig) -> Result<()> { let mut cmd = Command::new("rm"); cmd.args( glob("Images/Radar/*.svg")? .map(|v| v.unwrap().to_str().unwrap().to_string()) .collect::>(), ); if args.all { cmd.args( glob("Images/Radar/*.png")? .map(|v| v.unwrap().to_str().unwrap().to_string()) .collect::>(), ); } if let Err(e) = cmd.output() { println!( "[ERRR] An error has occured when executing the remove target \n {:#?}", e ) } Ok(()) } /// Generate the graph and save it fn gen_graph(args: &GraphConfig) -> Result<()> { // Import CSV let data = include_bytes!("../../data/lmroman8-regular.ttf") as &[u8]; get_or_try_init_fonts(Some(vec![data])).unwrap(); let csv = import_csv(args)?; let maxv = &csv.max; let cfg = load_graph_config(args)?; for graph in csv.values { // println!("{:?} {:#?}", maxv, graph); // let path = format!("{}/{}.png", args.destination, &graph.name); let path_svg = format!("{}/{}.svg", args.destination, &graph.name); let path_png = format!("{}/{}.png", args.destination, &graph.name); println!("[INFO] Processing {}", path_svg); let mut f = File::create(&path_svg)?; let mut r = RadarChart::new([graph].to_vec(), maxv.to_vec()); cfg.apply_to(&mut r); f.write_all(r.svg().context("Converting to SVG")?.as_bytes())?; let mut cmd = Command::new("convert"); cmd.arg("--size") .arg("800x600") .arg(&path_svg) .arg(path_png); println!("[INFO] Using convert cli to convert to png"); if let Err(e) = cmd.output() { println!( "[ERRR] An error has occured when converting the file {} to png \n {:#?}", path_svg, e ) } } Ok(()) } /// Import the default csv fn import_csv(args: &GraphConfig) -> Result { let file = File::open(&args.origin) .context("Opening the radar file") .unwrap(); let rdr = csv::ReaderBuilder::new().from_reader(file); cleanup_csv(rdr) } /// The data for all graphs struct GraphValues { /// The max values of a graph // max: Vec<(String, f32)>, max: Vec, /// The list of all character and associated values // values: Vec<(String, Vec)>, values: Vec, } /// Cleanup the given csv to output usable data fn cleanup_csv(mut rdr: csv::Reader) -> Result { let headers = rdr.headers().context("Opening headers")?; // Making the max/base vec // Gathering all the different category names let headers = headers .iter() .filter(|v| !v.is_empty()) .skip(1) .map(|v| v.to_string()) .collect::>(); // Gather all the different categories let mut rdr = rdr.records(); // Calculate the max values let maxvals: Vec = rdr .next() .context("Gathering max values")?? .iter() .map(|v| v.parse::().unwrap_or(0.0)) .skip(1) .collect(); // Calculate all the values of all graphs let mut res = Vec::new(); for line in rdr { let line = line.context("Parsing table lines")?; let name = line .get(0) .context("Fetching name for character")? .to_string() .replace(" ", "_") .replace("î", "i") .to_lowercase() .replace("é", "e"); let vals: Vec = line .iter() .skip(1) .enumerate() .map(|(i, v)| { v.parse::().unwrap_or(0.0) * 5.0 / maxvals.get(i).context("Fetching max value").unwrap() }) .collect(); res.push(Series::new(name, vals)); } Ok(GraphValues { max: headers .iter() .map(|v| v.to_owned()) .zip(iter::repeat(5.0f32)) .map(|(name, max)| RadarIndicator { name, max }) .collect::>(), values: res, }) } impl MiniTheme { /// The default theme for out tool pub fn new() -> Self { Self { font_family: "LMRoman8".to_string(), margin: Box { left: -10.0, top: 20.0, right: 70.0, bottom: 0.0, }, width: 720.0, height: 440.0, grid_stroke_color: Color { r: 77, g: 69, b: 57, a: 255, }, grid_stroke_width: 2.5, series_stroke_width: 5.0, series_label_font_size: 60.0, series_label_font_color: Color { r: 75, g: 61, b: 68, a: 255, }, series_colors: [Color { r: 179, g: 165, b: 85, a: 255, }] .to_vec(), legend_show: Some(false), } } /// Apply our super custom theme to the graph pub(super) fn apply_to(&self, r: &mut RadarChart) { r.font_family = self.font_family.clone(); r.margin = self.margin.clone(); r.width = self.width; r.height = self.height; r.grid_stroke_color = self.grid_stroke_color; r.grid_stroke_width = self.grid_stroke_width; r.series_stroke_width = self.series_stroke_width; r.series_label_font_size = self.series_label_font_size; r.series_label_font_color = self.series_label_font_color; r.series_colors = self.series_colors.clone(); r.legend_show = self.legend_show; } } #[allow(missing_docs, clippy::missing_docs_in_private_items)] #[derive(Serialize, Deserialize)] pub struct MiniTheme { pub font_family: String, pub margin: Box, pub width: f32, pub height: f32, pub legend_show: Option, // pub background_color: Color, pub grid_stroke_color: Color, pub grid_stroke_width: f32, pub series_stroke_width: f32, pub series_label_font_size: f32, pub series_label_font_color: Color, pub series_colors: Vec, // pub title_font_size: f32, // pub title_font_color: Color, // pub title_font_weight: Option, // pub title_margin: Option, // pub title_align: Align, // pub title_height: f32, // pub sub_title_font_size: f32, // pub sub_title_font_color: Color, // pub sub_title_margin: Option, // pub sub_title_align: Align, // pub sub_title_height: f32, // pub legend_font_size: f32, // pub legend_font_color: Color, // pub legend_align: Align, // pub legend_margin: Option, // pub x_axis_font_size: f32, // pub x_axis_stroke_color: Color, // pub x_axis_font_color: Color, // pub x_axis_name_gap: f32, // pub x_axis_height: f32, // pub y_axis_font_size: f32, // pub y_axis_font_color: Color, // pub y_axis_stroke_color: Color, // pub y_axis_split_number: usize, // pub y_axis_name_gap: f32, // pub table_header_color: Color, // pub table_body_colors: Vec, // pub table_border_color: Color, }