Readd option to configure DPI (#69)

Author: LaurenzV

CHANGELOG.md

@@ -7,18 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 - Added support for text embedding.
-- Added a `text` feature flag.
+- Made the CLI more flexible in terms of which features you want to include.
+- Added `raster-scale` and `text-to-paths` as arguments for the CLI.
+- Removed the option to configure the view box from the API. This might be readded in 
+ a later update.
 - The `convert_str` method has been removed. You should now always convert your SVG string into a `usvg` 
  tree yourself and then call either `to_pdf` or `to_chunk`.
 - The `convert_tree` method has been renamed into `to_pdf`, and now requires you to provide the fontdb
  used for the `usvg` tree, unless you have disabled the `text` feature.
 - `convert_tree_into` has been renamed into `to_chunk` and now returns an independent chunk as well
  as the object ID of the actual SVG in the chunk.
 
-- TODO: The CLI options have been (temporarily) removed. They will be readded before the next release.
-- TODO: Add tests for CLI and svg options
-- TODO: Add CLI option to convert text to paths.
-
 ### Changed
 - Bumped resvg to v0.40.
 - `convert_str` now requires a `fontdb` as an argument as well.

Cargo.toml

@@ -25,10 +25,10 @@ oxipng = { version = "9", default-features = false, features = ["filetime", "par
 pdf-writer = "0.9"
 pdfium-render = "0.8.6"
 termcolor = "1.2"
-usvg = "0.41"
+usvg = { version = "0.41", default-features = false }
 tiny-skia = "0.11.4"
 unicode-properties = "0.1.1"
-resvg = "0.41"
+resvg = { version = "0.41", default-features = false }
 subsetter = "0.1.1"
 ttf-parser = { version = "0.20.0" }
 siphasher = { version = "1.0.1"}

cli/src/args.rs

@@ -19,6 +19,13 @@ pub struct CliArguments {
     /// The number of SVG pixels per PDF points.
     #[clap(long, default_value = "72.0")]
     pub dpi: f32,
+    /// Whether text should be converted to paths
+    /// before embedding it into the PDF.
+    #[clap(long, short, action=ArgAction::SetTrue)]
+    pub text_to_paths: bool,
+    /// How much raster images of rasterized effects should be scaled up.
+    #[clap(long, default_value = "1.5")]
+    pub raster_scale: f32,
 }
 
 // What to do.
@@ -29,21 +36,6 @@ pub enum Command {
     Fonts(FontsCommand),
 }
 
-/// Lists all discovered fonts in system.
-#[derive(Debug, Clone, Parser)]
-pub struct ConvertCommand {
-    /// Path to read SVG file from.
-    pub input: PathBuf,
-    /// Path to write PDF file to.
-    pub output: Option<PathBuf>,
-    /// The number of SVG pixels per PDF points.
-    #[clap(long, default_value = "72.0")]
-    pub dpi: f32,
-    // How much rasterized effects should be scaled up.
-    #[clap(long, default_value = "1.0")]
-    pub raster_scale: f32,
-}
-
 /// Lists all discovered fonts in system.
 #[derive(Debug, Clone, Parser)]
 pub struct FontsCommand {

cli/src/convert.rs

@@ -1,13 +1,12 @@
-use crate::args::ConvertCommand;
 use std::path::{Path, PathBuf};
-use svg2pdf::Options;
-
-/// Execute a font listing command.
-pub fn _convert(command: ConvertCommand) -> Result<(), String> {
-    convert_(&command.input, command.output)
-}
-
-pub fn convert_(input: &PathBuf, output: Option<PathBuf>) -> Result<(), String> {
+use svg2pdf::{ConversionOptions, PageOptions};
+
+pub fn convert_(
+    input: &PathBuf,
+    output: Option<PathBuf>,
+    conversion_options: ConversionOptions,
+    page_options: PageOptions,
+) -> Result<(), String> {
     if let Ok(()) = log::set_logger(&LOGGER) {
         log::set_max_level(log::LevelFilter::Warn);
     }
@@ -40,7 +39,8 @@ pub fn convert_(input: &PathBuf, output: Option<PathBuf>) -> Result<(), String>
 
     let pdf = svg2pdf::to_pdf(
         &tree,
-        Options::default(),
+        conversion_options,
+        page_options,
         #[cfg(feature = "text")]
         &fontdb,
     );

cli/src/main.rs

@@ -8,6 +8,7 @@ use std::{
     io::{self, Write},
     process,
 };
+use svg2pdf::{ConversionOptions, PageOptions};
 use termcolor::{ColorChoice, ColorSpec, StandardStream, WriteColor};
 
 fn main() {
@@ -22,7 +23,15 @@ fn run() -> Result<(), String> {
 
     // If an input argument was provided, convert the svg file to pdf.
     if let Some(input) = args.input {
-        return convert::convert_(&input, args.output);
+        let conversion_options = ConversionOptions {
+            compress: true,
+            embed_text: !args.text_to_paths,
+            raster_scale: args.raster_scale,
+        };
+
+        let page_options = PageOptions { dpi: args.dpi };
+
+        return convert::convert_(&input, args.output, conversion_options, page_options);
     };
 
     // Otherwise execute the command provided if any.

src/lib.rs

@@ -15,7 +15,7 @@ This example reads an SVG file and writes the corresponding PDF back to the disk
 ```
 # fn main() -> Result<(), Box<dyn std::error::Error>> {
 use svg2pdf::usvg::fontdb;
-use svg2pdf::Options;
+use svg2pdf::{ConversionOptions, PageOptions};
 
 let input = "tests/svg/custom/integration/matplotlib/stairs.svg";
 let output = "target/stairs.pdf";
@@ -26,7 +26,7 @@ let mut db = fontdb::Database::new();
 db.load_system_fonts();
 let tree = svg2pdf::usvg::Tree::from_str(&svg, &options, &db)?;
 
-let pdf = svg2pdf::to_pdf(&tree, Options::default(), &db);
+let pdf = svg2pdf::to_pdf(&tree, ConversionOptions::default(), PageOptions::default(), &db);
 std::fs::write(output, pdf)?;
 # Ok(()) }
 ```
@@ -59,14 +59,14 @@ mod util;
 pub use usvg;
 
 use once_cell::sync::Lazy;
-use pdf_writer::{Chunk, Content, Filter, Finish, Pdf, Rect, Ref, TextStr};
+use pdf_writer::{Chunk, Content, Filter, Finish, Pdf, Ref, TextStr};
 #[cfg(feature = "text")]
 use usvg::fontdb;
-use usvg::Tree;
+use usvg::{Size, Transform, Tree};
 
 use crate::render::{tree_to_stream, tree_to_xobject};
 use crate::util::context::Context;
-use crate::util::helper::deflate;
+use crate::util::helper::{deflate, RectExt, TransformExt};
 use crate::util::resources::ResourceContainer;
 
 // The ICC profiles.
@@ -75,9 +75,24 @@ static SRGB_ICC_DEFLATED: Lazy<Vec<u8>> =
 static GRAY_ICC_DEFLATED: Lazy<Vec<u8>> =
     Lazy::new(|| deflate(include_bytes!("icc/sGrey-v4.icc")));
 
-/// Preferences for the PDF conversion.
+/// Options for the resulting PDF file.
 #[derive(Copy, Clone)]
-pub struct Options {
+pub struct PageOptions {
+    /// The DPI that should be assumed for the conversion to PDF.
+    ///
+    /// _Default:_ 72.0
+    pub dpi: f32,
+}
+
+impl Default for PageOptions {
+    fn default() -> Self {
+        Self { dpi: 72.0 }
+    }
+}
+
+/// Options for the PDF conversion.
+#[derive(Copy, Clone)]
+pub struct ConversionOptions {
     /// Whether the content streams should be compressed.
     ///
     /// The smaller PDFs generated by this are generally more practical, but it
@@ -102,7 +117,7 @@ pub struct Options {
     pub embed_text: bool,
 }
 
-impl Default for Options {
+impl Default for ConversionOptions {
     fn default() -> Self {
         Self {
             compress: false,
@@ -124,7 +139,7 @@ impl Default for Options {
 /// ```
 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
 /// use svg2pdf::usvg::fontdb;
-/// use svg2pdf::Options;
+/// use svg2pdf::{ConversionOptions, PageOptions};
 ///
 /// let input = "tests/svg/custom/integration/matplotlib/stairs.svg";
 /// let output = "target/stairs.pdf";
@@ -136,24 +151,31 @@ impl Default for Options {
 /// let mut tree = svg2pdf::usvg::Tree::from_str(&svg, &options, &db)?;
 ///
 ///
-/// let pdf = svg2pdf::to_pdf(&tree, Options::default(), &db);
+/// let pdf = svg2pdf::to_pdf(&tree, ConversionOptions::default(), PageOptions::default(), &db);
 /// std::fs::write(output, pdf)?;
 /// # Ok(()) }
 /// ```
 pub fn to_pdf(
     tree: &Tree,
-    options: Options,
+    conversion_options: ConversionOptions,
+    page_options: PageOptions,
     #[cfg(feature = "text")] fontdb: &fontdb::Database,
 ) -> Vec<u8> {
     let mut ctx = Context::new(
         #[cfg(feature = "text")]
         tree,
-        options,
+        conversion_options,
         #[cfg(feature = "text")]
         fontdb,
     );
     let mut pdf = Pdf::new();
 
+    let dpi_ratio = 72.0 / page_options.dpi;
+    let dpi_transform = Transform::from_scale(dpi_ratio, dpi_ratio);
+    let page_size =
+        Size::from_wh(tree.size().width() * dpi_ratio, tree.size().height() * dpi_ratio)
+            .unwrap();
+
     let catalog_ref = ctx.alloc_ref();
     let page_tree_ref = ctx.alloc_ref();
     let page_ref = ctx.alloc_ref();
@@ -165,7 +187,10 @@ pub fn to_pdf(
     // Generate main content
     let mut rc = ResourceContainer::new();
     let mut content = Content::new();
+    content.save_state();
+    content.transform(dpi_transform.to_pdf_transform());
     tree_to_stream(tree, &mut pdf, &mut content, &mut ctx, &mut rc);
+    content.restore_state();
     let content_stream = ctx.finish_content(content);
     let mut stream = pdf.stream(content_ref, &content_stream);
 
@@ -179,7 +204,7 @@ pub fn to_pdf(
     rc.finish(&mut page_resources);
     page_resources.finish();
 
-    page.media_box(Rect::new(0.0, 0.0, tree.size().width(), tree.size().height()));
+    page.media_box(page_size.to_non_zero_rect(0.0, 0.0).to_pdf_rect());
     page.parent(page_tree_ref);
     page.group()
         .transparency()
@@ -240,7 +265,7 @@ pub fn to_pdf(
 /// let mut db = fontdb::Database::new();
 /// db.load_system_fonts();
 /// let tree = svg2pdf::usvg::Tree::from_str(&svg, &svg2pdf::usvg::Options::default(), &db)?;
-/// let (mut svg_chunk, svg_id) = svg2pdf::to_chunk(&tree, svg2pdf::Options::default(), &db);
+/// let (mut svg_chunk, svg_id) = svg2pdf::to_chunk(&tree, svg2pdf::ConversionOptions::default(), &db);
 ///
 /// // Renumber the chunk so that we can embed it into our existing workflow, and also make sure
 /// // to update `svg_id`.
@@ -297,15 +322,15 @@ pub fn to_pdf(
 /// ```
 pub fn to_chunk(
     tree: &Tree,
-    options: Options,
+    conversion_options: ConversionOptions,
     #[cfg(feature = "text")] fontdb: &fontdb::Database,
 ) -> (Chunk, Ref) {
     let mut chunk = Chunk::new();
 
     let mut ctx = Context::new(
         #[cfg(feature = "text")]
         tree,
-        options,
+        conversion_options,
         #[cfg(feature = "text")]
         fontdb,
     );

src/util/context.rs

@@ -12,12 +12,12 @@ use {
 
 use super::helper::deflate;
 use crate::util::allocate::RefAllocator;
-use crate::{Options, GRAY_ICC_DEFLATED, SRGB_ICC_DEFLATED};
+use crate::{ConversionOptions, GRAY_ICC_DEFLATED, SRGB_ICC_DEFLATED};
 
 /// Holds all of the necessary information for the conversion process.
 pub struct Context {
     /// Options that where passed by the user.
-    pub options: Options,
+    pub options: ConversionOptions,
     /// The refs of the fonts
     #[cfg(feature = "text")]
     pub fonts: HashMap<ID, Option<Font>>,
@@ -29,7 +29,11 @@ pub struct Context {
 impl Context {
     /// Create a new context.
     #[cfg(feature = "text")]
-    pub fn new(tree: &Tree, options: Options, fontdb: &fontdb::Database) -> Self {
+    pub fn new(
+        tree: &Tree,
+        options: ConversionOptions,
+        fontdb: &fontdb::Database,
+    ) -> Self {
         let mut ctx = Self {
             ref_allocator: RefAllocator::new(),
             options,
@@ -48,7 +52,7 @@ impl Context {
     // TODO: Make context less ugly with different features.
     /// Create a new context.
     #[cfg(not(feature = "text"))]
-    pub fn new(options: Options) -> Self {
+    pub fn new(options: ConversionOptions) -> Self {
         Self {
             ref_allocator: RefAllocator::new(),
             options,
@@ -109,7 +113,7 @@ impl Context {
     }
 
     /// Just a helper method so that we don't have to manually compress the content if this was
-    /// set in the [Options] struct.
+    /// set in the [ConversionOptions] struct.
     pub fn finish_content(&self, content: Content) -> Vec<u8> {
         if self.options.compress {
             deflate(&content.finish())

tests/ref/api/dpi.png

@@ -5,19 +5,33 @@ use {
     pdf_writer::{Content, Finish, Name, Pdf, Rect, Ref, Str},
     std::collections::HashMap,
     std::path::Path,
-    svg2pdf::Options,
+    svg2pdf::ConversionOptions,
+    svg2pdf::PageOptions,
 };
 
 #[test]
 fn text_to_paths() {
-    let options = Options { embed_text: false, ..Options::default() };
+    let options = ConversionOptions { embed_text: false, ..ConversionOptions::default() };
 
     let svg_path = "svg/resvg/text/text/simple-case.svg";
-    let (pdf, actual_image) = convert_svg(Path::new(svg_path), options);
+    let (pdf, actual_image) =
+        convert_svg(Path::new(svg_path), options, PageOptions::default());
     let res = run_test_impl(pdf, actual_image, "api/text_to_paths");
     assert_eq!(res, 0);
 }
 
+#[test]
+fn dpi() {
+    let conversion_options = ConversionOptions::default();
+    let page_options = PageOptions { dpi: 140.0 };
+
+    let svg_path = "svg/resvg/text/text/simple-case.svg";
+    let (pdf, actual_image) =
+        convert_svg(Path::new(svg_path), conversion_options, page_options);
+    let res = run_test_impl(pdf, actual_image, "api/dpi");
+    assert_eq!(res, 0);
+}
+
 #[test]
 fn to_chunk() {
     let mut alloc = Ref::new(1);
@@ -36,7 +50,8 @@ fn to_chunk() {
     let tree =
         svg2pdf::usvg::Tree::from_str(&svg, &svg2pdf::usvg::Options::default(), &db)
             .unwrap();
-    let (svg_chunk, svg_id) = svg2pdf::to_chunk(&tree, svg2pdf::Options::default(), &db);
+    let (svg_chunk, svg_id) =
+        svg2pdf::to_chunk(&tree, svg2pdf::ConversionOptions::default(), &db);
 
     let mut map = HashMap::new();
     let svg_chunk =