Generalizing gradients and add constant gradients

palette/Cargo.toml

@@ -15,9 +15,10 @@ categories = ["graphics", "multimedia::images", "no-std"]
 build = "build/main.rs"
 
 [features]
-default = ["named_from_str", "std"]
+default = ["named_from_str", "named_gradients", "std"]
 named_from_str = ["named", "phf", "phf_codegen", "std"]
 named = []
+named_gradients = ["std"]
 random = ["rand"]
 serializing = ["serde", "std"]
 

palette/build/named.rs

@@ -1,16 +1,23 @@
 use std::fs::File;
 
-#[cfg(feature = "named")]
 pub fn build() {
-    use std::io::{BufRead, BufReader, Write};
     use std::path::Path;
 
     let out_dir = ::std::env::var("OUT_DIR").unwrap();
     let dest_path = Path::new(&out_dir).join("named.rs");
+    let mut writer = File::create(dest_path).expect("couldn't create named.rs");
+    build_colors(&mut writer);
+    let dest_path = Path::new(&out_dir).join("named_gradients.rs");
+    let mut writer = File::create(dest_path).expect("couldn't create named_gradients.rs");
+    build_gradients(&mut writer);
+}
+
+#[cfg(feature = "named")]
+pub fn build_colors(writer: &mut File) {
+    use std::io::{BufRead, BufReader, Write};
 
     let reader =
         BufReader::new(File::open("build/svg_colors.txt").expect("could not open svg_colors.txt"));
-    let mut writer = File::create(dest_path).expect("couldn't create named.rs");
     let mut entries = vec![];
 
     for line in reader.lines() {
@@ -40,7 +47,56 @@ pub fn build() {
         entries.push((name.to_owned(), name.to_uppercase()));
     }
 
-    gen_from_str(&mut writer, &entries)
+    gen_from_str(writer, &entries)
+}
+
+#[cfg(feature = "named_gradients")]
+pub fn build_gradients(writer: &mut File) {
+    use std::io::{BufRead, BufReader, Write};
+
+    let reader =
+        BufReader::new(File::open("build/svg_gradients_mpl.txt").expect("could not open svg_gradients_mpl.txt"));
+
+    let mut line_iter = reader.lines();
+    while let Some(Ok(line)) = line_iter.next(){
+        //empty lines are allowed
+        if line.is_empty() {continue;}
+        let mut parts = line.split_whitespace();
+        //every line should have the same info: name type number_of_colors [\n red green blue]^number_of_colors
+        let name = parts.next().expect("couldn't get the color name");
+        let color_type = parts.next().expect("couldn't get the type of the colors");
+        //we assume that color_type is a rgb type
+        let color_type = format!("crate::rgb::{}", color_type);
+        let number_of_colors : usize = parts.next().expect("couldn't get the number of colors")
+            .parse().unwrap_or_else(|_| panic!("couldn't parse the number of colors for color {}", name));
+        writeln!(writer, "/// New matplotlib colormap by Nathaniel J. Smith, Stefan van der Walt, and (in the case of viridis) Eric Firing.").unwrap();
+        writeln!(writer, "/// This gradient is perfectly perceptually-uniform, both in regular form and also when converted to black-and-white.").unwrap();
+        //writeln!(writer, "/// The colormap is released under the CC0 license public domain dedication.").unwrap();
+        write!(writer,
+            "pub const {0}: crate::gradient::Gradient<{1}, [(f32,{1});{2}]> = crate::gradient::Gradient([",
+            name.to_uppercase(), color_type, number_of_colors).unwrap();
+        for i in 0..number_of_colors {
+            let color = line_iter
+                .next()
+                .unwrap_or_else(|| panic!("less lines than stated colors in gradient {}", name))
+                .unwrap_or_else(|_| panic!("couldn't read the {}th line of color {}", i, name));
+            let mut rgb = color.split(",");
+            let red: f32 = rgb
+                .next()
+                .and_then(|r| r.trim().parse().ok())
+                .unwrap_or_else(|| panic!("couldn't get the {}th red-value for {}", i, name));
+            let green: f32 = rgb
+                .next()
+                .and_then(|r| r.trim().parse().ok())
+                .unwrap_or_else(|| panic!("couldn't get the {}th green-value for {}", i, name));
+            let blue: f32 = rgb
+                .next()
+                .and_then(|r| r.trim().parse().ok())
+                .unwrap_or_else(|| panic!("couldn't get the {}th blue-value for {}", i, name));
+            write!(writer, "({:.10},{}{{red: {}, green: {}, blue: {}, standard: ::core::marker::PhantomData}}),", (i as f32/number_of_colors as f32), color_type, red, green, blue).unwrap();
+        }
+        write!(writer, "]);\n").unwrap();
+    }
 }
 
 #[cfg(feature = "named_from_str")]
@@ -60,8 +116,12 @@ fn gen_from_str(writer: &mut File, entries: &[(String, String)]) {
 }
 
 #[cfg(not(feature = "named"))]
-pub fn build() {}
+pub fn build_colors(_writer: &mut File) {}
 
 #[allow(unused)]
 #[cfg(not(feature = "named_from_str"))]
 fn gen_from_str(_writer: &mut File, _entries: &[(String, String)]) {}
+
+#[allow(unused)]
+#[cfg(not(feature = "named_gradients"))]
+pub fn build_gradients(_writer: &mut File) {}