Bump edition and usvg

Co-Authored-By: Martin <[email protected]>

Author: laurmaedje

Cargo.toml

@@ -2,7 +2,7 @@
 name = "svg2pdf"
 version = "0.1.0"
 authors = ["Martin Haug <[email protected]>"]
-edition = "2018"
+edition = "2021"
 description = "Convert SVG files to PDFs."
 repository = "https://github.com/typst/svg2pdf"
 readme = "README.md"
@@ -11,14 +11,12 @@ categories = ["encoding", "graphics", "multimedia"]
 keywords = ["svg", "pdf", "vector-graphics", "conversion"]
 
 [features]
-default = ["png", "jpeg", "text", "system-fonts"]
+default = ["png", "jpeg", "text"]
 png = ["image/png"]
 jpeg = ["image/jpeg"]
-text = ["usvg/text"]
-system-fonts = ["usvg/system-fonts", "usvg/memmap-fonts"]
 
 [dependencies]
-image = { version = "0.23", default-features = false, optional = true }
 miniz_oxide = "0.4"
 pdf-writer = "0.4.1"
-usvg = { version = "0.19", default-features = false }
+usvg = { version = "0.20", default-features = false }
+image = { version = "0.23", default-features = false, optional = true }

src/defer.rs

@@ -164,7 +164,7 @@ pub fn write_gradients(
         shading.shading_type(pending.shading_type);
         shading.color_space().srgb();
         shading.function(func);
-        shading.coords(IntoIterator::into_iter(pending.coords).take(
+        shading.coords(pending.coords.into_iter().take(
             if pending.shading_type == ShadingType::Axial {
                 4
             } else {

src/lib.rs

@@ -40,7 +40,7 @@ use std::collections::HashMap;
 use pdf_writer::types::ProcSet;
 use pdf_writer::writers::{ColorSpace, ExponentialFunction, FormXObject, Resources};
 use pdf_writer::{Content, Finish, Name, PdfWriter, Rect, Ref, TextStr, Writer};
-use usvg::{NodeExt, NodeKind, Stop, Tree};
+use usvg::{NodeExt, NodeKind, Opacity, Stop, Tree};
 
 mod defer;
 mod render;
@@ -234,6 +234,11 @@ impl<'a> Context<'a> {
 
 /// Convert an SVG source string to a standalone PDF buffer.
 ///
+/// Does not load any fonts and consequently cannot convert `text` elements. To
+/// convert text, you should convert your source string to a usvg [`Tree`]
+/// manually (providing a [font database](usvg::Options::fontdb)) and then use
+/// [`convert_tree`].
+///
 /// Returns an error if the SVG string is malformed.
 pub fn convert_str(src: &str, options: Options) -> Result<Vec<u8>, usvg::Error> {
     let mut usvg_opts = usvg::Options::default();
@@ -545,31 +550,24 @@ fn apply_mask(
 
 /// A color helper function that stores colors with values between 0.0 and 1.0.
 #[derive(Debug, Clone, Copy)]
-struct RgbaColor {
+struct RgbColor {
     /// Red.
     r: f32,
     /// Green.
     g: f32,
     /// Blue.
     b: f32,
-    /// Alpha.
-    a: f32,
 }
 
-impl RgbaColor {
+impl RgbColor {
     /// Create a new color.
-    fn new(r: f32, g: f32, b: f32, a: f32) -> RgbaColor {
-        RgbaColor { r, g, b, a }
+    fn new(r: f32, g: f32, b: f32) -> RgbColor {
+        RgbColor { r, g, b }
     }
 
     /// Create a new color from u8 color components between 0.0 and 255.0.
-    fn from_u8(r: u8, g: u8, b: u8, a: u8) -> RgbaColor {
-        RgbaColor::new(
-            r as f32 / 255.0,
-            g as f32 / 255.0,
-            b as f32 / 255.0,
-            a as f32 / 255.0,
-        )
+    fn from_u8(r: u8, g: u8, b: u8) -> RgbColor {
+        RgbColor::new(r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0)
     }
 
     /// Create a RGB array for use in PDF.
@@ -578,9 +576,9 @@ impl RgbaColor {
     }
 }
 
-impl From<usvg::Color> for RgbaColor {
+impl From<usvg::Color> for RgbColor {
     fn from(color: usvg::Color) -> Self {
-        Self::from_u8(color.red, color.green, color.blue, color.alpha)
+        Self::from_u8(color.red, color.green, color.blue)
     }
 }
 
@@ -595,22 +593,9 @@ fn register_functions(
     let func_ref = ctx.alloc_ref();
     stops_to_function(writer, func_ref, stops, false);
 
-    let alpha_ref = if stops
-        .iter()
-        .any(|stop| stop.opacity.value() < 1.0 || stop.color.alpha < 255)
-    {
-        let stops = stops
-            .iter()
-            .cloned()
-            .map(|mut stop| {
-                stop.color.alpha = (stop.color.alpha as f64 * stop.opacity.value()) as u8;
-                stop
-            })
-            .collect::<Vec<_>>();
-
+    let alpha_ref = if stops.iter().any(|stop| stop.opacity.value() < 1.0) {
         let alpha_ref = ctx.alloc_ref();
         stops_to_function(writer, alpha_ref, &stops, true);
-
         Some(alpha_ref)
     } else {
         None
@@ -626,32 +611,34 @@ fn stops_to_function(
     stops: &[Stop],
     alpha: bool,
 ) -> bool {
-    let range =
-        IntoIterator::into_iter([0.0f32, 1.0f32])
-            .cycle()
-            .take(if alpha { 2 } else { 6 });
-
-    let set_colors =
-        |exp: &mut ExponentialFunction, a_color: RgbaColor, b_color: RgbaColor| {
-            if alpha {
-                exp.c0([a_color.a]);
-                exp.c1([b_color.a]);
-            } else {
-                exp.c0(a_color.to_array());
-                exp.c1(b_color.to_array());
-            }
+    let range = [0.0f32, 1.0f32].into_iter().cycle().take(if alpha { 2 } else { 6 });
+
+    let set_alphas =
+        |exp: &mut ExponentialFunction, a_alpha: Opacity, b_alpha: Opacity| {
+            exp.c0([a_alpha.value() as f32]);
+            exp.c1([b_alpha.value() as f32]);
+        };
+
+    let set_rgbs =
+        |exp: &mut ExponentialFunction, a_color: RgbColor, b_color: RgbColor| {
+            exp.c0(a_color.to_array());
+            exp.c1(b_color.to_array());
         };
 
     if stops.is_empty() {
         return false;
     } else if stops.len() == 1 {
         let mut exp = writer.exponential_function(id);
         let stop = stops[0];
-        let color = RgbaColor::from(stop.color);
+        let color = RgbColor::from(stop.color);
 
         exp.domain([0.0, 1.0]);
         exp.range(range);
-        set_colors(&mut exp, color, color);
+        if alpha {
+            set_alphas(&mut exp, stop.opacity, stop.opacity)
+        } else {
+            set_rgbs(&mut exp, color, color);
+        }
 
         exp.n(1.0);
         return true;
@@ -678,12 +665,16 @@ fn stops_to_function(
 
     for window in stops.windows(2) {
         let (a, b) = (window[0], window[1]);
-        let (a_color, b_color) = (RgbaColor::from(a.color), RgbaColor::from(b.color));
+        let (a_color, b_color) = (RgbColor::from(a.color), RgbColor::from(b.color));
         bounds.push(b.offset.value() as f32);
         let mut exp = ExponentialFunction::start(func_array.push());
         exp.domain([0.0, 1.0]);
         exp.range(range.clone());
-        set_colors(&mut exp, a_color, b_color);
+        if alpha {
+            set_alphas(&mut exp, a.opacity, b.opacity);
+        } else {
+            set_rgbs(&mut exp, a_color, b_color);
+        }
 
         exp.n(1.0);
 

src/render.rs

@@ -21,7 +21,7 @@ use {
 
 use super::{
     apply_clip_path, apply_mask, content_stream, form_xobject, Context, Options,
-    RgbaColor, SRGB,
+    RgbColor, SRGB,
 };
 use crate::convert_tree_into;
 use crate::defer::{PendingGS, PendingGradient};
@@ -165,22 +165,8 @@ fn render_path_partial(
     content.set_fill_color_space(ColorSpaceOperand::Named(SRGB));
     content.set_stroke_color_space(ColorSpaceOperand::Named(SRGB));
 
-    // Combine alpha and opacity values.
-    let stroke_opacity = path.stroke.as_ref().map(|s| {
-        let mut res = s.opacity.value() as f32;
-        if let Paint::Color(c) = s.paint {
-            res *= c.alpha as f32 / 255.0;
-        }
-        res
-    });
-
-    let fill_opacity = path.fill.as_ref().map(|f| {
-        let mut res = f.opacity.value() as f32;
-        if let Paint::Color(c) = f.paint {
-            res *= c.alpha as f32 / 255.0;
-        }
-        res
-    });
+    let stroke_opacity = path.stroke.as_ref().map(|s| s.opacity.value() as f32);
+    let fill_opacity = path.fill.as_ref().map(|f| f.opacity.value() as f32);
 
     // Write a graphics state for stroke and fill opacity.
     if stroke_opacity.unwrap_or(1.0) != 1.0 || fill_opacity.unwrap_or(1.0) != 1.0 {
@@ -219,7 +205,7 @@ fn render_path_partial(
 
             match &stroke.paint {
                 Paint::Color(c) => {
-                    content.set_stroke_color(RgbaColor::from(*c).to_array());
+                    content.set_stroke_color(RgbColor::from(*c).to_array());
                 }
                 Paint::Link(id) => {
                     let item = ctx.tree.defs_by_id(id).unwrap();
@@ -250,7 +236,7 @@ fn render_path_partial(
     if fill {
         match path.fill.as_ref().map(|fill| &fill.paint) {
             Some(Paint::Color(c)) => {
-                content.set_fill_color(RgbaColor::from(*c).to_array());
+                content.set_fill_color(RgbColor::from(*c).to_array());
             }
             Some(Paint::Link(id)) => {
                 let item = ctx.tree.defs_by_id(id).unwrap();
@@ -375,15 +361,13 @@ fn prep_shading(
     shading.shading_type(gradient.shading_type);
     shading.color_space().srgb_gray();
     shading.function(alpha_func);
-    shading.coords(
-        IntoIterator::into_iter(gradient.transformed_coords(&ctx.c, bbox)).take(
-            if gradient.shading_type == ShadingType::Axial {
-                4
-            } else {
-                6
-            },
-        ),
-    );
+    shading.coords(gradient.transformed_coords(&ctx.c, bbox).into_iter().take(
+        if gradient.shading_type == ShadingType::Axial {
+            4
+        } else {
+            6
+        },
+    ));
     shading.extend([true, true]);
     shading.finish();