Add initial SVG renderer for thermographs

Author: t4ccer

cgt-py/src/canonical_form.rs

@@ -70,8 +70,8 @@ impl PyCanonicalForm {
         self.inner.temperature().into()
     }
 
-    // TODO: Convert to svg
     fn thermograph(&self) -> String {
-        self.inner.thermograph().to_string()
+        // format!("{:?}", self.inner.thermograph())
+        self.inner.thermograph().to_svg()
     }
 }

src/drawing.rs

@@ -0,0 +1,3 @@
+//! Drawing module
+
+pub mod svg;

src/drawing/svg.rs

@@ -0,0 +1,65 @@
+//! Simple SVG immediate drawing utilities
+
+use std::fmt::{self, Write};
+
+/// SVG renderer
+pub struct Svg;
+
+impl Svg {
+    /// Create new SVG
+    pub fn new<W>(
+        w: &mut W,
+        width: u32,
+        height: u32,
+        cont: impl FnOnce(&mut W) -> fmt::Result,
+    ) -> fmt::Result
+    where
+        W: Write,
+    {
+        write!(w, "<svg width=\"{}\" height=\"{}\">", width, height)?;
+        cont(w)?;
+        write!(w, "</svg>")
+    }
+
+    /// Create [group element](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/g)
+    pub fn g<W>(w: &mut W, stroke: &str, cont: impl FnOnce(&mut W) -> fmt::Result) -> fmt::Result
+    where
+        W: Write,
+    {
+        write!(w, "<g stroke=\"{}\">", stroke)?;
+        cont(w)?;
+        write!(w, "</g>")
+    }
+
+    /// Create [line element](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/line)
+    pub fn line<W>(w: &mut W, x1: i32, y1: i32, x2: i32, y2: i32, stroke_width: u32) -> fmt::Result
+    where
+        W: Write,
+    {
+        write!(
+            w,
+            "<line x1=\"{}\" y1=\"{}\" x2=\"{}\" y2=\"{}\" style=\"stroke-width:{};\"/>",
+            x1, y1, x2, y2, stroke_width
+        )
+    }
+
+    /// Create [rectangle element](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/rect)
+    pub fn rect<W>(w: &mut W, x: i32, y: i32, width: u32, height: u32, fill: &str) -> fmt::Result
+    where
+        W: Write,
+    {
+        write!(
+            w,
+            "<rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" style=\"fill:{};\"/>",
+            x, y, width, height, fill,
+        )
+    }
+
+    /// Create [text element](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/text)
+    pub fn text<W>(w: &mut W, x: i32, y: i32, text: &str) -> fmt::Result
+    where
+        W: Write,
+    {
+        write!(w, "<text x=\"{}\" y=\"{}\">{}</text>", x, y, text,)
+    }
+}

src/lib.rs

@@ -23,6 +23,7 @@
     )
 )]
 
+pub mod drawing;
 pub mod graph;
 pub mod loopy;
 pub mod numeric;

src/numeric/rational.rs

@@ -55,6 +55,15 @@ impl Rational {
             Err(_) => Ok((input, Self::from(numerator))),
         }
     }
+
+    /// Rounding towards zero if finite
+    pub fn try_round(&self) -> Option<i64> {
+        match self {
+            Self::NegativeInfinity => None,
+            Self::Value(val) => Some(val.to_integer()),
+            Self::PositiveInfinity => None,
+        }
+    }
 }
 
 impl From<Rational64> for Rational {

src/short/partizan/games/domineering.rs

@@ -2,7 +2,7 @@
 //! horizontal dominoes.
 
 extern crate alloc;
-use crate::short::partizan::partizan_game::PartizanGame;
+use crate::{drawing::svg::Svg, short::partizan::partizan_game::PartizanGame};
 use alloc::collections::vec_deque::VecDeque;
 use std::{fmt::Display, str::FromStr};
 
@@ -342,67 +342,57 @@ impl Domineering {
 
     /// Output SVG string with domineering grid
     pub fn to_svg(&self) -> String {
-        use std::fmt::Write;
-        let mut buf = String::new();
-
+        // Chosen arbitrarily
         let tile_size = 48;
         let grid_width = 4;
-        let offset = grid_width / 2;
 
-        let svg_width = self.width() * tile_size + grid_width;
-        let svg_height = self.height() * tile_size + grid_width;
-
-        write!(
-            buf,
-            "<svg width=\"{}\" height=\"{}\">",
-            svg_width, svg_height,
-        )
-        .unwrap();
+        let offset = grid_width / 2;
+        let svg_width = self.width() as u32 * tile_size + grid_width;
+        let svg_height = self.height() as u32 * tile_size + grid_width;
 
-        for y in 0..self.height() {
-            for x in 0..self.width() {
-                let fill = if self.at(x, y) { "gray" } else { "white" };
-
-                write!(
-                    buf,
-                    "<rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" style=\"fill:{};\"/>",
-                    x * tile_size + offset,
-                    y * tile_size + offset,
-                    tile_size,
-                    tile_size,
-                    fill,
-                )
-                .unwrap();
+        let mut buf = String::new();
+        Svg::new(&mut buf, svg_width, svg_width, |buf| {
+            for y in 0..self.height() {
+                for x in 0..self.width() {
+                    let fill = if self.at(x, y) { "gray" } else { "white" };
+                    Svg::rect(
+                        buf,
+                        (x as u32 * tile_size + offset) as i32,
+                        (y as u32 * tile_size + offset) as i32,
+                        tile_size,
+                        tile_size,
+                        fill,
+                    )?;
+                }
             }
-        }
 
-        write!(buf, "<g stroke=\"black\">",).unwrap();
-        for y in 0..(self.height() + 1) {
-            write!(
-                buf,
-                "<line x1=\"{}\" y1=\"{}\" x2=\"{}\" y2=\"{}\" style=\"stroke-width:{};\"/>",
-                0,
-                y * tile_size + offset,
-                svg_width,
-                y * tile_size + offset,
-                grid_width
-            )
-            .unwrap();
-        }
-        for x in 0..(self.width() + 1) {
-            write!(
-                buf,
-                "<line x1=\"{}\" y1=\"{}\" x2=\"{}\" y2=\"{}\" style=\"stroke-width:{};\"/>",
-                x * tile_size + offset,
-                0,
-                x * tile_size + offset,
-                svg_height,
-                grid_width
-            )
-            .unwrap();
-        }
+            Svg::g(buf, "black", |buf| {
+                for y in 0..(self.height() + 1) {
+                    Svg::line(
+                        buf,
+                        0,
+                        (y as u32 * tile_size + offset) as i32,
+                        svg_width as i32,
+                        (y as u32 * tile_size + offset) as i32,
+                        grid_width,
+                    )?;
+                }
+
+                for x in 0..(self.width() + 1) {
+                    Svg::line(
+                        buf,
+                        (x as u32 * tile_size + offset) as i32,
+                        0,
+                        (x as u32 * tile_size + offset) as i32,
+                        svg_height as i32,
+                        grid_width,
+                    )?;
+                }
 
-        write!(buf, "</g></svg>",).unwrap();
+                Ok(())
+            })
+        })
+        .unwrap();
 
         buf
     }

src/short/partizan/thermograph.rs

@@ -1,8 +1,12 @@
 //! Thermograph constructed from scaffolds with support for subzero thermography
 
-use crate::{display, numeric::rational::Rational, short::partizan::trajectory::Trajectory};
-use std::cmp::Ordering;
-use std::fmt::Display;
+use crate::{
+    display, drawing::svg::Svg, numeric::rational::Rational,
+    short::partizan::trajectory::Trajectory,
+};
+use ahash::{HashSet, HashSetExt};
+use core::fmt;
+use std::{cmp::Ordering, fmt::Display, iter::once};
 
 /// See [thermograph](self) header
 #[derive(Debug, Hash, Clone, PartialEq, Eq)]
@@ -455,6 +459,141 @@ impl Thermograph {
             right_wall,
         }
     }
+
+    /// Render thermograph as SVG image
+    pub fn to_svg(&self) -> String {
+        fn rescale(x: i64, in_min: i64, in_max: i64, out_min: i64, out_max: i64) -> i64 {
+            (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min
+        }
+
+        // Chosen arbitrarily, may be customizable in the future
+        let svg_width = 450;
+        let svg_height = 300;
+        let mast_arrow_len = Rational::from(3);
+        let axis_weight = 1;
+        let thermograph_line_weight = 3;
+        let padding = 32;
+
+        let thermograph_x_min = self
+            .right_wall
+            .value_at(Rational::from(-1))
+            .try_round()
+            .unwrap();
+        let thermograph_x_max = self
+            .left_wall
+            .value_at(Rational::from(-1))
+            .try_round()
+            .unwrap();
+
+        let thermograph_y_min = 0;
+        let thermograph_y_max = (self.get_temperature() + mast_arrow_len)
+            .try_round()
+            .unwrap();
+
+        let x_axis_location = (svg_height as f32 * 0.9) as i32;
+        let y_axis_location = rescale(
+            0,
+            thermograph_x_min,
+            thermograph_x_max,
+            svg_width as i64 - padding,
+            padding,
+        ) as i32;
+
+        let from_thermograph_horizontal = |value| {
+            rescale(
+                value,
+                thermograph_x_min,
+                thermograph_x_max,
+                svg_width as i64 - padding,
+                padding,
+            )
+        };
+        let from_thermograph_vertical = |value| {
+            rescale(
+                value,
+                thermograph_y_min,
+                thermograph_y_max,
+                x_axis_location as i64,
+                padding,
+            )
+        };
+
+        let draw_scaffold = |w: &mut String,
+                             seen: &mut HashSet<(i64, i64)>,
+                             trajectory: &Trajectory|
+         -> fmt::Result {
+            let mut previous = None;
+
+            let y_points = once(trajectory.mast_x_intercept() + mast_arrow_len).chain(
+                trajectory
+                    .critical_points
+                    .iter()
+                    .copied()
+                    .chain(once(Rational::from(-1))),
+            );
+
+            for point_y in y_points {
+                let point_x = trajectory.value_at(point_y);
+
+                let image_x = from_thermograph_horizontal(point_x.try_round().unwrap());
+                let image_y = from_thermograph_vertical(point_y.try_round().unwrap());
+
+                if !seen.contains(&(image_x, image_y)) {
+                    // TODO: Make it less ugly, maybe move values to axis rather than having them on
+                    // critical points
+                    Svg::text(
+                        w,
+                        image_x as i32,
+                        image_y as i32,
+                        &format!("({}, {})", point_x, point_y),
+                    )?;
+                    seen.insert((image_x, image_y));
+                }
+
+                if let Some((previous_x, previous_y)) = previous {
+                    Svg::line(
+                        w,
+                        previous_x as i32,
+                        previous_y as i32,
+                        image_x as i32,
+                        image_y as i32,
+                        thermograph_line_weight,
+                    )?;
+                }
+
+                previous = Some((image_x, image_y));
+            }
+            Ok(())
+        };
+
+        let mut buf = String::new();
+        Svg::new(&mut buf, svg_width, svg_height, |buf| {
+            Svg::g(buf, "black", |buf| {
+                Svg::line(
+                    buf,
+                    0,
+                    x_axis_location,
+                    svg_width as i32,
+                    x_axis_location,
+                    axis_weight,
+                )?;
+                Svg::line(
+                    buf,
+                    y_axis_location,
+                    0,
+                    y_axis_location,
+                    svg_height as i32,
+                    axis_weight,
+                )?;
+
+                let mut seen = HashSet::new();
+                draw_scaffold(buf, &mut seen, &self.left_wall)?;
+                draw_scaffold(buf, &mut seen, &self.right_wall)
+            })
+        })
+        .unwrap();
+        buf
+    }
 }
 
 impl Display for Thermograph {

src/short/partizan/trajectory.rs

@@ -95,7 +95,7 @@ impl Trajectory {
         self.x_intercepts[0]
     }
 
-    /// Gets the value of this trajectory at the specified point.
+    /// Gets the value of this trajectory at the specified height (y value).
     pub fn value_at(&self, r: Rational) -> Rational {
         let i = self
             .critical_points