svg2img 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d79ded4df5c7da3f90781d4a55545909261183b4ab6759baf2e20094ca48011
-  data.tar.gz: d2bb132f2fa76a9f7e2754d37615afe67f111cb9e96b2534e298233620d21c05
+  metadata.gz: 18e78e2be604a584bdf8e325b2f007b46505e6d2d74cd584d55fa460aecc31d5
+  data.tar.gz: 6bacef7baabce46157cbc3d1af5dbefaae727e8726a1f35495c2d35f1d54cff1
 SHA512:
-  metadata.gz: ee228f18a63c3b04969e8b3188b5b3a0c9b9a1a0c8cd3b89d0a8485e87ef27490aebe39cf9ef22944a8185a9540086569d0402b0b4da570a579289740dfbb706
-  data.tar.gz: 06dc50fca47cce15698f4f1ab07b9d794986e3f141ba077586916a3e64c4afd7c84bd10655bb7af702da2f8f20dbb75619ed7d934bada4aa8dad35d7d138eb1e
+  metadata.gz: 1c34f340977be8cdf8c4fd8e2a49e15a5409bdbcb770d555bc984d085ee1e5de95d16f37584d06ff49fb4c3b72b50d1c7ef23393e2178a9024b5821dc14a202f
+  data.tar.gz: 1126a561399fb919c61ea017d7cd1d910ab4422ab51c568bf9482e7c421b9d56e532658dc722b293264fc3b67cbf2701c1d7e0b605f1c2a0e3205915c340c4e8

data/README.md

@@ -40,6 +40,11 @@ bundle lock --add-platform arm64-darwin # Apple Silicon MacOS  (i.e. M1)
 
 ## Usage
 
+```ruby
+require "svg2img"
+Svg2Img.process_svg(svg_string, options)
+```
+
 Example usage:
 
 ```ruby
@@ -50,12 +55,12 @@ circle_svg = <<~SVG
     <circle cx="50" cy="50" r="40" stroke="black" stroke-width="3" fill="red" />
   </svg>
 SVG
-png_path = Svg2Img.process_svg(circle_svg, output_format: :png)
+png_path = Svg2Img.process_svg(circle_svg, format: :png)
 # png_path is a path to the generated PNG file
 
 # Rails example
 data = Rails.cache.fetch([some, deps]) do
-  png_path = Svg2Img.process_svg(circle_svg, output_format: :png)
+  png_path = Svg2Img.process_svg(circle_svg, format: :png, size: proc {|_svg_width, _svg_height| [256, 256]})
   png_data = File.binread(png_path)
   File.delete(png_path)
   png_data
@@ -63,6 +68,12 @@ end
 send_data(png_data, type: 'image/png', disposition: 'inline')
 ```
 
+### Options
+
+- `format` - output format, one of `:png`, `:jpg`, `:webp`, `:gif`
+- `output_path` - path to the output image. If not provided, a temporary file will be created and the path to it will be returned.
+- `size` - size of the output image as a proc that receives the width and height of the SVG and returns an array with the width and height of the output image. If the provides size has a different aspect ratio than the SVG, the image will be resized to fit in the center of the provided size. If not provided, the output image will have the same size as the SVG.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/ext/svg2img/src/lib.rs

@@ -1,6 +1,6 @@
 use anyhow::Context;
-use image::{DynamicImage, GenericImageView, ImageBuffer};
-use magnus::{function, prelude::*, Error, Ruby};
+use image::{DynamicImage, ImageBuffer};
+use magnus::{block::Proc, function, prelude::*, Error, Ruby};
 use std::panic::{self, AssertUnwindSafe};
 
 #[magnus::init]
@@ -28,8 +28,9 @@ fn process_svg_rb(svg: String, options: magnus::RHash) -> Result<String, magnus:
         };
     }
     let options = Options {
-        max_width: get_option(&options, "max_width")?,
-        max_height: get_option(&options, "max_height")?,
+        size: get_option::<Proc>(&options, "size")?
+            .map(convert_size_proc)
+            .unwrap_or_else(default_size),
         format,
         output_path: get_option(&options, "output_path")?,
     };
@@ -76,32 +77,30 @@ fn get_string_option(options: &magnus::RHash, key: &str) -> Result<Option<String
     Ok(None)
 }
 
+type ProcessSize = Box<dyn FnOnce(u32, u32) -> Result<(u32, u32), anyhow::Error>>;
+fn default_size() -> ProcessSize {
+    Box::new(|width, height| Ok((width, height)))
+}
+fn convert_size_proc(proc: Proc) -> ProcessSize {
+    Box::new(move |width, height| {
+        let result: Result<(i64, i64), magnus::Error> = proc.call((width as i64, height as i64));
+        match result {
+            Ok((width, height)) => Ok((width as u32, height as u32)),
+            Err(err) => Err(anyhow::anyhow!(
+                "svg2img: Failed to call size proc: {err:?}"
+            )),
+        }
+    })
+}
+
 struct Options {
-    max_width: Option<u32>,
-    max_height: Option<u32>,
+    size: ProcessSize,
     format: image::ImageFormat,
     output_path: Option<String>,
 }
 
 fn process_svg(svg: String, options: Options) -> Result<String, anyhow::Error> {
-    let image = image_from_svg(svg.as_bytes())?;
-    let (old_width, old_height) = image.dimensions();
-
-    let (mut width, mut height) = (old_width, old_height);
-    if let Some(max_width) = options.max_width {
-        if width > max_width {
-            height = height * max_width / width;
-            width = max_width;
-        }
-    }
-    if let Some(max_height) = options.max_height {
-        if height > max_height {
-            width = width * max_height / height;
-            height = max_height;
-        }
-    }
-
-    let mut image = image.resize_exact(width, height, image::imageops::FilterType::Lanczos3);
+    let mut image = image_from_svg(svg.as_bytes(), options.size)?;
 
     if options.format == image::ImageFormat::Jpeg {
         // Convert from rgba8 to rgb8
@@ -134,36 +133,56 @@ fn process_svg(svg: String, options: Options) -> Result<String, anyhow::Error> {
     Ok(output_path)
 }
 
-fn image_from_svg(bytes: &[u8]) -> Result<DynamicImage, anyhow::Error> {
-    let tree = resvg::usvg::Tree::from_data(bytes, &resvg::usvg::Options::default())
+fn image_from_svg(bytes: &[u8], size: ProcessSize) -> Result<DynamicImage, anyhow::Error> {
+    let svg = resvg::usvg::Tree::from_data(bytes, &resvg::usvg::Options::default())
         .context("Failed to parse SVG")?;
+    let svg_width = svg.size().width();
+    let svg_height = svg.size().height();
+    let svg_ratio = svg_width / svg_height;
 
-    const TARGET_SIZE: u32 = 512;
-    let mut pixmap = resvg::tiny_skia::Pixmap::new(TARGET_SIZE, TARGET_SIZE)
-        .context("Failed to create Pixmap for SVG rendering")?;
-    let ratio = tree.size().width() / tree.size().height();
-    let scaled_width = if ratio > 1.0 {
-        TARGET_SIZE
-    } else {
-        (TARGET_SIZE as f32 * ratio).round() as u32
-    };
-    let scaled_height = if ratio > 1.0 {
-        (TARGET_SIZE as f32 / ratio).round() as u32
+    let (image_width, image_height) = size(svg_width as u32, svg_height as u32)?;
+    let image_ratio = image_width as f32 / image_height as f32;
+
+    let scale = if svg_ratio > image_ratio {
+        image_width as f32 / svg_width
     } else {
-        TARGET_SIZE
+        image_height as f32 / svg_height
     };
+    let rendered_width = svg_width * scale;
+    let rendered_height = svg_height * scale;
+    let tx = (image_width as f32 - rendered_width) / 2.0;
+    let ty = (image_height as f32 - rendered_height) / 2.0;
+
+    // panic!(
+    //     r#"
+    //     svg_width: {svg_width}
+    //     svg_height: {svg_height}
+    //     svg_ratio: {svg_ratio}
+    //     image_width: {image_width}
+    //     image_height: {image_height}
+    //     image_ratio: {image_ratio}
+    //     rendered_width: {rendered_width}
+    //     rendered_height: {rendered_height}
+    //     scale: {scale}
+    //     tx: {tx}
+    //     ty: {ty}
+    // "#
+    // );
 
     // Scale svg and place it centered
-    let transform = resvg::tiny_skia::Transform {
-        sx: scaled_width as f32 / tree.size().width(),
-        sy: scaled_height as f32 / tree.size().height(),
-        tx: (TARGET_SIZE - scaled_width) as f32 / 2.0,
-        ty: (TARGET_SIZE - scaled_height) as f32 / 2.0,
+    let transform: resvg::usvg::Transform = resvg::tiny_skia::Transform {
+        sx: scale,
+        sy: scale,
+        tx,
+        ty,
         ..Default::default()
     };
 
+    let mut pixmap = resvg::tiny_skia::Pixmap::new(image_width, image_height)
+        .context("Failed to create Pixmap for SVG rendering")?;
+
     let result = panic::catch_unwind(AssertUnwindSafe(|| {
-        resvg::render(&tree, transform, &mut pixmap.as_mut());
+        resvg::render(&svg, transform, &mut pixmap.as_mut());
     }));
     if let Err(panic) = result {
         let panic_message = panic
@@ -178,10 +197,10 @@ fn image_from_svg(bytes: &[u8]) -> Result<DynamicImage, anyhow::Error> {
         return Err(anyhow::anyhow!("SVG rendering panicked: {}", panic_message));
     }
 
-    rgba_to_image(pixmap.width(), pixmap.height(), pixmap.data())
+    pixmap_to_image(pixmap.width(), pixmap.height(), pixmap.data())
 }
 
-fn rgba_to_image(width: u32, height: u32, data: &[u8]) -> Result<DynamicImage, anyhow::Error> {
+fn pixmap_to_image(width: u32, height: u32, data: &[u8]) -> Result<DynamicImage, anyhow::Error> {
     let mut image_data = Vec::with_capacity((width * height * 4) as usize);
     for pixel in data.chunks(4) {
         image_data.push(pixel[0]); // R

data/lib/svg2img/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Svg2Img
-  VERSION = "0.1.1"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: svg2img
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Orvar Segerström
@@ -44,9 +44,6 @@ files:
 - tmp/arm64-darwin23/stage/Cargo.lock
 - tmp/arm64-darwin23/stage/Cargo.toml
 - tmp/arm64-darwin23/stage/ext/svg2img/Cargo.toml
-- tmp/arm64-darwin23/stage/tmp/arm64-darwin23/stage/Cargo.lock
-- tmp/arm64-darwin23/stage/tmp/arm64-darwin23/stage/Cargo.toml
-- tmp/arm64-darwin23/stage/tmp/arm64-darwin23/stage/ext/svg2img/Cargo.toml
 homepage: https://github.com/0rvar/svg2img-rb
 licenses:
 - MIT