[NIB] Add configurable accuracy

Author: ctrlcctrlv

README.md

@@ -151,10 +151,11 @@ FLAGS:
     -V, --version    Prints version information
 
 OPTIONS:
-    -n, --nib <nib>          The path to the nib file. FontForge is quite strict about these. The .glif must contain a
-                             single closed spline, running clockwise, which represents a convex shape.
-    -i, --input <input>      The path to the input path file.
-    -o, --output <output>    The path where the output .glif will be saved.
+    -n, --nib <nib>              The path to the nib file. FontForge is quite strict about these. The .glif must contain
+                                 a single closed spline, running clockwise, which represents a convex shape.
+    -i, --input <input>          The path to the input path file.
+    -o, --output <output>        The path where the output .glif will be saved.
+    -a, --accuracy <accuracy>    <f64> Accuracy target [default: 0.25]
 ```
 
 ## License

src/constant_width_stroke.rs

@@ -11,19 +11,6 @@ use glifparser::{Glif, Outline};
 use clap::{App, Arg};
 
 pub fn clap_app() -> clap::App<'static, 'static> {
-    fn arg_validator_width(v: String) -> Result<(), String> {
-        match v.parse::<f64>() {
-            Ok(i) => {
-                if i <= 0.0 + f64::EPSILON {
-                    Err(String::from("Value too small"))
-                } else {
-                    Ok(())
-                }
-            }
-            Err(_) => Err(String::from("Value must be a float")),
-        }
-    }
-
     App::new("CWS")
         .alias("constant")
         .alias("cws")
@@ -67,7 +54,7 @@ pub fn clap_app() -> clap::App<'static, 'static> {
             .short("w")
             .takes_value(true)
             .help(r#"<f64> Constant stroke width."#)
-            .validator(arg_validator_width)
+            .validator(super::arg_validator_positive_f64)
             .required(true))
 }
 

src/main.rs

@@ -9,6 +9,19 @@ mod nib_stroke;
 mod pattern_along_path;
 mod variable_width_stroke;
 
+pub fn arg_validator_positive_f64(v: String) -> Result<(), String> {
+    match v.parse::<f64>() {
+        Ok(i) => {
+            if i <= 0.0 + f64::EPSILON {
+                Err(String::from("Value too small"))
+            } else {
+                Ok(())
+            }
+        }
+        Err(_) => Err(String::from("Value must be a float")),
+    }
+}
+
 fn main() {
     #[allow(unused_mut)] // we actually use it if cfg(feature=fontforge)
     let mut argparser = App::new("MFEKstroke")

src/nib_stroke.rs

@@ -31,16 +31,27 @@ pub fn clap_app() -> clap::App<'static, 'static> {
             .takes_value(true)
             .help("The path where the output .glif will be saved.")
             .required(true))
+       .arg(Arg::with_name("accuracy")
+            .display_order(4)
+            .short("a")
+            .long("accuracy")
+            .takes_value(true)
+            .default_value("0.25")
+            .help("<f64> Accuracy target")
+            .validator(super::arg_validator_positive_f64)
+            .required(false))
 }
 
 pub fn nib_cli(matches: &clap::ArgMatches) {
     let nib_file = matches.value_of("nib").unwrap();
     let input_file = matches.value_of("input").unwrap();
     let output_file = matches.value_of("output").unwrap();
+    let accuracy = matches.value_of("accuracy").unwrap();
 
     let settings = fontforge::NibSettings {
         nib: nib_file.to_string(),
         path: input_file.to_string(),
+        accuracy: accuracy.parse().unwrap(), //validated by super::arg_validator_positive_f64
         quiet: true,
     };
 

src/nib_stroke/fontforge.rs

@@ -243,6 +243,7 @@ fn glif_to_ffsplineset<T>(glif: glifparser::Glif<T>) -> (Vec<fontforge::SplineSe
 pub struct NibSettings {
     pub nib: String,
     pub path: String,
+    pub accuracy: f64,
     pub quiet: bool,
 }
 
@@ -288,6 +289,7 @@ pub fn convert_glif(settings: &NibSettings) -> Option<String> {
         (*si).stroke_type = fontforge::si_type_si_nib;
         (*si).nib = nibss;
         (*si).width = 10.;
+        (*si).accuracy_target = settings.accuracy;
         (*si).simplify = -1;
         (*si).rmov = fontforge::stroke_rmov_srmov_none;
         // Do the stroke for each contour. We do it this way to avoid constructing linked lists of