add svg visitor

.gitignore

@@ -2,3 +2,5 @@
 
 *.ttf
 *.otf
+*.svg
+*.dump

src/font.rs

@@ -17,6 +17,8 @@ use log::{debug, info};
 use maximum_profile::MaximumProfile;
 use table_directory::TableDirectory;
 
+pub use glyph_data::{GlyphData, GlyphHeader, GlyphPoint, Glyph, SimpleGlyph};
+
 fn deserialize<R: Read, T: serde::de::DeserializeOwned>(reader: R) -> bincode::Result<T> {
 	bincode::options().with_big_endian().with_fixint_encoding().deserialize_from::<R, T>(reader)
 }
@@ -76,7 +78,7 @@ impl Font {
 		})
 	}
 
-	pub fn get_data_for(&mut self, glyph: char) -> Result<(), Box<dyn Error>> {
+	pub fn get_data_for(&mut self, glyph: char) -> Result<Glyph, Box<dyn Error>> {
 		let Some(glyph_id) = self.character_map.get_char(glyph) else {
 			return Err("Failed to get glyph id for char".into());
 		};
@@ -85,7 +87,7 @@ impl Font {
 
 		let glyph = self.glyph_table.get_glyph(glyph_id, &mut self.index_to_location)?;
 
-		Ok(())
+		Ok(glyph)
 	}
 }
 

src/font/glyph_data.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, fs::File, io::{BufReader, Read, Seek, SeekFrom}, iter::zip};
+use std::{collections::HashMap, fs::File, io::{BufReader, Read, Seek, SeekFrom}, iter::zip, slice::Iter};
 
 use bincode::{ErrorKind, Result};
 use bitfield::bitfield;
@@ -12,10 +12,10 @@ use super::{deserialize, deserialize_vec, index_to_location::IndexToLocation, ta
 pub struct GlyphHeader {
 	num_countours: i16,
 
-	xmin: i16,
+	pub xmin: i16,
-	ymin: i16,
+	pub ymin: i16,
-	xmax: i16,
+	pub xmax: i16,
-	ymax: i16
+	pub ymax: i16
 }
 
 bitfield! {
@@ -81,15 +81,14 @@ impl<'a> Iterator for GlyphFlags<'a> {
 
 #[derive(Debug)]
 pub struct GlyphPoint {
-	x: i32,
+	pub x: i32,
-	y: i32,
+	pub y: i32,
 
-	on_curve: bool
+	pub on_curve: bool
 }
 
 #[derive(Debug)]
 pub struct SimpleGlyph {
-	header: GlyphHeader,
 	instructions: Vec<u8>,
 
 	points: Vec<GlyphPoint>
@@ -146,7 +145,7 @@ impl SimpleGlyph {
 		Ok(coordinates)
 	}
 
-	fn new<R: Read + Seek>(header: GlyphHeader, reader: &mut R) -> Result<SimpleGlyph> {
+	fn new<R: Read + Seek>(header: &GlyphHeader, reader: &mut R) -> Result<SimpleGlyph> {
 		let end_points: Vec<u16> = deserialize_vec(reader, header.num_countours as usize)?;
 		debug!("glyph end points: {end_points:#?}");
 
@@ -168,7 +167,27 @@ impl SimpleGlyph {
 
 		// coordinates.for_each(|point| debug!("({}, {}, {})", point.x, point.y, if point.on_curve { "on" } else { "off" }));
 
-		Ok(SimpleGlyph { header, instructions, points: coordinates.collect() })
+		Ok(SimpleGlyph { instructions, points: coordinates.collect() })
+	}
+
+	pub fn iter<'a>(&'a self) -> SimpleGlyphIter<'a> {
+		SimpleGlyphIter {
+			glyph: self,
+			iter: self.points.iter()
+		}
+	}
+}
+
+struct SimpleGlyphIter<'a> {
+	glyph: &'a SimpleGlyph,
+	iter: Iter<'a, GlyphPoint>
+}
+
+impl<'a> Iterator for SimpleGlyphIter<'a> {
+	type Item = &'a GlyphPoint;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		self.iter.next()
 	}
 }
 
@@ -178,16 +197,33 @@ pub enum GlyphData {
 	Composite
 }
 
+#[derive(Debug)]
+pub struct Glyph {
+	pub header: GlyphHeader,
+	pub data: GlyphData
+}
+
+impl Glyph {
+	pub fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = &'a GlyphPoint> + 'a> {
+		Box::new(
+			match &self.data {
+				GlyphData::Simple(glyph) => glyph.iter(),
+				GlyphData::Composite => todo!()
+			}
+		)
+	}
+}
+
 #[derive(Debug)]
 pub struct GlyphTable {
 	data_source: BufReader<File>,
 	offset: u32,
 
-	cache: HashMap<u16, GlyphData>
+	cache: HashMap<u16, Glyph>
 }
 
 impl GlyphTable {
-	pub fn get_glyph(&mut self, glyph_id: u16, location: &mut IndexToLocation) -> Result<GlyphData>{
+	pub fn get_glyph(&mut self, glyph_id: u16, location: &mut IndexToLocation) -> Result<Glyph>{
 		let Some(offset) = location.get_offset(glyph_id) else {
 			return Err(ErrorKind::Custom("Failed to look up glyph location".into()).into());
 		};
@@ -201,7 +237,10 @@ impl GlyphTable {
 		debug!("glyph header: {header:#?}");
 
 		if header.num_countours >= 0 {
-			Ok(GlyphData::Simple(SimpleGlyph::new(header, self.data_source.by_ref())?))
+			Ok(Glyph {
+				data: GlyphData::Simple(SimpleGlyph::new(&header, self.data_source.by_ref())?),
+				header
+			})
 		} else {
 			todo!();
 		}

src/main.rs

@@ -1,4 +1,5 @@
 mod font;
+mod writer;
 
 use std::{error::Error, fs::File};
 
@@ -6,6 +7,7 @@ use clap::Parser;
 use font::Font;
 use log::{error, LevelFilter};
 use simplelog::{ColorChoice, Config, TermLogger, TerminalMode};
+use writer::{SvgWriter, Visitor};
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -33,13 +35,18 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     // dbg!(font);
 
-    match font.get_data_for(args.glyph) {
+    let glyph = match font.get_data_for(args.glyph) {
-        Ok(()) => {},
+        Ok(glyph) => glyph,
         Err(err) => {
             error!("{err}");
             return Err(err);
         }
     };
 
+    let svg_file = File::create("out.svg")?;
+    let mut writer = SvgWriter::new(svg_file);
+
+    writer.write(&glyph);
+
     Ok(())
 }

src/writer.rs

@@ -0,0 +1,19 @@
+mod svg;
+
+use crate::font::{GlyphHeader, GlyphPoint, Glyph};
+
+pub use svg::SvgWriter;
+
+pub trait Visitor {
+	fn write_prefix(&mut self, header: &GlyphHeader);
+	fn write_point(&mut self, point: &GlyphPoint);
+	fn write_suffix(&mut self);
+
+	fn write(&mut self, glyph: &Glyph) {
+		self.write_prefix(&glyph.header);
+		
+		glyph.iter().for_each(|point| self.write_point(point));
+
+		self.write_suffix();
+	}
+}

src/writer/svg.rs

@@ -0,0 +1,54 @@
+use std::{fs::File, io::{BufWriter, Write}};
+
+use crate::font::{GlyphHeader, GlyphPoint};
+
+use super::Visitor;
+
+pub struct SvgWriter {
+	first_point: bool,
+	writer: BufWriter<File>
+}
+
+impl SvgWriter {
+	pub fn new(file: File) -> Self {
+		SvgWriter {
+			first_point: true,
+			writer: BufWriter::new(file)
+		}
+	}
+}
+
+impl Visitor for SvgWriter {
+	fn write_prefix(&mut self, header: &GlyphHeader) {
+		write!(
+			self.writer,
+			"<svg width=\"1000\" height=\"1000\" viewBox=\"{} {} {} {}\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"",
+			header.xmin, header.ymin,
+			header.xmax - header.xmin,
+			header.ymax - header.ymin
+		);
+	}
+
+	fn write_point(&mut self, point: &GlyphPoint) {
+		if !point.on_curve {
+			return
+		}
+
+		let prefix = if self.first_point { "M" } else { "L" };
+
+		write!(
+			self.writer,
+			"{prefix}{} {} ",
+			point.x, point.y
+		);
+
+		self.first_point = false;
+	}
+
+	fn write_suffix(&mut self) {
+		write!(
+			self.writer,
+			"\" style=\"fill:none; stroke:black; stroke-width:3;\" /></svg>"
+		);
+	}
+}